w3gs

package
v1.3.0 Latest Latest
Warning

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

 Go to latest Published: Mar 17, 2019 License: MPL-2.0 Imports: 7 Imported by: 37

Documentation

Overview

Package w3gs implements the game protocol for Warcraft III.

Based on protocol documentation by https://bnetdocs.org/

Each packet type is mapped to a struct type that implements the Packet interface. To deserialize from a binary stream, use DeserializePacket().

This package tries to keep ammortized heap memory allocations to 0.

General serialization format: 

(UINT8)  Protocol signature (0xF7)
(UINT8)  Packet type ID
(UINT16) Packet size
[Packet Data]

Index

Constants

View Source 
const (
	PidPingFromHost      = 0x01
	PidSlotInfoJoin      = 0x04
	PidRejectJoin        = 0x05
	PidPlayerInfo        = 0x06
	PidPlayerLeft        = 0x07
	PidPlayerLoaded      = 0x08
	PidSlotInfo          = 0x09
	PidCountDownStart    = 0x0A
	PidCountDownEnd      = 0x0B
	PidIncomingAction    = 0x0C
	PidDesync            = 0x0D
	PidChatFromHost      = 0x0F
	PidStartLag          = 0x10
	PidStopLag           = 0x11
	PidGameOver          = 0x14
	PidPlayerKicked      = 0x1C
	PidLeaveAck          = 0x1B
	PidReqJoin           = 0x1E
	PidLeaveReq          = 0x21
	PidGameLoadedSelf    = 0x23
	PidOutgoingAction    = 0x26
	PidOutgoingKeepAlive = 0x27
	PidChatToHost        = 0x28
	PidDropReq           = 0x29
	PidSearchGame        = 0x2F
	PidGameInfo          = 0x30
	PidCreateGame        = 0x31
	PidRefreshGame       = 0x32
	PidDecreateGame      = 0x33
	PidChatFromOthers    = 0x34
	PidPingFromOthers    = 0x35
	PidPongToOthers      = 0x36
	PidClientInfo        = 0x37
	PidPeerSet           = 0x3B
	PidMapCheck          = 0x3D
	PidStartDownload     = 0x3F
	PidMapSize           = 0x42
	PidMapPart           = 0x43
	PidMapPartOK         = 0x44
	PidMapPartError      = 0x45
	PidPongToHost        = 0x46
	PidIncomingAction2   = 0x48
)

W3GS packet type identifiers

View Source 
const CurrentGameVersion = uint32(30)

CurrentGameVersion used by stable release

View Source 
const ProtocolSig = 0xF7

ProtocolSig is the W3GS magic number used in the packet header.

Variables

View Source 
var (
	ErrNoProtocolSig     = errors.New("w3gs: Invalid w3gs packet (no signature found)")
	ErrInvalidPacketSize = errors.New("w3gs: Invalid packet size")
	ErrInvalidChecksum   = errors.New("w3gs: Checksum invalid")
	ErrUnexpectedConst   = errors.New("w3gs: Unexpected constant value")
	ErrBufferTooSmall    = errors.New("w3gs: Packet exceeds buffer size")
)

Errors

View Source 
var (
	ProductDemo = protocol.DString("W3DM") // Demo
	ProductROC  = protocol.DString("WAR3") // ROC
	ProductTFT  = protocol.DString("W3XP") // TFT
)

Game product

Functions

func ReadPacket 

func ReadPacket(r io.Reader, b *DeserializationBuffer) ([]byte, int, error)

ReadPacket reads exactly one packet from r and returns it in the proper (deserialized) packet type.

func ReadPacketWithBuffer 

func ReadPacketWithBuffer(r io.Reader, b *DeserializationBuffer) ([]byte, int, error)

ReadPacketWithBuffer reads exactly one packet from r and returns its raw bytes.

func SerializePacket 

func SerializePacket(w io.Writer, p Packet) (int, error)

SerializePacket serializes p and writes it to w.

func SerializePacketWithBuffer 

func SerializePacketWithBuffer(w io.Writer, b *SerializationBuffer, p Packet) (int, error)

SerializePacketWithBuffer serializes p and writes it to w.

Types

type AI 

type AI uint8

AI difficulty enum 

const (
	ComputerEasy   AI = 0x00
	ComputerNormal AI = 0x01
	ComputerInsane AI = 0x02
)

AI difficulty

func (AI) String 

func (a AI) String() string

type CountDownEnd 

type CountDownEnd struct {
}

CountDownEnd implements the [0x0B] W3GS_COUNTDOWN_END packet (S -> C).

The game has finished the countdown and has now started. Players should see a loading screen for the map once this is received.

[0x0A] W3GS_COUNTDOWN_START should be received before this packet, even if there is no countdown or if the countdown was 0 seconds.

Format: 

[blank]

func (*CountDownEnd) Deserialize 

func (pkt *CountDownEnd) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*CountDownEnd) Serialize 

func (pkt *CountDownEnd) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type CountDownStart 

type CountDownStart struct {
}

CountDownStart implements the [0x0A] W3GS_COUNTDOWN_START packet (S -> C).

The game has begun the countdown to start.

The official clients countdown from 5 seconds, however it is possible to use any time you wish. For example, the GHost++ bot uses 10 seconds when auto-hosted, but 5 seconds when started using an administrative command.

