slippi

package module
v0.0.0-...-f49cdc0 Latest Latest
Warning

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

 Go to latest Published: Oct 20, 2022 License: MIT Imports: 13 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Connect      ConnectionEventType = "connect"
	Message                          = "message"
	Handshake                        = "message"
	StatusChange                     = "statusChange"
	Data                             = "data"
	Error                            = "error"
)

ConnectionEvents

View Source 
const (
	Default    Port = 51441
	Legacy          = 666
	RelayStart      = 53741
)

Ports

View Source 
const (
	ConnectReply   DolphinMessageType = "connect_reply"
	ConnectRequest                    = "connect_request"
	MenuEvent                         = "menu_event"
	GameEvent                         = "game_event"
	StartGame                         = "start_game"
	EndGame                           = "end_game"
)

DolphinMessageTypes

View Source 
const (
	ItemsVeryLow = iota
	ItemsLow
	ItemsMedium
	ItemsHigh
	ItemsVeryHigh
	Items5
	Items6
	Items7
	Items8
	ItemsOff ItemSpawnBehavior = -1
)

ItemSpawnBehaviors

View Source 
const (
	Unresolved GameEndMethod = 0
	Time                     = 1
	Game                     = 2
	Resolved                 = 3
	NoContest                = 7
)

GameEndMethods

View Source 
const MaxPeers = 32
View Source 
const MaxRollbackFrames = 7

Variables

This section is empty.

Functions

func MakeUnboundedChannel 

func MakeUnboundedChannel[K any]() (chan<- *K, <-chan *K)

Types

type Command 

type Command byte

Command enumerates the command bytes of Slippi events. 

const (
	EventPayloads Command = iota + 0x35
	GameStart
	PreFrameUpdate
	PostFrameUpdate
	GameEnd
	FrameStart
	ItemUpdate
	FrameBookend
	GeckoList
	MessageSplitter Command = 0x10
)

/ Commands

type Connection 

type Connection interface {
	GetStatus() ConnectionStatus
	GetSettings() ConnectionSettings
	GetDetails() ConnectionDetails
	Connect(ip string, port uint16) error
	Disconnect()
}

type ConnectionDetails 

type ConnectionDetails struct {
	ConsoleNick    string
	GameDataCursor interface{}
	Version        string
	ClientToken    int
}

type ConnectionEvent 

type ConnectionEvent struct {
	Type    ConnectionEventType
	Payload interface{}
}

type ConnectionEventType 

type ConnectionEventType string

ConnectionEventType enumerates the possible connection events emitted by a connection

type ConnectionSettings 

type ConnectionSettings struct {
	IpAddress string
	Port      uint16
}

type ConnectionStatus 

type ConnectionStatus uint8

ConnectionStatus enumerates the possible states of a connection 

const (
	Disconnected ConnectionStatus = iota
	Connecting
	Connected
	ReconnectWait
)

ConnectionStatuses

type DashbackFix 

type DashbackFix uint32

DashbackFix enumerates the controller fixes for dashback. 

const (
	DBOff DashbackFix = iota
	DBUCF
	DBDween
)

DashbackFixes

type DolphinConnection 

type DolphinConnection struct {
	IpAddress        string
	Port             uint16
	ConnectionStatus ConnectionStatus
	GameCursor       int
	Nickname         string
	Version          string
	Peer             enet.ENetPeer
	// contains filtered or unexported fields
}

DolphinConnection represents a connection to an instance of Dolphin.

func NewDolphinConnection 

func NewDolphinConnection() *DolphinConnection

NewDolphinConnection returns a new DolphinConnection instance.

func (*DolphinConnection) Connect 

func (c *DolphinConnection) Connect(ip string, port uint16) (<-chan *ConnectionEvent, error)

Connect connects to a Dolphin instance on the given IP and port.

func (*DolphinConnection) Disconnect 

func (c *DolphinConnection) Disconnect()

func (*DolphinConnection) GetDetails 

func (c *DolphinConnection) GetDetails() ConnectionDetails

GetDetails gets the current details of the DolphinConnection.

func (*DolphinConnection) GetSettings 

func (c *DolphinConnection) GetSettings() ConnectionSettings

GetSettings gets the current settings of the DolphinConnection.

func (*DolphinConnection) GetStatus 

func (c *DolphinConnection) GetStatus() ConnectionStatus

GetStatus gets the current state of the DolphinConnection.

type DolphinMessage 