Format: 

[blank]

func (*CountDownStart) Deserialize 

func (pkt *CountDownStart) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*CountDownStart) Serialize 

func (pkt *CountDownStart) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type CreateGame 

type CreateGame struct {
	GameVersion
	HostCounter uint32
}

CreateGame implements the [0x31] W3GS_CreateGame packet (S -> C).

Notifies the local area network that a game was created.

Format: 

(UINT32) Product
(UINT32) Version
(UINT32) HostCounter

func (*CreateGame) Deserialize 

func (pkt *CreateGame) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*CreateGame) Serialize 

func (pkt *CreateGame) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type DecreateGame 

type DecreateGame struct {
	HostCounter uint32
}

DecreateGame implements the [0x33] W3GS_DecreateGame packet (S -> C).

Notifies the local area network that a game is no longer being hosted.

Format: 

(UINT32) Host Counter

func (*DecreateGame) Deserialize 

func (pkt *DecreateGame) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*DecreateGame) Serialize 

func (pkt *DecreateGame) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type DeserializationBuffer 

type DeserializationBuffer struct {
	Buffer [2048]byte
	// contains filtered or unexported fields
}

DeserializationBuffer is used by DeserializePacketWithBuffer to bring amortized allocs to 0 for repeated calls

type Desync 

type Desync struct {
	Checksum       uint32
	PlayersInState []uint8
}

Desync implements the [0x0D] W3GS_DESYNC packet (S -> C).

This is sent whenever the server detects a split state based on checksums sent by [0x27] W3GS_OUTGOING_KEEPALIVE. Each client continues the game with the given player numbers, other players are dropped. 

(UINT32)  Unknown (0x01)
(UINT8)   Unknown (0x04)
(UINT32)  Checksum
(UINT8)   NumPlayersInState
(UINT8)[] Player numbers

func (*Desync) Deserialize 

func (pkt *Desync) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*Desync) Serialize 

func (pkt *Desync) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type DropLaggers 

type DropLaggers struct {
}

DropLaggers implements the [0x2F] W3GS_STOP_DROPREQ packet (C -> S).

This is sent when a player votes to drop lagging players.

Format: 

[blank]

func (*DropLaggers) Deserialize 

func (pkt *DropLaggers) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*DropLaggers) Serialize 

func (pkt *DropLaggers) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type GameAction 

type GameAction struct {
	Data []byte
}

GameAction implements the [0x26] W3GS_OUTGOING_ACTION packet (C -> S).

A client sends this to the game host to execute an action in-game.

Format: 

(UINT32) CRC-32 checksum
  (VOID) Action data

func (*GameAction) Deserialize 

func (pkt *GameAction) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*GameAction) Serialize 

func (pkt *GameAction) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type GameFlags 

type GameFlags uint32

GameFlags enum 

const (
	GameFlagCustomGame   GameFlags = 0x000001
	GameFlagOfficialGame GameFlags = 0x000009 // Blizzard signed map
	GameFlagSinglePlayer GameFlags = 0x00001D
	GameFlagTeamLadder   GameFlags = 0x000020
	GameFlagSavedGame    GameFlags = 0x000200
	GameFlagTypeMask     GameFlags = 0x0002FF

	GameFlagPrivateGame GameFlags = 0x000800

	GameFlagCreatorUser     GameFlags = 0x002000
	GameFlagCreatorBlizzard GameFlags = 0x004000
	GameFlagCreatorMask     GameFlags = 0x006000

	GameFlagMapTypeMelee    GameFlags = 0x008000
	GameFlagMapTypeScenario GameFlags = 0x010000
	GameFlagMapTypeMask     GameFlags = 0x018000

	GameFlagSizeSmall  GameFlags = 0x020000
	GameFlagSizeMedium GameFlags = 0x040000
	GameFlagSizeLarge  GameFlags = 0x080000
	GameFlagSizeMask   GameFlags = 0x0E0000

	GameFlagObsFull     GameFlags = 0x100000
	GameFlagObsOnDefeat GameFlags = 0x200000
	GameFlagObsNone     GameFlags = 0x400000
	GameFlagObsMask     GameFlags = 0x700000

	// Used for filtering game list
	GameFlagFilterMask GameFlags = 0x7FE000
)

Game flags

func (GameFlags) String 

func (f GameFlags) String() string

type GameInfo 

type GameInfo struct {
	GameVersion
	HostCounter    uint32
	EntryKey       uint32
	GameName       string
	GameSettings   GameSettings
	SlotsTotal     uint32
	GameFlags      GameFlags
	SlotsUsed      uint32
	SlotsAvailable uint32
	UptimeSec      uint32
	GamePort       uint16
}

GameInfo implements the [0x30] W3GS_GameInfo packet (S -> C).

This is sent in response to [0x2F] W3GS_SearchGame (on the local area network).

Format: 

(UINT32) Product
(UINT32) Version
(UINT32) Host Counter
(UINT32) Entry key
(STRING) Game name
 (UINT8) Unknown (0x00)
(STRING) Statstring
(UINT32) Slots total
(UINT32) Game Type Info
(UINT32) Player slots used
(UINT32) Player slots available (total slots - closed slots - AI slots)
(UINT32) Time since creation
(UINT16) Listen Port