type DolphinMessage struct {
	Type       DolphinMessageType `json:"type"`
	Nick       string             `json:"nick,omitempty"`
	Version    string             `json:"version,omitempty"`
	Cursor     int                `json:"cursor"`
	NextCursor int                `json:"next_cursor,omitempty"`
	Payload    string             `json:"payload,omitempty"`
}

DolphinMessage represents a message sent from Dolphin to a client.

type DolphinMessageType 

type DolphinMessageType string

DolphinMessageType enumerates the types of messages Dolphin sends to a client.

type EventPayloadsPayload 

type EventPayloadsPayload struct {
	PayloadSize  uint8
	PayloadSizes map[uint8]uint16
}

EventPayloadsPayload represents the EventPayloads Slippi event.

type FrameBookendPayload 

type FrameBookendPayload struct {
	FrameNumber          int32
	LatestFinalizedFrame int32
}

FrameBookendPayload represents the FrameBookend Slippi event.

type FrameEntry 

type FrameEntry struct {
	Players            map[uint8]FrameUpdates
	Followers          map[uint8]FrameUpdates
	Items              []ItemUpdatePayload
	IsTransferComplete bool
}

A FrameEntry contains all relevant updates from a given frame.

type FrameStartPayload 

type FrameStartPayload struct {
	FrameNumber       int32
	RandomSeed        uint32
	SceneFrameCounter uint32
}

FrameStartPayload represents the FrameStart Slippi event.

type FrameUpdate 

type FrameUpdate struct {
	FrameNumber     int32
	PlayerIndex     uint8
	IsFollower      bool
	ActionStateID   uint16
	XPosition       float32
	YPosition       float32
	FacingDirection float32
	Percent         float32
}

FrameUpdate contains fields generic to pre- and post-frame update Slippi events.

type FrameUpdatePayload 

type FrameUpdatePayload interface {
	GetFrameUpdate() FrameUpdate
}

The FrameUpdatePayload is the interface that abstract pre- and post-frame updates to their shared FrameUpdate field.

type FrameUpdateType 

type FrameUpdateType string

FrameUpdateType enumerates the types of frame updates. 

const (
	Pre  FrameUpdateType = "pre"
	Post                 = "post"
)

FrameUpdateTypes

type FrameUpdates 

type FrameUpdates struct {
	Pre  *PreFrameUpdatePayload
	Post *PostFrameUpdatePayload
}

FrameUpdates holds pre- and post-frame updates.

type GameEndMethod 

type GameEndMethod uint8

GameEndMethod enumerates the game end methods in Melee.

type GameEndPayload 

type GameEndPayload struct {
	GameEndMethod GameEndMethod
	LRASInitiator int8
}

GameEndPayload represents the GameEnd Slippi event.

type GameInfo 

type GameInfo struct {
	Version    semver.Version
	Teams      bool
	PAL        bool
	Stage      uint16
	Players    []PlayerInfo
	MajorScene uint8
	MinorScene uint8
}

GameInfo contains the general information about a game of Melee.

type GameInfoBlock 

type GameInfoBlock struct {
	GameBitfield1          uint8
	GameBitfield2          uint8
	GameBitfield3          uint8
	GameBitfield4          uint8
	BombRain               uint8
	IsTeams                bool
	ItemSpawnBehavior      ItemSpawnBehavior
	SelfDestructScoreValue int8
	Stage                  uint16
	GameTimer              uint32
	ItemSpawnBitfield1     uint8
	ItemSpawnBitfield2     uint8
	ItemSpawnBitfield3     uint8
	ItemSpawnBitfield4     uint8
	ItemSpawnBitfield5     uint8
	DamageRatio            float32
}

GameInfoBlock contains the Melee game info block.

type GameStartPayload 

type GameStartPayload struct {
	Version        semver.Version
	GameInfoBlock  GameInfoBlock
	Players        [4]PlayerInfo
	RandomSeed     uint32
	PAL            bool
	FrozenPS       bool
	MajorScene     uint8
	MinorScene     uint8
	LanguageOption Language
}

GameStartPayload represents the GameStart Slippi event.

type GeckoListPayload 

type GeckoListPayload struct {
	GeckoCodes []byte
}

GeckoListPayload represents the GeckoList Slippi event.

type HurtboxCollisionState 

type HurtboxCollisionState uint8

HurtboxCollisionState enumerates possible hurtbox collision states. 

const (
	Vulnerable HurtboxCollisionState = iota
	Invulnerable
	Intangible
)

HurtboxCollisionStates

type InputType 

type InputType int

InputType enumerates possible slp data sources. 

const (
	SlpFile InputType = iota
	SlpBytes
)

InputTypes

type ItemSpawnBehavior 

type ItemSpawnBehavior int8

ItemSpawnBehavior enumerates item spawn frequencies.

type ItemUpdatePayload 

type ItemUpdatePayload struct {
	FrameNumber      int32
	TypeID           uint16
	State            uint8
	FacingDirection  float32
	XVelocity        float32
	YVelocity        float32
	XPosition        float32
	YPosition        float32
	DamageTaken      uint16
	ExpirationTimer  float32
	SpawnID          uint32
	SamusMissileType uint8
	PeachTurnipFace  uint8
	IsLaunched       uint8
	ChargedPower     uint8
	Owner            int8
}

ItemUpdatePayload represents the ItemUpdate Slippi event.

type LCancelStatus 

type LCancelStatus uint8

LCancelStatus enumerates possible L-Cancel statuses. 

const (
	None LCancelStatus = iota
	Successful
	Unsuccessful
)

LCancelStatuses

type Language 

type Language uint8

Language enumerates the language options. 

const (
	Japanese Language = iota
	English
)

Languages

type MessageSplitterPayload 

type MessageSplitterPayload struct {
	Data            [512]uint8
	DataLength      uint16
	InternalCommand uint8
	LastMessage     bool
}

MessageSplitterPayload represents the MessageSplitter Slippi event.

type Metadata 

type Metadata struct {
	StartAt     string                    `ubjson:"startAt"`
	LastFrame   int32                     `ubjson:"lastFrame"`
	Players     map[string]PlayerMetadata `ubjson:"players"`
	PlayedOn    string                    `ubjson:"playedOn"`
	ConsoleNick string                    `ubjson:"consoleNick"`
}

A Metadata contains metadata about a Slippi game.

type Names 

type Names struct {
	Netplay string `ubjson:"netplay"`
	Code    string `ubjson:"code"`
}

A Names contains the names of a player.

type ParserEvent 

type ParserEvent uint8

ParserEvent enumerates events sent by a SlpParser 

const (
	Started ParserEvent = iota
	Frame
	FinalizedFrame
	RollbackFrame
	Ended
)

ParserEvents

type PlayerInfo 

type PlayerInfo struct {
	Index           uint8
	Port            uint8
	CharacterID     uint8
	PlayerType      PlayerType
	StockStartCount uint8
	CostumeIndex    uint8
	TeamShade       TeamShade
	Handicap        uint8
	TeamID          TeamID
	PlayerBitfield  uint8
	CPULevel        uint8
	OffenseRatio    float32
	DefenseRatio    float32
	ModelScale      float32
	DashbackFix     DashbackFix
	ShieldDropFix   ShieldDropFix
	Nametag         string
	DisplayName     string
	ConnectCode     string
	SlippiUID       string
}

PlayerInfo contains information about a player in Melee.

type PlayerMetadata 

type PlayerMetadata struct {
	Characters map[string]int32 `ubjson:"characters"`
	Names      Names            `ubjson:"names"`
}

A PlayerMetadata contains metadata about a player.

type PlayerType 

type PlayerType uint8

PlayerType enumerates the different player types in Melee. 

const (
	Human PlayerType = iota
	CPU
	Demo
	Empty
)

PlayerTypes

type Port 

type Port uint16

Port enumerates the ports used

type PostFrameUpdatePayload 

type PostFrameUpdatePayload struct {
	FrameUpdate
	InternalCharacterID     uint8
	ShieldSize              float32
	LastHittingAttackID     uint8
	CurrentComboCount       uint8
	LastHitBy               uint8
	StocksRemaining         uint8
	ActionStateFrameCounter float32
	StateBitFlags1          uint8
	StateBitFlags2          uint8
	StateBitFlags3          uint8
	StateBitFlags4          uint8
	StateBitFlags5          uint8
	MiscAS                  float32
	Airborne                bool
	LastGroundID            uint16
	JumpsRemaining          uint8
	LCancelStatus           LCancelStatus
	HurtboxCollisionState   HurtboxCollisionState
	SelfInducedAirXSpeed    float32
	SelfInducedYSpeed       float32
	AttackBasedXSpeed       float32
	AttackBasedYSpeed       float32
	SelfInducedGroundXSpeed float32
	HitlagFramesRemaining   float32
	AnimationIndex          uint32
}