func (*GameInfo) Deserialize 

func (pkt *GameInfo) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*GameInfo) Serialize 

func (pkt *GameInfo) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type GameLoaded 

type GameLoaded struct {
}

GameLoaded implements the [0x23] W3GS_GAMELOADED_SELF packet (C -> S).

The client sends this to the host when they have finished loading the map.

Format: 

[blank]

func (*GameLoaded) Deserialize 

func (pkt *GameLoaded) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*GameLoaded) Serialize 

func (pkt *GameLoaded) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type GameOver 

type GameOver struct {
	PlayerID uint8
}

GameOver implements the [0x14] W3GS_GameOver packet (S -> C).

Notify clients that the game has ended and the connection will be closed.

Format: 

(UINT8) Player number

func (*GameOver) Deserialize 

func (pkt *GameOver) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*GameOver) Serialize 

func (pkt *GameOver) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type GameSettingFlags 

type GameSettingFlags uint32

GameSettingFlags enum 

const (
	SettingSpeedSlow   GameSettingFlags = 0x00000000
	SettingSpeedNormal GameSettingFlags = 0x00000001
	SettingSpeedFast   GameSettingFlags = 0x00000002
	SettingSpeedMask   GameSettingFlags = 0x0000000F

	SettingTerrainHidden   GameSettingFlags = 0x00000100
	SettingTerrainExplored GameSettingFlags = 0x00000200
	SettingTerrainVisible  GameSettingFlags = 0x00000400
	SettingTerrainDefault  GameSettingFlags = 0x00000800
	SettingTerrainMask     GameSettingFlags = 0x00000F00

	SettingObsNone     GameSettingFlags = 0x00000000
	SettingObsOnDefeat GameSettingFlags = 0x00002000
	SettingObsFull     GameSettingFlags = 0x00003000
	SettingObsReferees GameSettingFlags = 0x40000000
	SettingObsMask     GameSettingFlags = 0x40003000

	SettingTeamsTogether GameSettingFlags = 0x00004000
	SettingTeamsFixed    GameSettingFlags = 0x00060000
	SettingSharedControl GameSettingFlags = 0x01000000
	SettingRandomHero    GameSettingFlags = 0x02000000
	SettingRandomRace    GameSettingFlags = 0x04000000
)

Game setting flags

func (GameSettingFlags) String 

func (f GameSettingFlags) String() string

type GameSettings 

type GameSettings struct {
	GameSettingFlags GameSettingFlags
	MapWidth         uint16
	MapHeight        uint16
	MapXoro          uint32
	MapPath          string
	HostName         string
	MapSha1          [20]byte
}

GameSettings stores the settings of a created game.

Flags: 

Speed: (mask 0x00000003) cannot be combined
  0x00000000 - Slow game speed
  0x00000001 - Normal game speed
  0x00000002 - Fast game speed
Visibility: (mask 0x00000F00) cannot be combined
  0x00000100 - Hide terrain
  0x00000200 - Map explored
  0x00000400 - Always visible (no fog of war)
  0x00000800 - Default
Observers/Referees: (mask 0x40003000) cannot be combined
  0x00000000 - No Observers
  0x00002000 - Observers on Defeat
  0x00003000 - Additional players as observer allowed
  0x40000000 - Referees
Teams/Units/Hero/Race: (mask 0x07064000) can be combined
  0x00004000 - Teams Together (team members are placed at neighbored starting locations)
  0x00060000 - Fixed teams
  0x01000000 - Unit share
  0x02000000 - Random hero
  0x04000000 - Random races

Format: 

(UINT32)     Flags
(UINT16)     Map width
(UINT16)     Map height
(UINT32)     Map xoro
(STRING)     Map path
(STRING)     Host name
 (UINT8)[20] Map Sha1 hash

Encoded as a null terminated string where every even byte-value was incremented by 1. So all encoded bytes are odd. A control-byte stores the transformations for the next 7 bytes.

func (*GameSettings) Deserialize 

func (gs *GameSettings) Deserialize(buf *protocol.Buffer) error

Deserialize GameSettings from StatString

func (*GameSettings) Serialize 

func (gs *GameSettings) Serialize(buf *protocol.Buffer)

Serialize GameSettings into StatString

func (*GameSettings) Size 

func (gs *GameSettings) Size() int

Size of Serialize()

type GameVersion 

type GameVersion struct {
	Product protocol.DWordString
	Version uint32
}

GameVersion stores the game version tuple. 

Format:
  (UINT32) Product
  (UINT32) Version

func (*GameVersion) Deserialize 

func (gv *GameVersion) Deserialize(buf *protocol.Buffer)

Deserialize decodes the binary data generated by Serialize.

func (*GameVersion) Serialize 

func (gv *GameVersion) Serialize(buf *protocol.Buffer)

Serialize encodes the struct into its binary form.

type Join 

type Join struct {
	HostCounter  uint32
	EntryKey     uint32
	ListenPort   uint16
	JoinCounter  uint32
	PlayerName   string
	InternalAddr protocol.SockAddr
}

Join implements the [0x1E] W3GS_ReqJoin packet (C -> S).