PostFrameUpdatePayload represents the PostFrameUpdate Slippi event.

func (PostFrameUpdatePayload) GetFrameUpdate 

func (u PostFrameUpdatePayload) GetFrameUpdate() FrameUpdate

GetFrameUpdate implements the FrameUpdatePayload interface.

type PreFrameUpdatePayload 

type PreFrameUpdatePayload struct {
	FrameUpdate
	RandomSeed       uint32
	JoystickX        float32
	JoystickY        float32
	CStickX          float32
	CStickY          float32
	Trigger          float32
	ProcessedButtons uint32
	PhysicalButtons  uint16
	PhysicalLTrigger float32
	PhysicalRTrigger float32
	XAnalogUCF       uint8
}

PreFrameUpdatePayload represents the PreFrameUpdate Slippi event.

func (PreFrameUpdatePayload) GetFrameUpdate 

func (u PreFrameUpdatePayload) GetFrameUpdate() FrameUpdate

GetFrameUpdate implements the FrameUpdatePayload interface.

type Rollbacks 

type Rollbacks struct {
	Frames  map[int32][]FrameEntry
	Count   int
	Lengths []int
	// contains filtered or unexported fields
}

Rollbacks tracks the rollbacks within a replay.

type ShieldDropFix 

type ShieldDropFix uint32

ShieldDropFix enumerates the controller fixes for shield drops. 

const (
	SDFixOff ShieldDropFix = iota
	SDUCF
	SDDween
)

ShieldDropFixes

type SlpCalculator 

type SlpCalculator interface {
	// contains filtered or unexported methods
}

SlpCalculator is the interface to represent calculators

type SlpEvent 

type SlpEvent struct {
	Command Command
	Payload interface{}
}

SlpEvent contains the command of an event and its associated data.

type SlpEventResult 

type SlpEventResult struct {
	Event *SlpEvent
	Error error
}

type SlpGame 

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

A SlpGame contains information about a Slippi game.

func NewSlpGameFromBytes 

func NewSlpGameFromBytes(b []byte, calculators []SlpCalculator) (*SlpGame, error)

NewSlpGameFromBytes creates a new SlpGame from the provided bytes.

func NewSlpGameFromFile 

func NewSlpGameFromFile(f *os.File, calculators []SlpCalculator) (*SlpGame, error)

NewSlpGameFromFile creates a new SlpGame from the provided file.

func (*SlpGame) AddCalculator 

func (g *SlpGame) AddCalculator(c SlpCalculator)

AddCalculator adds a calculator to the SlpGame.

func (*SlpGame) Close 

func (g *SlpGame) Close()

Close the SlpGame's underlying channel.

func (*SlpGame) GetFrames 

func (g *SlpGame) GetFrames() (map[int32]FrameEntry, error)

GetFrames gets the frames from the SlpGame.

func (*SlpGame) GetGameEnd 

func (g *SlpGame) GetGameEnd() (*GameEndPayload, error)

GetGameEnd gets the game end event from the SlpGame.

func (*SlpGame) GetGameInfo 

func (g *SlpGame) GetGameInfo() (*GameInfo, error)

GetGameInfo gets the game info of the SlpGame.

func (*SlpGame) GetLatestFrame 

func (g *SlpGame) GetLatestFrame() (*FrameEntry, error)

GetLatestFrame gets the latest frame in the SlpGame.

func (*SlpGame) GetMetadata 

func (g *SlpGame) GetMetadata() (*Metadata, error)

GetMetadata gets the SlpGame's metadata.

func (*SlpGame) GetRollbackFrames 

func (g *SlpGame) GetRollbackFrames() (map[int32][]FrameEntry, error)

GetRollbackFrames gets the rollback frames from the SlpGame.

func (*SlpGame) RemoveAllCalculators 

func (g *SlpGame) RemoveAllCalculators()

RemoveAllCalculators removes all calculators from the SlpGame.

func (*SlpGame) RemoveCalculator 

func (g *SlpGame) RemoveCalculator(c SlpCalculator)

RemoveCalculator removes a calculator from the SlpGame.

type SlpParser 

type SlpParser struct {
	Options   SlpParserOpts
	Frames    map[int32]FrameEntry
	Rollbacks Rollbacks

	GameEnd *GameEndPayload
	// contains filtered or unexported fields
}

A SlpParser parses a replay into frames.

func NewSlpParser 

func NewSlpParser(options SlpParserOpts) *SlpParser

NewSlpParser creates a new SlpParser with the given SlpParserOpts.

func (*SlpParser) AddHandler 

func (p *SlpParser) AddHandler(event ParserEvent, handler chan interface{})

AddHandler attaches an event handler channel to a ParseEvent.

func (*SlpParser) GetGameInfo 

func (p *SlpParser) GetGameInfo() (*GameInfo, bool)

GetGameInfo gets the current parsed game info, as well as a boolean indicating if the full game info has been parsed yet.

func (*SlpParser) GetLatestFrame 

func (p *SlpParser) GetLatestFrame() *FrameEntry

GetLatestFrame gets the latest frame parsed by the SlpParser.

func (*SlpParser) GetPlayableFrameCount 

func (p *SlpParser) GetPlayableFrameCount() int32

GetPlayableFrameCount returns the number of playable frames parsed so far.

func (*SlpParser) ParseReplay 

func (p *SlpParser) ParseReplay(eventResults <-chan *SlpEventResult) error

ParseReplay processes events from the given SlpEventResult channel and updates the SlpParser's state accordingly.

func (*SlpParser) RemoveAllHandlers 

func (p *SlpParser) RemoveAllHandlers(event ParserEvent)

RemoveAllHandlers removes all event handler channels from a ParseEvent.

func (*SlpParser) RemoveHandler 

func (p *SlpParser) RemoveHandler(event ParserEvent, toRemove chan interface{})

RemoveHandler removes an event handler channel from a ParseEvent.

func (*SlpParser) Reset 

func (p *SlpParser) Reset()

Reset resets the SlpParser's state. This does not reset parser options or remove event handler channels.

func (*SlpParser) Trigger 

func (p *SlpParser) Trigger(event ParserEvent, payload interface{})

Trigger triggers the given ParserEvent with the given payload, sending it to all attached handler channels.

type SlpParserOpts 

type SlpParserOpts struct {
	Strict bool
}

SlpParserOpts contains options that determine how a SlpParser behaves.

type SlpReader 

type SlpReader struct {
	Source SlpSource

	RawStart       int64
	RawLength      int64
	MetadataStart  int64
	MetadataLength int64
	PayloadSizes   map[byte]uint16
	// contains filtered or unexported fields
}

A SlpReader reads data from Source and emits event payloads and metadata.

func NewSlpReader 

func NewSlpReader(s SlpSource) (*SlpReader, error)

NewSlpReader returns a SlpReader that reads from the provided SlpSource s.

func (SlpReader) GetMetadata 

func (r SlpReader) GetMetadata() (*Metadata, error)

GetMetadata gets metadata from the replay SlpReader is reading.

func (*SlpReader) SetInclude 

func (r *SlpReader) SetInclude(command byte, include bool) error

SetInclude sets whether a given event (as specified by its command byte) will be read and emitted when YieldEvents is called on the SlpReader.

func (*SlpReader) YieldEvents 

func (r *SlpReader) YieldEvents(stopYielding func(*SlpEvent) bool) (<-chan *SlpEventResult, error)

YieldEvents returns a channel to which it sends the events from the SlpSource.

type SlpSource 

type SlpSource struct {
	io.ReadSeeker
	InputType InputType
	// contains filtered or unexported fields
}

A SlpSource wraps a reader and the type of the reader, used to determine its length.

func NewSlpSourceBytes 

func NewSlpSourceBytes(r *bytes.Reader) *SlpSource

NewSlpSourceBytes returns a SlpSource wrapping the provided *bytes.Reader r.

func NewSlpSourceFile 

func NewSlpSourceFile(f *os.File) *SlpSource

NewSlpSourceFile returns a SlpSource wrapping the provided *os.File f.

func (*SlpSource) GetLength 

func (s *SlpSource) GetLength(recalculate bool) (int64, error)

GetLength gets the length of the underlying data source of the SlpSource. If recalculate is true, the length will be recalculated. Otherwise, the length is only calculated on the first call to GetLength for a given SlpSource. If there is an error getting the length of the data source, a length of 0 is returned along with the error.

type TeamID 

type TeamID uint8

TeamID enumerates the possible team colors in Melee. 

const (
	Red TeamID = iota
	Blue
	Green
)

TeamIDs

type TeamShade 

type TeamShade uint8

TeamShade enumerates the coloration changes for multiples of the same character on the same team. 

const (
	Normal TeamShade = iota
	Light
	Dark
)

TeamShades

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.