A client sends this to the host to enter the game lobby.

The internal IP uses the Windows in_addr structure which is thus used by the sockaddr_in structure.

Format: 

(UINT32)   Host Counter (Game ID)
(UINT32)   Entry Key (used in LAN)
 (UINT8)   Unknown (0x00)
(UINT16)   Listen Port
(UINT32)   Join counter
(STRING)   Player name
 (UINT8)   Number of bytes that follow (0x01 < 1.29; 0x02 >= 1.29)
 (UINT8)[] Unknown (0x00)
(UINT16)   AF_INET (0x02)
(UINT16)   Internal Port
(UINT32)   Internal IP
(UINT32)   Unknown (0x00)
(UINT32)   Unknown (0x00)

func (*Join) Deserialize 

func (pkt *Join) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*Join) Serialize 

func (pkt *Join) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type LagPlayer 

type LagPlayer struct {
	PlayerID      uint8
	LagDurationMS uint32
}

LagPlayer stores the data for a single lagging player. 

(UINT8) Player number
(UINT32) Lag duration in milliseconds

type Leave 

type Leave struct {
	Reason LeaveReason
}

Leave implements the [0x21] W3GS_LeaveReq packet (C -> S).

A client requests to leave.

Reason: 

0x01 PLAYERLEAVE_DISCONNECT
0x07 PLAYERLEAVE_LOST
0x08 PLAYERLEAVE_LOSTBUILDINGS
0x09 PLAYERLEAVE_WON
0x0A PLAYERLEAVE_DRAW
0x0B PLAYERLEAVE_OBSERVER
0x0D PLAYERLEAVE_LOBBY

Format: 

(UINT32) Reason

func (*Leave) Deserialize 

func (pkt *Leave) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*Leave) Serialize 

func (pkt *Leave) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type LeaveAck 

type LeaveAck struct {
}

LeaveAck implements the [0x1B] W3GS_LeaveAck packet (S -> C).

This is the response to [0x21] W3GS_LeaveReq.

You will leave the game once the connection is terminated.

Format: 

[blank]

func (*LeaveAck) Deserialize 

func (pkt *LeaveAck) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*LeaveAck) Serialize 

func (pkt *LeaveAck) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type LeaveReason 

type LeaveReason uint32

LeaveReason enum 

const (
	LeaveDisconnect      LeaveReason = 0x01
	LeaveLost            LeaveReason = 0x07
	LeaveLostBuildings   LeaveReason = 0x08
	LeaveWon             LeaveReason = 0x09
	LeaveDraw            LeaveReason = 0x0A
	LeaveObserver        LeaveReason = 0x0B
	LeaveInvalidSaveGame LeaveReason = 0x0C // (?)
	LeaveLobby           LeaveReason = 0x0D
)

PlayerLeft reason

func (LeaveReason) String 

func (l LeaveReason) String() string

type MapCheck 

type MapCheck struct {
	FilePath string
	FileSize uint32
	FileCRC  uint32
	MapXoro  uint32
	MapSha1  [20]byte
}

MapCheck implements the [0x3D] W3GS_MapCheck packet (S -> C).

This is sent from the game host to a client that just joined to check if the client has the map.

Map hash is not only based on map file, as it takes common.j/blizzard.j from current patch into account as well.

Format: 

(UINT32)     Unknown (0x01)
(STRING)     File Path
(UINT32)     File size
(UINT32)     File CRC hash
(UINT32)     Map XOR/RotateLeft hash
 (UINT8)[20] Map SHA-1 hash

func (*MapCheck) Deserialize 

func (pkt *MapCheck) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*MapCheck) Serialize 

func (pkt *MapCheck) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type MapPart 

type MapPart struct {
	RecipientID uint8
	SenderID    uint8
	ChunkPos    uint32
	Data        []byte
}

MapPart implements the [0x43] W3GS_MapPart packet (S -> C).

This is received when you are downloading a map from the host.

You can calculate how many more chunks you have left based on the file size and the chunk position in file. You are done downloading when the chunk position in file (plus the size of the chunk) matches the file size received in 0x42 W3GS_MapSize.

If the data does not match the CRC-32, you should send the host 0x45 W3GS_MapPartError, otherwise you should always send 0x44 W3GS_MapPartOK in reply to this packet.

Format: 

 (UINT8)       To player number
 (UINT8)       From player number
(UINT32)       Unknown (0x01)
(UINT32)       Chunk position in file
(UINT32)       CRC-32 checksum
 (UINT8)[1442] Data

func (*MapPart) Deserialize 

func (pkt *MapPart) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*MapPart) Serialize 

func (pkt *MapPart) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type MapPartError 

type MapPartError struct {
}

MapPartError implements the [0x45] W3GS_MapPartError packet (C -> S).

This is sent when downloading a map in reply to 0x43 W3GS_MapPart and a chunk of the map file does not match its CRC checksum.

Format: 

[unknown]

func (*MapPartError) Deserialize 

func (pkt *MapPartError) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*MapPartError) Serialize 

func (pkt *MapPartError) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type MapPartOK 

type MapPartOK struct {
	SenderID    uint8
	RecipientID uint8
	ChunkPos    uint32
}

MapPartOK implements the [0x44] W3GS_MapPartOK packet (C -> S).

The client sends this when it has successfully received a chunk of the map file from the host client.

Format: 

 (UINT8) From player number
 (UINT8) To player number
(UINT32) Unknown (0x01)
(UINT32) Chunk position in file

func (*MapPartOK) Deserialize 

func (pkt *MapPartOK) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*MapPartOK) Serialize 

func (pkt *MapPartOK) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type MapState 

type MapState struct {
	Ready    bool
	FileSize uint32
}

MapState implements the [0x42] W3GS_MapSize packet (C -> S).

This is sent from the client to tell the host about the map file on the client's local system.

Format: 

(UINT32) Unknown (0x01)
 (UINT8) Size Flag (0x01 is ready, 0x03 to request the next 0x43] W3GS_MapPart)
(UINT32) Map Size

func (*MapState) Deserialize 

func (pkt *MapState) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*MapState) Serialize 

func (pkt *MapState) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type Message 

type Message struct {
	RecipientIDs []uint8
	SenderID     uint8
	Type         MessageType
	NewVal       uint8
	ExtraFlags   uint32
	Content      string
}

Message implements the [0x28] W3GS_CHAT_TO_HOST packet (C -> S).

This is sent from the client to the host to send a message to the other clients.

Format: 

(UINT8)   Player count
(UINT8)[] Player numbers that will receive the message
(UINT8)   From player number
(UINT8)   Flags

For Flag 0x10:
   (STRING) Message
For Flag 0x11:
   (UINT8) NewVal (Team)
For Flag 0x12:
   (UINT8) NewVal (Color)
For Flag 0x13:
   (UINT8) NewVal (Race)
For Flag 0x14:
   (UINT8) NewVal(Handicap)
For Flag 0x20:
   (UINT32) Extra Flags
   (STRING) Message

func (*Message) Deserialize 

func (pkt *Message) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*Message) Serialize 

func (pkt *Message) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type MessageRelay 

type MessageRelay struct {
	Message
}

MessageRelay implements the [0x0F] W3GS_CHAT_FROM_HOST packet (S -> C).

This is sent to the clients to print a message on the screen from another player.

Format: 

(UINT8)   Player count
(UINT8)[] Player numbers that will receive the message
(UINT8)   From player number
(UINT8)   Flags

For Flag 0x10:
   (STRING) Message
For Flag 0x11:
   (UINT8) NewVal (Team)
For Flag 0x12:
   (UINT8) NewVal (Color)
For Flag 0x13:
   (UINT8) NewVal (Race)
For Flag 0x14:
   (UINT8) NewVal(Handicap)
For Flag 0x20:
   (UINT32) Extra Flags
   (STRING) Message

func (*MessageRelay) Serialize 

func (pkt *MessageRelay) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type MessageType 

type MessageType uint8

MessageType enum 

const (
	MsgChat           MessageType = 0x10
	MsgTeamChange     MessageType = 0x11
	MsgColorChange    MessageType = 0x12
	MsgRaceChange     MessageType = 0x13
	MsgHandicapChange MessageType = 0x14
	MsgChatExtra      MessageType = 0x20
)

Chat type

func (MessageType) String 

func (m MessageType) String() string

type Packet 

type Packet interface {
	Serialize(buf *protocol.Buffer) error
	Deserialize(buf *protocol.Buffer) error
}

Packet interface.

func DeserializePacket 

func DeserializePacket(r io.Reader) (Packet, int, error)

DeserializePacket reads exactly one packet from r and returns it in the proper (deserialized) packet type.

func DeserializePacketWithBuffer 

func DeserializePacketWithBuffer(r io.Reader, b *DeserializationBuffer) (Packet, int, error)

DeserializePacketWithBuffer reads exactly one packet from r and returns it in the proper (deserialized) packet type.

type PeerConnect 

type PeerConnect struct {
	JoinCounter uint32
	EntryKey    uint32
	PlayerID    uint8
	PeerSet     protocol.BitSet32
}

PeerConnect implements the [0x37] W3GS_ClientInfo packet (C -> C).

A client sends this to another client to gain information about self when connected.

Peer set is a bitset with bits set for every peer connected to this client.

Format: 

(UINT32) Player Counter
(UINT32) Entry key
 (UINT8) Player number
 (UINT8) Unknown (0xFF, status / provider version constant?)
(UINT32) Peer set

func (*PeerConnect) Deserialize 

func (pkt *PeerConnect) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*PeerConnect) Serialize 

func (pkt *PeerConnect) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PeerMessage 

type PeerMessage struct {
	Message
}

PeerMessage implements the [0x34] W3GS_CHAT_FROM_OTHERS packet (C -> C).

This is sent to connected peers to print a message on the screen from another player.

Format: 

(UINT8)   Player count
(UINT8)[] Player numbers that will receive the message
(UINT8)   From player number
(UINT8)   Flags

For Flag 0x10:
   (STRING) Message
For Flag 0x11:
   (UINT8) NewVal (Team)
For Flag 0x12:
   (UINT8) NewVal (Color)
For Flag 0x13:
   (UINT8) NewVal (Race)
For Flag 0x14:
   (UINT8) NewVal(Handicap)
For Flag 0x20:
   (UINT32) Extra Flags
   (STRING) Message

func (*PeerMessage) Serialize 

func (pkt *PeerMessage) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PeerPing 

type PeerPing struct {
	Payload   uint32
	PeerSet   protocol.BitSet32
	GameTicks uint32
}

PeerPing implements the [0x35] W3GS_PING_FROM_OTHERS packet (C -> C).

Client requests an echo from another client (occurs every 10 seconds).

Format: 

(UINT32) Ping
(UINT32) Peer set  (see [0x37] W3GS_ClientInfo)
(UINT32) Game ticks

func (*PeerPing) Deserialize 

func (pkt *PeerPing) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*PeerPing) Serialize 

func (pkt *PeerPing) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PeerPong 

type PeerPong struct {
	Ping
}

PeerPong implements the [0x36] W3GS_PONG_TO_OTHERS packet (C -> C).

This is sent in response to an echo from another client.

Format: 

(UINT32) Pong (copy of Ping payload)

func (*PeerPong) Serialize 

func (pkt *PeerPong) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PeerSet 

type PeerSet struct {
	PeerSet protocol.BitSet16
}

PeerSet implements the [0x3B] W3GS_PEER_SET packet (C -> S).

Client sends this to the server to let it know which peers are connected to the client.

Format: 

(UINT16) Peer Set

func (*PeerSet) Deserialize 

func (pkt *PeerSet) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*PeerSet) Serialize 

func (pkt *PeerSet) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type Ping 

type Ping struct {
	Payload uint32
}

Ping implements the [0x01] W3GS_PING_FROM_HOST packet (S -> C).

This is sent every 30 seconds to make sure that the client is still responsive.

Format: 

(UINT32) Ping (GetTickCount)

func (*Ping) Deserialize 

func (pkt *Ping) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*Ping) Serialize 

func (pkt *Ping) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PlayerAction 

type PlayerAction struct {
	PlayerID uint8
	Data     []byte
}

PlayerAction stores the data for a single game action. 

(UINT8) Player number
(UINT16) Length of action data
(VOID) Action data

type PlayerInfo 

type PlayerInfo struct {
	JoinCounter  uint32
	PlayerID     uint8
	PlayerName   string
	ExternalAddr protocol.SockAddr
	InternalAddr protocol.SockAddr
}

PlayerInfo implements the [0x06] W3GS_PlayerInfo packet (S -> C).

Tells a client about a player's information.

The external and internal IP are always zero for the host.

Format: 

(UINT32)   Join Counter
 (UINT8)   Player number
(STRING)   Player name
 (UINT8)   Number of bytes that follow (0x01)
 (UINT8)[] Unknown (0x00)
(UINT16)   AF_INET (0x02)
(UINT16)   Port
(UINT32)   External IP
(UINT32)   Unknown (0x00)
(UINT32)   Unknown (0x00)
(UINT16)   AF_INET (0x02)
(UINT16)   Port
(UINT32)   Internal IP
(UINT32)   Unknown (0x00)
(UINT32)   Unknown (0x00)

func (*PlayerInfo) Deserialize 

func (pkt *PlayerInfo) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*PlayerInfo) Serialize 

func (pkt *PlayerInfo) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PlayerKicked 

type PlayerKicked struct {
	Leave
}

PlayerKicked implements the [0x1C] W3GS_PlayerKicked packet (S -> C).

The host has kicked the client from the lobby.

Reason: 

0x01 PLAYERLEAVE_DISCONNECT
0x07 PLAYERLEAVE_LOST
0x08 PLAYERLEAVE_LOSTBUILDINGS
0x09 PLAYERLEAVE_WON
0x0A PLAYERLEAVE_DRAW
0x0B PLAYERLEAVE_OBSERVER
0x0D PLAYERLEAVE_LOBBY

Format: 

(UINT32) Reason

func (*PlayerKicked) Serialize 

func (pkt *PlayerKicked) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PlayerLeft 

type PlayerLeft struct {
	PlayerID uint8
	Reason   LeaveReason
}

PlayerLeft implements the [0x07] W3GS_PlayerLeft packet (S -> C).

This is received from the game host when a player leaves.

Reason: 

0x01 PLAYERLEAVE_DISCONNECT
0x07 PLAYERLEAVE_LOST
0x08 PLAYERLEAVE_LOSTBUILDINGS
0x09 PLAYERLEAVE_WON
0x0A PLAYERLEAVE_DRAW
0x0B PLAYERLEAVE_OBSERVER
0x0D PLAYERLEAVE_LOBBY

Format: 

 (UINT8) Player number
(UINT32) Reason

func (*PlayerLeft) Deserialize 

func (pkt *PlayerLeft) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*PlayerLeft) Serialize 

func (pkt *PlayerLeft) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type PlayerLoaded 

type PlayerLoaded struct {
	PlayerID uint8
}

PlayerLoaded implements the [0x08] W3GS_PlayerLoaded packet (S -> C).

Sent to all other clients in-game to notify that a player has finished loading.

Format: 

(UINT8) Player number

func (*PlayerLoaded) Deserialize 

func (pkt *PlayerLoaded) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*PlayerLoaded) Serialize 

func (pkt *PlayerLoaded) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type Pong 

type Pong struct {
	Ping
}

Pong implements the [0x46] W3GS_PONG_TO_HOST packet (C -> S).

This is sent in response to 0x01 W3GS_PING_FROM_HOST.

The pong value is just a copy of whatever was sent in SEND_W3GS_PING_FROM_HOST which was GetTicks( ) at the time of sending so as long as we trust that the client isn't trying to fake us out and mess with the pong value we can find the round trip time by simple subtraction (the subtraction is done elsewhere because the very first pong value seems to be 1 and we want to discard that one)

Format: 

(UINT32) Pong (copy of Ping payload)

func (*Pong) Serialize 

func (pkt *Pong) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type RacePref 

type RacePref uint8

RacePref enum 

const (
	RaceHuman    RacePref = 0x01
	RaceOrc      RacePref = 0x02
	RaceNightElf RacePref = 0x04
	RaceUndead   RacePref = 0x08
	RaceDemon    RacePref = 0x10
	RaceRandom   RacePref = 0x20
	RaceMask              = RaceHuman | RaceOrc | RaceNightElf | RaceUndead | RaceDemon | RaceRandom

	RaceSelectable RacePref = 0x40
)

Race preference

func (RacePref) String 

func (r RacePref) String() string

type RefreshGame 

type RefreshGame struct {
	HostCounter    uint32
	SlotsUsed      uint32
	SlotsAvailable uint32
}

RefreshGame implements the [0x32] W3GS_RefreshGame packet (S -> C).

Notifies the local area network about a game (occurs every 5 seconds or refresh slots).

Format: 

(UINT32) Host Counter
(UINT32) Player slots used
(UINT32) Player slots available (total slots - closed slots - AI slots)

func (*RefreshGame) Deserialize 

func (pkt *RefreshGame) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*RefreshGame) Serialize 

func (pkt *RefreshGame) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type RejectJoin 

type RejectJoin struct {
	Reason RejectReason
}

RejectJoin implements the [0x05] W3GS_RejectJoin packet (S -> C).

This is sent in a response to a request to join the game lobby and indicates that the request was denied.

Reason: 

0x09 RejectJoin_FULL      The game lobby is full
0x07 RejectJoin_INVALID   There was an error in your request
0x10 RejectJoin_STARTED   The game has already been started
0x27 RejectJoin_WRONGPASS The password you sent was incorrect

Format: 

(UINT32) Reason

func (*RejectJoin) Deserialize 

func (pkt *RejectJoin) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*RejectJoin) Serialize 

func (pkt *RejectJoin) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type RejectReason 

type RejectReason uint32

RejectReason enum 

const (
	RejectJoinInvalid  RejectReason = 0x07
	RejectJoinFull     RejectReason = 0x09
	RejectJoinStarted  RejectReason = 0x0A
	RejectJoinWrongKey RejectReason = 0x1B
)

RejectJoin reason

func (RejectReason) String 

func (r RejectReason) String() string

type SearchGame 

type SearchGame struct {
	GameVersion
	HostCounter uint32
}

SearchGame implements the [0x2F] W3GS_SearchGame packet (C -> S).

This is broadcasted to the entire local area network to detect games during initial search of local games. After that, it is sent directly to clients that broadcasted [0x31] W3GS_CreateGame.

Product is either WAR3 or W3XP.

Format: 

(UINT32) Product
(UINT32) Version
(UINT32) Host Counter

func (*SearchGame) Deserialize 

func (pkt *SearchGame) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*SearchGame) Serialize 

func (pkt *SearchGame) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type SerializationBuffer 

type SerializationBuffer = protocol.Buffer

SerializationBuffer is used by SerializePacketWithBuffer to bring amortized allocs to 0 for repeated calls

type SlotData 

type SlotData struct {
	PlayerID       uint8
	DownloadStatus uint8
	SlotStatus     SlotStatus
	Computer       bool
	Team           uint8
	Color          uint8
	Race           RacePref
	ComputerType   AI
	Handicap       uint8
}

SlotData stores the info for a single game slot.

Download status:

- This is a percentage of their download progress. As such, this value can only be between 0 and 100.

Slot status: 

0x00 Open
0x01 Closed
0x02 Occupied

Computer status: 

0x00 Human
0x01 Computer

Race: 

0x01 Human
0x02 Orc
0x04 Night Elf
0x08 Undead
0x20 Random
0x40 Selectable

Computer type: 

  0x00 Easy
  0x01 Normal / Human
  0x02 Hard

Format:

  (UINT8) Player number
  (UINT8) Download status
  (UINT8) Slot status
  (UINT8) Computer status
  (UINT8) Team
  (UINT8) Color
  (UINT8) Race
  (UINT8) Computer type
  (UINT8) Handicap

type SlotInfo 

type SlotInfo struct {
	Slots      []SlotData
	RandomSeed uint32
	SlotLayout SlotLayout
	NumPlayers uint8
}

SlotInfo implements the [0x09] W3GS_SlotInfo packet (S -> C).

This is sent for slot updates.

The length of slot info should always be `0x0B`.

Format: 

(UINT16)   Length of Slot data
 (UINT8)   Number of slots
 (UINT8)[] Slot data
(UINT32)   Random seed (GetTickCount)
 (UINT8)   Slots layout
 (UINT8)   Number of player slots without observers

For each slot:
   (UINT8) Player number
   (UINT8) Download status
   (UINT8) Slot status
   (UINT8) Computer status
   (UINT8) Team
   (UINT8) Color
   (UINT8) Race
   (UINT8) Computer type
   (UINT8) Handicap

func (*SlotInfo) Deserialize 

func (pkt *SlotInfo) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*SlotInfo) Serialize 

func (pkt *SlotInfo) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type SlotInfoJoin 

type SlotInfoJoin struct {
	SlotInfo
	PlayerID     uint8
	ExternalAddr protocol.SockAddr
}

SlotInfoJoin implements the [0x04] W3GS_SlotInfoJoin packet (S -> C).

This is sent to tell the client about the game slots, upon entry of the lobby.

Format: 

   Embedded [0x09] W3GS_SlotInfo:
	    (UINT16)   Length of Slot data
	     (UINT8)   Number of slots
	     (UINT8)[] Slot data
	    (UINT32)   Random seed
	     (UINT8)   Slots layout
	     (UINT8)   Number of player slots without observers

    (UINT8) Player number
   (UINT16) AF_INET (0x02)
   (UINT16) Port
   (UINT32) External IP
   (UINT32) Unknown (0x00)
   (UINT32) Unknown (0x00)

func (*SlotInfoJoin) Deserialize 

func (pkt *SlotInfoJoin) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*SlotInfoJoin) Serialize 

func (pkt *SlotInfoJoin) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type SlotLayout 

type SlotLayout uint8

SlotLayout enum 

const (
	LayoutMelee               SlotLayout = 0x00
	LayoutCustomForces        SlotLayout = 0x01
	LayoutFixedPlayerSettings SlotLayout = 0x02
)

Slot layout

func (SlotLayout) String 

func (s SlotLayout) String() string

type SlotStatus 

type SlotStatus uint8

SlotStatus enum 

const (
	SlotOpen     SlotStatus = 0x00
	SlotClosed   SlotStatus = 0x01
	SlotOccupied SlotStatus = 0x02
)

Slot status

func (SlotStatus) String 

func (s SlotStatus) String() string

type StartDownload 

type StartDownload struct {
	PlayerID uint8
}

StartDownload implements the [0x3F] W3GS_StartDownload packet (C -> S, S -> C).

C -> S: Client sends this to the host to initiate a map download. S -> C: This tells the client that it is now in the downloading state and should expect chunks of file data.

Format: 

(UINT32) Unknown (0x01)
 (UINT8) Player number

func (*StartDownload) Deserialize 

func (pkt *StartDownload) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*StartDownload) Serialize 

func (pkt *StartDownload) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type StartLag 

type StartLag struct {
	Players []LagPlayer
}

StartLag implements the [0x10] W3GS_START_LAG packet (S -> C).

This is sent to the clients to initiate the lag screen.

Format: 

(UINT8) Number of lagging players

For every lagging player:
    (UINT8) Player number
   (UINT32) Lag duration in milliseconds

func (*StartLag) Deserialize 

func (pkt *StartLag) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*StartLag) Serialize 

func (pkt *StartLag) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type StopLag 

type StopLag struct {
	LagPlayer
}

StopLag implements the [0x11] W3GS_STOP_LAG packet (S -> C).

This is sent to the clients to indicate that a player stopped lagging.

Format: 

 (UINT8) Player number
(UINT32) Lag duration in milliseconds

func (*StopLag) Deserialize 

func (pkt *StopLag) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*StopLag) Serialize 

func (pkt *StopLag) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type TimeSlot 

type TimeSlot struct {
	Fragment        bool
	TimeIncrementMS uint16

	Actions []PlayerAction
	// contains filtered or unexported fields
}

TimeSlot implements the [0x0C] W3GS_INCOMING_ACTION packet (S -> C).

Informs the client about an action in-game.

Format: 

(UINT16) Send interval
(UINT16) CRC-16 checksum

For each action:
    (UINT8) Player number
   (UINT16) Length of action data
     (VOID) Action data

func (*TimeSlot) Deserialize 

func (pkt *TimeSlot) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*TimeSlot) Serialize 

func (pkt *TimeSlot) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type TimeSlotAck 

type TimeSlotAck struct {
	Unknown1 uint8
	Checksum uint32
}

TimeSlotAck implements the [0x27] W3GS_OUTGOING_KEEPALIVE packet (C -> S).

This is sent to the host from each client.

Format: 

(UINT8)  Unknown
(UINT32) Unknown (checksum?)

func (*TimeSlotAck) Deserialize 

func (pkt *TimeSlotAck) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*TimeSlotAck) Serialize 

func (pkt *TimeSlotAck) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

type UnknownPacket 

type UnknownPacket struct {
	ID   byte
	Blob []byte
}

UnknownPacket is used to store unknown packets.

func (*UnknownPacket) Deserialize 

func (pkt *UnknownPacket) Deserialize(buf *protocol.Buffer) error

Deserialize decodes the binary data generated by Serialize.

func (*UnknownPacket) Serialize 

func (pkt *UnknownPacket) Serialize(buf *protocol.Buffer) error

Serialize encodes the struct into its binary form.

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.