gamepacket

package
v0.0.3 Latest Latest
Warning

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

 Go to latest Published: Jul 16, 2023 License: Apache-2.0, BSD-3-Clause, ISC Imports: 3 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ChatMessageEvent = 0
	GameEndEvent     = 16
)
View Source 
const (
	GameInitTypeFull    = 0
	GameInitTypeMinimal = 4
)
View Source 
const CensusMaxUsers = 36

Variables

View Source 
var ClientMessageTable = common.NewMessageTable(map[uint16]ClientMessage{
	0x0002: &ClientAuth{},
	0x0003: &ClientMessageSend{},
	0x0004: &ClientJoinChannel{},
	0x0006: &ClientGameEnd{},
	0x0007: &ClientGetUserOnlineStatus{},
	0x0008: &ClientRoomCreate{},
	0x0009: &ClientRoomJoin{},
	0x000A: &ClientRoomEdit{},
	0x000B: &ClientTutorialStart{},
	0x000C: &ClientRoomUserEquipmentChange{},
	0x000D: &ClientPlayerReady{},
	0x000E: &ClientPlayerStartGame{},
	0x000F: &ClientRoomLeave{},
	0x0011: &ClientReadyStartHole{},
	0x0012: &ClientShotCommit{},
	0x0013: &ClientShotRotate{},
	0x0014: &ClientShotMeterInput{},
	0x0015: &ClientShotPower{},
	0x0016: &ClientShotClubChange{},
	0x0017: &ClientShotItemUse{},
	0x0018: &ClientUserTypingIndicator{},
	0x0019: &ClientShotCometRelief{},
	0x001A: &ClientHoleInfo{},
	0x001B: &ClientShotSync{},
	0x001C: &ClientRoomSync{},
	0x001D: &ClientBuyItem{},
	0x0020: &ClientEquipmentUpdate{},
	0x0022: &ClientShotActiveUserAcknowledge{},
	0x0026: &ClientRoomKick{},
	0x002D: &ClientRoomInfo{},
	0x002F: &ClientGetPlayerData{},
	0x0030: &ClientPauseGame{},
	0x0031: &ClientHoleEnd{},
	0x0032: &ClientSetIdleStatus{},
	0x0033: &ClientException{},
	0x0034: &ClientFirstShotReady{},
	0x0037: &ClientLastPlayerLeaveGame{},
	0x0042: &ClientShotArrow{},
	0x0043: &ClientRequestServerList{},
	0x0048: &ClientLoadProgress{},
	0x004F: &Client004F{},
	0x0063: &ClientRoomLoungeAction{},
	0x0069: &ClientUserMacrosSet{},
	0x0081: &ClientMultiplayerJoin{},
	0x0082: &ClientMultiplayerLeave{},
	0x0088: &Client0088{},
	0x008B: &ClientRequestMessengerList{},
	0x0098: &ClientRareShopOpen{},
	0x009C: &ClientRequestPlayerHistory{},
	0x00AE: &ClientTutorialClear{},
	0x00B5: &ClientEnterMyRoom{},
	0x00B7: &ClientRequestInventory{},
	0x00C1: &Client00C1{},
	0x00CC: &ClientLockerCombinationAttempt{},
	0x00D3: &ClientLockerInventoryRequest{},
	0x00FE: &Client00FE{},
	0x0108: &ClientGuildListRequest{},
	0x012A: &ClientScratchyMenuOpen{},
	0x0140: &ClientShopJoin{},
	0x0143: &ClientRequestInboxList{},
	0x0144: &ClientRequestInboxMessage{},
	0x014B: &ClientBlackPapelPlay{},
	0x0151: &ClientQuestStatusRequest{},
	0x0157: &ClientAchievementStatusRequest{},
	0x016E: &ClientRequestDailyReward{},
	0x0176: &ClientEventLobbyJoin{},
	0x0177: &ClientEventLobbyLeave{},
	0x0184: &ClientAssistModeToggle{},
	0x0186: &ClientBigPapelPlay{},
})
View Source 
var ServerMessageTable = common.NewMessageTable(map[uint16]ServerMessage{
	0x0040: &ServerEvent{},
	0x0044: &ServerPlayerData{},
	0x0046: &ServerUserCensus{},
	0x0047: &ServerRoomList{},
	0x0048: &ServerRoomCensus{},
	0x0049: &ServerRoomJoin{},
	0x004A: &ServerRoomStatus{},
	0x004B: &ServerRoomEquipmentData{},
	0x004C: &ServerRoomLeave{},
	0x004E: &Server004E{},
	0x0052: &ServerRoomGameData{},
	0x0053: &ServerRoomStartHole{},
	0x0055: &ServerRoomShotAnnounce{},
	0x0056: &ServerRoomShotRotateAnnounce{},
	0x0058: &ServerRoomShotPowerAnnounce{},
	0x0059: &ServerRoomClubChangeAnnounce{},
	0x005A: &ServerRoomItemUseAnnounce{},
	0x005B: &ServerRoomSetWind{},
	0x005D: &ServerRoomUserTypingAnnounce{},
	0x0060: &ServerRoomShotCometReliefAnnounce{},
	0x0061: &ServerPlayerQuitGame{},
	0x0063: &ServerRoomActiveUserAnnounce{},
	0x0064: &ServerRoomShotSync{},
	0x0065: &ServerRoomFinishHole{},
	0x0066: &ServerRoomFinishGame{},
	0x0068: &ServerPurchaseItemResponse{},
	0x006B: &ServerPlayerEquipmentUpdated{},
	0x0070: &ServerCharData{},
	0x0072: &ServerPlayerEquipment{},
	0x0073: &ServerPlayerInventory{},
	0x0076: &ServerGameInit{},
	0x0077: &Server0077{},
	0x0078: &ServerPlayerReady{},
	0x0086: &ServerRoomInfoResponse{},
	0x0089: &ServerPlayerDataResponse{},
	0x0090: &ServerPlayerFirstShotReady{},
	0x0092: &ServerOpponentQuit{},
	0x0095: &ServerMoneyUpdate{},
	0x0096: &ServerPointsBalance{},
	0x009E: &ServerRoomSetWeather{},
	0x009F: &ServerChannelList{},
	0x00A1: &ServerUserInfo{},
	0x00A3: &ServerPlayerLoadProgress{},
	0x00C4: &ServerRoomAction{},
	0x00C8: &ServerPangBalanceData{},
	0x00CC: &ServerRoomShotEnd{},
	0x00F1: &ServerMessageConnect{},
	0x00F5: &ServerMultiplayerJoined{},
	0x00F6: &ServerMultiplayerLeft{},
	0x00FB: &ServerBlackPapelResponse{},
	0x010B: &ServerRareShopOpen{},
	0x010E: &ServerPlayerHistory{},
	0x011F: &ServerTutorialStatus{},
	0x012B: &ServerMyRoomEntered{},
	0x012D: &ServerMyRoomLayout{},
	0x0151: &Server0151{},
	0x0156: &ServerPlayerEquipmentResponse{},
	0x0157: &ServerPlayerInfoResponse{},
	0x0158: &ServerPlayerStatisticsResponse{},
	0x015E: &ServerPlayerCharacterResponse{},
	0x0168: &ServerPlayerInfo{},
	0x016A: &Server016A{},
	0x016C: &ServerLockerCombinationResponse{},
	0x0170: &ServerLockerInventoryResponse{},
	0x0199: &ServerRoomPlayerFinished{},
	0x01BC: &ServerGuildListPage{},
	0x01EB: &ServerScratchyMenuResponse{},
	0x01F6: &Server01F6{},
	0x020E: &Server020E{},
	0x0210: &ServerInboxNotify{},
	0x0211: &ServerInboxList{},
	0x0212: &ServerMailMessage{},
	0x0216: &ServerUserStatusUpdate{},
	0x021B: &ServerBlackPapelWinnings{},
	0x021D: &ServerAchievementProgress{},
	0x0225: &ServerQuestStatus{},
	0x022C: &ServerAchievementUnknownResponse{},
	0x022D: &ServerAchievementStatusResponse{},
	0x0230: &Server0230{},
	0x0231: &Server0231{},
	0x0248: &ServerLoginBonusStatus{},
	0x0250: &ServerEventLobbyJoined{},
	0x0251: &ServerEventLobbyLeft{},
	0x026A: &ServerAssistModeToggled{},
	0x026C: &ServerBigPapelWinnings{},
})

Functions

This section is empty.

Types

type Achievement added in v0.0.3 

type Achievement struct {
	ID        uint32
	Value     uint32
	Timestamp uint32
}

type AchievementGroup added in v0.0.3 

type AchievementGroup struct {
	GroupID      uint32
	ID           uint32
	Count        uint32 `struct:"sizeof=Achievements"`
	Achievements []Achievement
}

type AchievementProgress 

type AchievementProgress struct {
	Unknown    byte
	StatusID   uint32
	StatusSlot uint32
	Value      uint32
}

type CaddieUpdated added in v0.0.3 

type CaddieUpdated struct {
	CaddieID uint32
}

type CharacterUpdated added in v0.0.3 

type CharacterUpdated struct {
	CharacterID uint32
}

type ChatMessage 

type ChatMessage struct {
	Nickname common.PString
	Message  common.PString
}

ChatMessage contains a global chat message

type Client004F added in v0.0.3 

type Client004F struct {
	ClientMessage_
}

Client004F is sent when the client gags you from chatting due to typing too much or too many obscenities

type Client0088 

type Client0088 struct {
	ClientMessage_
}

Client0088 is an unknown message.

type Client00C1 added in v0.0.3 

type Client00C1 struct {
	ClientMessage_
	Unknown byte
}

type Client00FE 

type Client00FE struct {
	ClientMessage_
}

type ClientAchievementStatusRequest added in v0.0.3 

type ClientAchievementStatusRequest struct {
	ClientMessage_
	UserID uint32
}

ClientAchievementStatusRequest requests Achievement Status for a user.

type ClientAssistModeToggle 

type ClientAssistModeToggle struct {
	ClientMessage_
}

ClientAssistModeToggle is sent when assist mode is toggled.

type ClientAuth 

type ClientAuth struct {
	ClientMessage_
	Username common.PString
	Unknown1 uint32
	Unknown2 uint32
	Unknown3 uint16
	LoginKey common.PString
	Version  common.PString
}

ClientAuth is a message sent to authenticate a session.

type ClientBigPapelPlay added in v0.0.3 

type ClientBigPapelPlay struct {
	ClientMessage_
}

type ClientBlackPapelPlay added in v0.0.3 

type ClientBlackPapelPlay struct {
	ClientMessage_
}

type ClientBuyItem 

type ClientBuyItem struct {
	ClientMessage_
	Unknown1 byte
	NumItems uint16 `struct:"sizeof=Items"`
	Items    []PurchaseItem
}

ClientBuyItem is sent by the client to buy an item from the shop.

type ClientEnterMyRoom added in v0.0.3 

type ClientEnterMyRoom struct {
	ClientMessage_
	UserID     uint32
	RoomUserID uint32
}

type ClientEquipmentUpdate 

type ClientEquipmentUpdate struct {
	ClientMessage_
	Type        uint8
	CharParts   *pangya.PlayerCharacterData `struct-if:"Type == 0"`
	Caddie      *UpdateCaddie               `struct-if:"Type == 1"`
	Consumables *UpdateConsumables          `struct-if:"Type == 2"`
	Comet       *UpdateComet                `struct-if:"Type == 3"`
	Decoration  *UpdateDecoration           `struct-if:"Type == 4"`
	Character   *UpdateCharacter            `struct-if:"Type == 5"`
	Unknown1    *UpdateUnknown1             `struct-if:"Type == 8"`
	Unknown2    *UpdateUnknown2             `struct-if:"Type == 9"`
}

ClientEquipmentUpdate updates the user's equipment.

type ClientEventLobbyJoin 

type ClientEventLobbyJoin struct {
	ClientMessage_
}

ClientEventLobbyJoin is the message sent when joining the event lobby.

type ClientEventLobbyLeave 

type ClientEventLobbyLeave struct {
	ClientMessage_
}

ClientEventLobbyLeave is sent when the client exits the event lobby.

type ClientException 

type ClientException struct {
	ClientMessage_
	Empty   byte
	Message common.PString
}

ClientException is a message sent when the client encounters an error.

type ClientFirstShotReady 

type ClientFirstShotReady struct {
	ClientMessage_
}

type ClientGameEnd 

type ClientGameEnd struct {
	ClientMessage_
}

ClientGameEnd contains information after the end of a game.

type ClientGetPlayerData added in v0.0.3 

type ClientGetPlayerData struct {
	ClientMessage_
	UserID  uint32
	Request byte
}

ClientGetPlayerData is a message sent by the client to request the client state.

type ClientGetUserOnlineStatus 

type ClientGetUserOnlineStatus struct {
	ClientMessage_
	Unknown  uint8
	Username common.PString
}

ClientGetUserOnlineStatus is sent to get information of a user.

type ClientGuildListRequest added in v0.0.3 

type ClientGuildListRequest struct {
	ClientMessage_
	Page uint32
}

type ClientHoleEnd 

type ClientHoleEnd struct {
	ClientMessage_
	Stats pangya.PlayerStats
}

type ClientHoleInfo added in v0.0.3 

type ClientHoleInfo struct {
	ClientMessage_
	Num        uint8
	Unknown1   uint32
	Unknown2   uint32
	Par        uint8
	TeeX, TeeZ float32
	PinX, PinZ float32
}

type ClientJoinChannel 

type ClientJoinChannel struct {
	ClientMessage_
	ChannelID byte
}

ClientJoinChannel is a message sent when the client joins a channel.

type ClientLastPlayerLeaveGame added in v0.0.3 

type ClientLastPlayerLeaveGame struct {
	ClientMessage_
}

ClientLastPlayerLeaveGame is sent when the last player leaves a room. We can't rely on it for much; it just tells us the client thinks it shouldn't be punished for leaving the room since everyone else has already left. In the future it may need to be rejected in some cases.

type ClientLoadProgress 

type ClientLoadProgress struct {
	ClientMessage_
	Progress uint8
}

type ClientLockerCombinationAttempt added in v0.0.3 

type ClientLockerCombinationAttempt struct {
	ClientMessage_
	Combination common.PString
}

type ClientLockerInventoryRequest added in v0.0.3 

type ClientLockerInventoryRequest struct {
	ClientMessage_
}

type ClientMessage 

type ClientMessage interface {
	common.Message
	// contains filtered or unexported methods
}

type ClientMessageSend 

type ClientMessageSend struct {
	ClientMessage_
	Nickname common.PString
	Message  common.PString
}

ClientMessageSend is sent when the client sends a public chat message.

type ClientMessage_ 

type ClientMessage_ struct{}

type ClientMultiplayerJoin 

type ClientMultiplayerJoin struct {
	ClientMessage_
}

ClientMultiplayerJoin is the message sent when joining multiplayer.

type ClientMultiplayerLeave 

type ClientMultiplayerLeave struct {
	ClientMessage_
}

ClientMultiplayerLeave is sent when the client exits multiplayer mode.

type ClientPauseGame 

type ClientPauseGame struct {
	ClientMessage_
	Pause bool `struct:"byte"`
}

type ClientPlayerReady 

type ClientPlayerReady struct {
	ClientMessage_
	State byte
}

ClientPlayerReady is sent by the client when they are ready/to start the game.

type ClientPlayerStartGame 

type ClientPlayerStartGame struct {
	ClientMessage_
	Unknown uint32
}

ClientPlayerStartGame

type ClientQuestStatusRequest added in v0.0.3 

type ClientQuestStatusRequest struct {
	ClientMessage_
}

type ClientRareShopOpen added in v0.0.3 

type ClientRareShopOpen struct {
	ClientMessage_
}

ClientRareShopOpen notifies the server if a user opens the rare shop menu.

type ClientReadyStartHole 

type ClientReadyStartHole struct {
	ClientMessage_
}

type ClientRequestDailyReward 

type ClientRequestDailyReward struct {
	ClientMessage_
}

ClientRequestDailyReward is the message sent to request the daily reward.

type ClientRequestInboxList 

type ClientRequestInboxList struct {
	ClientMessage_
	PageNum uint32
}

ClientRequestInboxList is the message sent to request the inbox.

type ClientRequestInboxMessage 

type ClientRequestInboxMessage struct {
	ClientMessage_
	MessageID uint32
}

ClientRequestInboxMessage is sent by the client to retrieve a message from the inbox.

type ClientRequestInventory added in v0.0.3 

type ClientRequestInventory struct {
	ClientMessage_
	UserID  uint32
	Unknown byte
}

type ClientRequestMessengerList 

type ClientRequestMessengerList struct {
	ClientMessage_
}

ClientRequestMessengerList is a message sent to request the current list of message servers.

type ClientRequestPlayerHistory 

type ClientRequestPlayerHistory struct {
	ClientMessage_
}

ClientRequestPlayerHistory is an unknown message.

type ClientRequestServerList 

type ClientRequestServerList struct {
	ClientMessage_
}

ClientRequestServerList is a message sent to request the current list of game servers.

type ClientRoomCreate 

type ClientRoomCreate struct {
	ClientMessage_
	Unknown         byte
	ShotTimerMS     uint32
	GameTimerMS     uint32
	MaxUsers        uint8
	RoomType        byte
	NumHoles        byte
	Course          byte
	HoleProgression byte
	Unknown2        [4]byte
	RoomName        common.PString
	Password        common.PString
	Unknown3        [4]byte
}

ClientRoomCreate is sent by the client when creating a room.

type ClientRoomEdit 

type ClientRoomEdit struct {
	ClientMessage_
	Unknown    uint16
	NumChanges uint8 `struct:"sizeof=Changes"`
	Changes    []gamemodel.RoomSettingsChange
}

ClientRoomEdit is sent when the client changes room settings.

type ClientRoomInfo 

type ClientRoomInfo struct {
	ClientMessage_
	RoomNumber uint16
}

type ClientRoomJoin 

type ClientRoomJoin struct {
	ClientMessage_
	RoomNumber   int16
	RoomPassword common.PString
}

ClientRoomJoin is sent by the client when joining a room.

type ClientRoomKick 

type ClientRoomKick struct {
	ClientMessage_
	ConnID uint32
}

type ClientRoomLeave 

type ClientRoomLeave struct {
	ClientMessage_
	Unknown    byte
	RoomNumber int16
	Unknown2   uint32
	Unknown3   uint32
	Unknown4   uint32
	Unknown5   uint32
}

ClientRoomLeave is sent by the client when leaving a room back to lobby

type ClientRoomLoungeAction 

type ClientRoomLoungeAction struct {
	ClientMessage_
	gamemodel.RoomAction
}

ClientRoomLoungeAction

type ClientRoomSync 

type ClientRoomSync struct {
	ClientMessage_
	Unknown1   uint8
	EntryCount uint8
	Entries    []SyncEntry
}

type ClientRoomUserEquipmentChange 

type ClientRoomUserEquipmentChange struct {
	ClientMessage_
}

ClientRoomUserEquipmentChange is sent when a user's equipment changes in a room.

type ClientScratchyMenuOpen added in v0.0.3 

type ClientScratchyMenuOpen struct {
	ClientMessage_
}

type ClientSetIdleStatus 

type ClientSetIdleStatus struct {
	ClientMessage_
	Idle bool `struct:"byte"`
}

ClientSetIdleStatus sets whether or not the client is idle in a room.

type ClientShopJoin 

type ClientShopJoin struct {
	ClientMessage_
}

ClientShopJoin is an unknown message.

type ClientShotActiveUserAcknowledge 

type ClientShotActiveUserAcknowledge struct {
	ClientMessage_
}

type ClientShotArrow 

type ClientShotArrow struct {
	ClientMessage_
}

type ClientShotClubChange 

type ClientShotClubChange struct {
	ClientMessage_
	Club uint8
}

type ClientShotCometRelief 

type ClientShotCometRelief struct {
	ClientMessage_
	X, Y, Z float32
}

type ClientShotCommit 

type ClientShotCommit struct {
	ClientMessage_
	UnknownFlag      bool    `struct:"uint16"`
	Unknown          [9]byte `struct-if:"UnknownFlag"`
	ShotStrength     float32
	ShotAccuracy     float32
	ShotEnglishCurve float32
	ShotEnglishSpin  float32
	Unknown2         [30]byte
	Unknown3         [4]float32
}

type ClientShotItemUse 

type ClientShotItemUse struct {
	ClientMessage_
	ItemTypeID uint32
}

type ClientShotMeterInput 

type ClientShotMeterInput struct {
	ClientMessage_
	Sequence uint8
	Value    float32
}

type ClientShotPower 

type ClientShotPower struct {
	ClientMessage_
	Level uint8
}

type ClientShotRotate 

type ClientShotRotate struct {
	ClientMessage_
	Angle float32
}

type ClientShotSync 

type ClientShotSync struct {
	ClientMessage_
	Data    gamemodel.ShotSyncData
	Unknown [16]byte
}

type ClientTutorialClear 

type ClientTutorialClear struct {
	ClientMessage_
}

ClientTutorialClear is an unknown message.

type ClientTutorialStart 

type ClientTutorialStart struct {
	ClientMessage_
}

ClientTutorialStart is sent when starting a tutorial.

type ClientUserMacrosSet 

type ClientUserMacrosSet struct {
	ClientMessage_
	MacroList pangya.MacroList
}

ClientUserMacrosSet is a message sent to set the user's macros.

type ClientUserTypingIndicator 

type ClientUserTypingIndicator struct {
	ClientMessage_
	Status int16 // 1 = started, -1 = stopped
}

type CometUpdated added in v0.0.3 

type CometUpdated struct {
	ItemID     uint32
	ItemTypeID uint32
}

type ConnectMessage 

type ConnectMessage struct {
	Unknown [8]byte
	Key     byte
}

ConnectMessage is the message sent upon connecting.

func (*ConnectMessage) SetKey 

func (c *ConnectMessage) SetKey(key uint8)

type ConsumablesUpdated added in v0.0.3 

type ConsumablesUpdated struct {
	ItemTypeID [10]uint32
}

type DecorationUpdated added in v0.0.3 

type DecorationUpdated struct {
	BackgroundTypeID uint32
	FrameTypeID      uint32
	StickerTypeID    uint32
	SlotTypeID       uint32
	CutInTypeID      uint32
	TitleTypeID      uint32
}

type EquipmentUpdateType added in v0.0.3 

type EquipmentUpdateType uint8
const (
	UpdatedCharParts   EquipmentUpdateType = 0
	UpdatedCaddie      EquipmentUpdateType = 1
	UpdatedConsumables EquipmentUpdateType = 2
	UpdatedComet       EquipmentUpdateType = 3
	UpdatedDecoration  EquipmentUpdateType = 4
	UpdatedCharacter   EquipmentUpdateType = 5
)

type EventType 

type EventType byte

EventType enumerates message data event types.

type FurnitureItem added in v0.0.3 

type FurnitureItem struct {
	Unknown  uint32
	ItemID   uint32
	Unknown2 [19]byte
}

type GameEnd 

type GameEnd struct {
	Score   int32
	Pang    uint64
	Unknown uint8
}

type GameInitFull 

type GameInitFull struct {
	NumPlayers byte `struct:"sizeof=Players"`
	Players    []GamePlayer
}

type GameInitMinimal 

type GameInitMinimal struct {
	Unknown uint32
	Time    pangya.SystemTime
}

type GameInitType 

type GameInitType byte

type GamePlayer 

type GamePlayer struct {
	Number     uint16
	PlayerData pangya.PlayerData
	StartTime  pangya.SystemTime
	NumCards   uint8
}

type HoleInfo 

type HoleInfo struct {
	HoleID  uint32
	Pin     uint8
	Course  uint8
	HoleNum uint8
}

type InboxMessage 

type InboxMessage struct {
	ID              uint32
	SenderNickname  string `struct:"[30]byte"`
	Message         string `struct:"[80]byte"`
	Unknown         [18]byte
	Unknown2        uint32
	Unknown3        byte
	AttachmentCount uint32 `struct:"sizeof=Attachments"`
	Attachments     []MessageAttachment
}

type InventoryItem added in v0.0.3 

type InventoryItem struct {
	ItemID          uint32
	ItemTypeID      uint32
	Unknown         int32
	Quantity        uint32
	Unknown2        [7]byte
	Flags           byte
	RentalDateStart uint32
	Unknown3        uint32
	RentalDateEnd   uint32
	Unknown4        uint32
	Unknown5        [156]byte
}

type ListType 

type ListType byte

ListType enumerates the types of room list messages. 

const (
	ListSet    ListType = 0
	ListAdd    ListType = 1
	ListRemove ListType = 2
	ListChange ListType = 3

	// Only valid for lounge mode rooms
	ListLounge ListType = 7
)

type MailMessage 

type MailMessage struct {
	ID              uint32
	SenderNickname  common.PString
	DateTime        common.PString
	Message         common.PString
	Unknown         byte
	AttachmentCount uint32 `struct:"sizeof=Attachments"`
	Attachments     []MessageAttachment
}

type MessageAttachment 

type MessageAttachment struct {
	ID           uint32
	ItemID       uint32
	Unknown      byte
	ItemQuantity uint32
	Unknown2     uint32
	Unknown3     uint64
	Unknown5     uint64
	Unknown6     uint32
	Unknown7     uint32
	Unknown8     [12]byte
	Unknown10    uint16
}

type MoneyUpdateType 

type MoneyUpdateType uint16
const (
	MoneyUpdateRewardUnknown MoneyUpdateType = 2
	MoneyUpdatePangBalance   MoneyUpdateType = 273
)

type PlayerGameResult 

type PlayerGameResult struct {
	ConnID    uint32
	Place     uint8
	Score     int8
	Unknown   uint8
	Exp       uint16
	Pang      uint64
	BonusPang uint64
	Unknown3  uint64
}

type PlayerMainData 

type PlayerMainData struct {
	ClientVersion common.PString
	ServerVersion common.PString
	Game          uint16
	PlayerData    pangya.PlayerData
	Unknown2      [321]byte
}

PlayerMainData contains the main player information, sent after logging in.

type PurchaseItem 

type PurchaseItem struct {
	Unknown       uint32
	ItemTypeID    uint32
	Unknown2      uint16
	Unknown3      uint16
	Quantity      uint32
	ItemCostPang  uint32
	ItemCostPoint uint32
}

type RecentPlayer 

type RecentPlayer struct {
	Unknown  uint32
	Nickname string `struct:"[22]byte"`
	Username string `struct:"[22]byte"`
	PlayerID uint32
}

type RoomCensusListAdd 

type RoomCensusListAdd struct {
	User gamemodel.RoomPlayerEntry
}

type RoomCensusListChange 

type RoomCensusListChange struct {
	ConnID uint32
	User   gamemodel.RoomPlayerEntry
}

type RoomCensusListRemove 

type RoomCensusListRemove struct {
	ConnID uint32
}

type RoomCensusListSet 

type RoomCensusListSet struct {
	PlayerCount uint8 `struct:"sizeof=PlayerList"`
	PlayerList  []gamemodel.RoomPlayerEntry
	Unknown     byte
}

type RoomListRoom 

type RoomListRoom struct {
	Name             string `struct:"[64]byte"`
	Public           bool   `struct:"byte"`
	Open             bool   `struct:"uint16"`
	UserMax          uint8
	UserCount        uint8
	Key              [16]byte // Known thanks to SuperSS; XOR pad for shot sync data
	Unknown3         uint8
	Unknown4         uint8
	NumHoles         uint8
	HoleProgression  uint8
	Number           int16
	Unknown5         uint8
	Course           uint8
	ShotTimerMS      uint32
	GameTimerMS      uint32
	Flags            uint32
	Unknown6         [68]byte
	Unknown7         uint32
	Unknown8         uint32
	OwnerID          uint32
	Class            byte
	ArtifactID       uint32
	Unknown9         uint32
	EventNum         uint32
	EventNumTop      uint32
	EventShotTimerMS uint32
	Unknown10        uint32
}

type Server004E 

type Server004E struct {
	ServerMessage_
	Unknown []byte
}

type Server0077 

type Server0077 struct {
	ServerMessage_
	Unknown uint32
}

type Server0151 

type Server0151 struct {
	ServerMessage_
	Unknown []byte
}

type Server016A 

type Server016A struct {
	ServerMessage_
	Unknown  byte
	Unknown2 uint32
}

type Server01F6 

type Server01F6 struct {
	ServerMessage_
	Unknown []byte
}

type Server020E added in v0.0.3 

type Server020E struct {
	ServerMessage_
	Unknown [8]byte
}

type Server0230 

type Server0230 struct {
	ServerMessage_
}

type Server0231 

type Server0231 struct {
	ServerMessage_
}

type ServerAchievementProgress 

type ServerAchievementProgress struct {
	ServerMessage_
	Status       uint32
	Remaining    uint32
	Count        uint32 `struct:"sizeof=Achievements"`
	Achievements []AchievementProgress
}

type ServerAchievementStatusResponse added in v0.0.3 

type ServerAchievementStatusResponse struct {
	ServerMessage_
	Status    uint32
	Remaining uint32
	Count     uint32 `struct:"sizeof=Groups"`
	Groups    []AchievementGroup
}

type ServerAchievementUnknownResponse added in v0.0.3 

type ServerAchievementUnknownResponse struct {
	ServerMessage_
	UnknownA [4]byte
}

type ServerAssistModeToggled 

type ServerAssistModeToggled struct {
	ServerMessage_
	Unknown uint32
}

type ServerBigPapelWinnings added in v0.0.3 

type ServerBigPapelWinnings struct {
	ServerMessage_
	Status                  uint32
	BlackPapelInvTicketSlot uint32
	UniqueItemsWon          uint32 `struct:"sizeof=Items"`
	Items                   []ServerBlackPapelItems
	PangsRemaining          uint64
	CookiesRemaining        uint64
}

type ServerBlackPapelItems added in v0.0.3 

type ServerBlackPapelItems struct {
	DolfiniBallColor uint32
	ItemTypeID       uint32
	InventorySlot    uint32
	Quantity         uint32
	Rarity           uint32
}

type ServerBlackPapelResponse added in v0.0.3 

type ServerBlackPapelResponse struct {
	ServerMessage_
	RemainingTurns int32
	UnknownA       int32
}

type ServerBlackPapelWinnings added in v0.0.3 

type ServerBlackPapelWinnings struct {
	ServerMessage_
	Status                  uint32
	BlackPapelInvTicketSlot uint32
	UniqueItemsWon          uint32 `struct:"sizeof=Items"`
	Items                   []ServerBlackPapelItems
	PangsRemaining          uint64
	CookiesRemaining        uint64 // not filled in but seems correct
}

type ServerChannelList 

type ServerChannelList struct {
	ServerMessage_
	Count   byte `struct:"sizeof=Servers"`
	Servers []pangya.ServerEntry
}

ServerChannelList is a message that contains a list of all of the channels for a given server. Channels are isolated game zones within a region.

type ServerCharData 

type ServerCharData struct {
	ServerMessage_
	Count1     uint16 `struct:"sizeof=Characters"`
	Count2     uint16 `struct:"sizeof=Characters"`
	Characters []pangya.PlayerCharacterData
}

ServerCharData contains the user's characters.

type ServerConn 

type ServerConn = common.ServerConn[ClientMessage, ServerMessage]

type ServerEvent 

type ServerEvent struct {
	ServerMessage_
	Type    byte
	Data    ChatMessage
	GameEnd *GameEnd `struct-if:"Type == 16"`
}

ServerEvent is a message that contains events.

type ServerEventLobbyJoined 

type ServerEventLobbyJoined struct {
	ServerMessage_
}

type ServerEventLobbyLeft 

type ServerEventLobbyLeft struct {
	ServerMessage_
}

type ServerGameInit 

type ServerGameInit struct {
	ServerMessage_
	SubType byte
	Full    *GameInitFull    `struct-if:"SubType == 0"`
	Minimal *GameInitMinimal `struct-if:"SubType == 4"`
}

type ServerGuildListPage added in v0.0.3 

type ServerGuildListPage struct {
	ServerMessage_
	Status     uint32
	Page       uint32
	NumPages   uint32
	GuildCount uint16
	Guilds     []pangya.GuildData
}

type ServerInboxList 

type ServerInboxList struct {
	ServerMessage_
	Status      uint32
	PageNum     uint32
	NumPages    uint32
	NumMessages uint32 `struct:"sizeof=Messages"`
	Messages    []InboxMessage
}

type ServerInboxNotify 

type ServerInboxNotify struct {
	ServerMessage_
	Unknown []byte
}

ServerInboxNotify is unimplemented.

type ServerLockerCombinationResponse added in v0.0.3 

type ServerLockerCombinationResponse struct {
	ServerMessage_
	Status uint32
}

type ServerLockerInventoryResponse added in v0.0.3 

type ServerLockerInventoryResponse struct {
	ServerMessage_
	Unknown uint32
	Status  uint32
}

type ServerLoginBonusStatus 

type ServerLoginBonusStatus struct {
	ServerMessage_
	Unknown []byte
}

type ServerMailMessage 

type ServerMailMessage struct {
	ServerMessage_
	Status  uint32
	Message MailMessage
}

type ServerMessage 

type ServerMessage interface {
	common.Message
	// contains filtered or unexported methods
}

type ServerMessageConnect 

type ServerMessageConnect struct {
	ServerMessage_
	Unknown byte
}

ServerMessageConnect seems to make the client connect to the message server. TODO: need to do more reverse engineering effort

type ServerMessage_ 

type ServerMessage_ struct{}

type ServerMoneyUpdate 

type ServerMoneyUpdate struct {
	ServerMessage_
	Type uint16

	RewardUnknown *UpdateRewardUnknownData `struct-if:"Type == 2"`
	PangBalance   *UpdatePangBalanceData   `struct-if:"Type == 273"`
}

type ServerMultiplayerJoined 

type ServerMultiplayerJoined struct {
	ServerMessage_
}

type ServerMultiplayerLeft 

type ServerMultiplayerLeft struct {
	ServerMessage_
}

type ServerMyRoomEntered added in v0.0.3 

type ServerMyRoomEntered struct {
	ServerMessage_
	Unknown  uint32
	UserID   uint32
	Unknown2 uint32
	Unknown3 [99]byte
}

type ServerMyRoomLayout added in v0.0.3 

type ServerMyRoomLayout struct {
	ServerMessage_
	Unknown        uint32
	FurnitureCount uint16
	Furniture      []FurnitureItem
}

type ServerOpponentQuit 

type ServerOpponentQuit struct {
	ServerMessage_
}

type ServerPangBalanceData added in v0.0.3 

type ServerPangBalanceData struct {
	ServerMessage_
	PangsRemaining uint64
	PangsSpent     uint64
}

ServerPangBalanceData is sent after a pang purchase succeeds. Sometimes Pang Spent is not set like on Black Papel Transactions.

type ServerPlayerCharacterResponse added in v0.0.3 

type ServerPlayerCharacterResponse struct {
	ServerMessage_
	UserID    uint32
	Character pangya.PlayerCharacterData
}

type ServerPlayerData added in v0.0.3 

type ServerPlayerData struct {
	ServerMessage_
	SubType  byte
	MainData *PlayerMainData `struct-if:"SubType == 0"`
}

ServerPlayerData contains important state information.

type ServerPlayerDataResponse added in v0.0.3 

type ServerPlayerDataResponse struct {
	ServerMessage_
	Status  uint32
	Request uint8
	UserID  uint32
}

type ServerPlayerEquipment added in v0.0.3 

type ServerPlayerEquipment struct {
	ServerMessage_
	Equipment pangya.PlayerEquipment
}

type ServerPlayerEquipmentResponse added in v0.0.3 

type ServerPlayerEquipmentResponse struct {
	ServerMessage_
	Request   uint8
	UserID    uint32
	Equipment pangya.PlayerEquipment
}

type ServerPlayerEquipmentUpdated added in v0.0.3 

type ServerPlayerEquipmentUpdated struct {
	ServerMessage_
	Status      uint8
	Type        uint8
	CharParts   *pangya.PlayerCharacterData `struct-if:"Type == 0"`
	Caddie      *CaddieUpdated              `struct-if:"Type == 1"`
	Consumables *ConsumablesUpdated         `struct-if:"Type == 2"`
	Comet       *CometUpdated               `struct-if:"Type == 3"`
	Decoration  *DecorationUpdated          `struct-if:"Type == 4"`
	Character   *CharacterUpdated           `struct-if:"Type == 5"`
}

type ServerPlayerFirstShotReady 

type ServerPlayerFirstShotReady struct {
	ServerMessage_
}

type ServerPlayerHistory 

type ServerPlayerHistory struct {
	ServerMessage_
	RecentPlayers [5]RecentPlayer
}

type ServerPlayerID 

type ServerPlayerID struct {
	ServerMessage_
	Empty    byte
	PlayerID uint32
	Unknown  [239]byte
}

ServerPlayerID is a message that contains the PlayerID and some other unknown data.

type ServerPlayerInfo added in v0.0.3 

type ServerPlayerInfo struct {
	ServerMessage_
	Player gamemodel.RoomPlayerEntry
}

type ServerPlayerInfoResponse added in v0.0.3 

type ServerPlayerInfoResponse struct {
	ServerMessage_
	Request uint8
	UserID  uint32
	RoomID  uint16
	Info    pangya.PlayerInfo
	Unknown uint32
}

type ServerPlayerInventory added in v0.0.3 

type ServerPlayerInventory struct {
	ServerMessage_
	Remaining uint16
	Count     uint16 `struct:"sizeof=Inventory"`
	Inventory []InventoryItem
}

type ServerPlayerLoadProgress 

type ServerPlayerLoadProgress struct {
	ServerMessage_
	ConnID   uint32
	Progress uint8
}

type ServerPlayerQuitGame added in v0.0.3 

type ServerPlayerQuitGame struct {
	ServerMessage_
	ConnID uint32
}

type ServerPlayerReady 

type ServerPlayerReady struct {
	ServerMessage_
	ConnID uint32
	State  byte
}

type ServerPlayerStatisticsResponse added in v0.0.3 

type ServerPlayerStatisticsResponse struct {
	ServerMessage_
	Request uint8
	UserID  uint32
	Stats   pangya.PlayerStats
}

type ServerPointsBalance added in v0.0.3 

type ServerPointsBalance struct {
	ServerMessage_
	Points uint64
}

type ServerPurchaseItemResponse added in v0.0.3 

type ServerPurchaseItemResponse struct {
	ServerMessage_
	Status uint32
	Pang   uint64
	Points uint64
}

type ServerQuestStatus added in v0.0.3 

type ServerQuestStatus struct {
	ServerMessage_
	Status               uint32
	QuestExpiryUnixTime  uint32
	QuestStartedUnixTime uint32
	QuestCount           uint32 `struct:"sizeof=QuestTypeID"`
	QuestTypeID          []uint32
	QuestSlotCount       uint32 `struct:"sizeof=QuestStatusSlot"`
	QuestStatusSlot      []uint32
}

type ServerRareShopOpen added in v0.0.3 

type ServerRareShopOpen struct {
	ServerMessage_
	UnknownA int32
	UnknownB int32
	UnknownC uint32
}

type ServerRoomAction 

type ServerRoomAction struct {
	ServerMessage_
	ConnID uint32
	gamemodel.RoomAction
}

type ServerRoomActiveUserAnnounce 

type ServerRoomActiveUserAnnounce struct {
	ServerMessage_
	ConnID uint32
}

type ServerRoomCensus 

type ServerRoomCensus struct {
	ServerMessage_
	Type       byte
	Unknown    int16
	ListSet    *RoomCensusListSet    `struct-if:"Type == 0"`
	ListAdd    *RoomCensusListAdd    `struct-if:"Type == 1"`
	ListRemove *RoomCensusListRemove `struct-if:"Type == 2"`
	ListChange *RoomCensusListChange `struct-if:"Type == 3"`
}

ServerRoomCensus reports on the users in a game room.

type ServerRoomClubChangeAnnounce 

type ServerRoomClubChangeAnnounce struct {
	ServerMessage_
	ConnID uint32
	Club   uint8
}

type ServerRoomEquipmentData 

type ServerRoomEquipmentData struct {
	ServerMessage_
	Unknown []byte
}

type ServerRoomFinishGame 

type ServerRoomFinishGame struct {
	ServerMessage_
	NumPlayers uint8
	Standings  []PlayerGameResult `struct:"sizefrom=NumPlayers"`
}

type ServerRoomFinishHole 

type ServerRoomFinishHole struct {
	ServerMessage_
}

type ServerRoomGameData 

type ServerRoomGameData struct {
	ServerMessage_
	Course          byte
	Unknown         byte
	HoleProgression byte
	NumHoles        uint8
	Unknown2        uint32
	ShotTimerMS     uint32
	GameTimerMS     uint32
	Holes           [18]HoleInfo // `struct:"sizefrom=NumHoles"`
	RandomSeed      uint32
	Unknown3        [18]byte
}

type ServerRoomInfoResponse 

type ServerRoomInfoResponse struct {
	ServerMessage_
	RoomInfo gamemodel.RoomInfo
}

type ServerRoomItemUseAnnounce 

type ServerRoomItemUseAnnounce struct {
	ServerMessage_
	ItemTypeID uint32
	Unknown    uint32
	ConnID     uint32
}

type ServerRoomJoin 

type ServerRoomJoin struct {
	ServerMessage_
	Status      uint16
	RoomName    string `struct:"[64]byte"`
	Unknown2    [25]byte
	RoomNumber  int16
	Unknown3    [111]byte
	EventNumber uint32
	Unknown4    uint32
}

ServerRoomJoin is sent when a room is joined.

type ServerRoomLeave 

type ServerRoomLeave struct {
	ServerMessage_
	RoomNumber int16
}

type ServerRoomList 

type ServerRoomList struct {
	ServerMessage_
	Count    uint8 `struct:"sizeof=RoomList"`
	Type     ListType
	Unknown  uint16
	RoomList []RoomListRoom
}

ServerRoomList contains information about rooms currently open in multiplayer.

type ServerRoomPlayerFinished added in v0.0.3 

type ServerRoomPlayerFinished struct {
	ServerMessage_
}

type ServerRoomSetWeather 

type ServerRoomSetWeather struct {
	ServerMessage_
	Weather uint16
	Unknown uint8
}

type ServerRoomSetWind 

type ServerRoomSetWind struct {
	ServerMessage_
	Wind    uint8
	Unknown uint8
	Heading uint16
	Reset   bool `struct:"bool"`
}

type ServerRoomShotAnnounce 

type ServerRoomShotAnnounce struct {
	ServerMessage_
	ConnID           uint32
	ShotStrength     float32
	ShotAccuracy     float32
	ShotEnglishCurve float32
	ShotEnglishSpin  float32
	Unknown2         [30]byte
	Unknown3         [4]float32
}

type ServerRoomShotCometReliefAnnounce 

type ServerRoomShotCometReliefAnnounce struct {
	ServerMessage_
	ConnID  uint32
	X, Y, Z float32
}

type ServerRoomShotEnd 

type ServerRoomShotEnd struct {
	ServerMessage_
	ConnID uint32
}

type ServerRoomShotPowerAnnounce 

type ServerRoomShotPowerAnnounce struct {
	ServerMessage_
	ConnID uint32
	Level  uint8
}

type ServerRoomShotRotateAnnounce 

type ServerRoomShotRotateAnnounce struct {
	ServerMessage_
	ConnID uint32
	Angle  float32
}

type ServerRoomShotSync 

type ServerRoomShotSync struct {
	ServerMessage_
	Data gamemodel.ShotSyncData
}

type ServerRoomStartHole 

type ServerRoomStartHole struct {
	ServerMessage_
	ConnID uint32
}

type ServerRoomStatus 

type ServerRoomStatus struct {
	ServerMessage_
	Unknown         uint16
	RoomType        byte
	Course          byte
	NumHoles        byte
	HoleProgression byte
	NaturalWind     uint32
	MaxUsers        byte
	Unknown2        uint16
	ShotTimerMS     uint32
	GameTimerMS     uint32
	Flags           uint32
	Owner           bool `struct:"byte"`
	RoomName        common.PString
}

ServerRoomStatus is sent when a room's settings or status changes.

type ServerRoomUserTypingAnnounce 

type ServerRoomUserTypingAnnounce struct {
	ServerMessage_
	ConnID uint32
	Status int16
}

type ServerScratchyMenuResponse added in v0.0.3 

type ServerScratchyMenuResponse struct {
	ServerMessage_
	Status  uint32
	Unknown uint8
}

type ServerTutorialStatus 

type ServerTutorialStatus struct {
	ServerMessage_
	Unknown [6]byte
}

type ServerUserCensus 

type ServerUserCensus struct {
	ServerMessage_
	Type       UserCensusType
	Count      uint8 `struct:"sizeof=PlayerList"`
	PlayerList []gamemodel.LobbyPlayer
}

ServerUserCensus contains information about users currently online in multiplayer

type ServerUserInfo 

type ServerUserInfo struct {
	ServerMessage_
	ResponseCode uint8
	PlayerID     uint32
	UserInfo     pangya.PlayerInfo
}

ServerUserInfo contains requested user information.

type ServerUserStatusUpdate 

type ServerUserStatusUpdate struct {
	ServerMessage_
	DateTimeUnix uint32
	Count        uint32
	Changes      []UserStatusChange
}

type SyncEntry 

type SyncEntry struct {
	Unknown1 uint8
	Unknown2 uint32
}

type UpdateCaddie 

type UpdateCaddie struct {
	CaddieID uint32
}

type UpdateCharacter 

type UpdateCharacter struct {
	CharacterID uint32
}

type UpdateComet 

type UpdateComet struct {
	ItemTypeID uint32
}

type UpdateConsumables 

type UpdateConsumables struct {
	ItemTypeID [10]uint32
}

type UpdateDecoration 

type UpdateDecoration struct {
	BackgroundTypeID uint32
	FrameTypeID      uint32
	StickerTypeID    uint32
	SlotTypeID       uint32
	CutInTypeID      uint32
	TitleTypeID      uint32
}

type UpdatePangBalanceData 

type UpdatePangBalanceData struct {
	Status     uint32
	PangAmount uint64
}

type UpdateRewardUnknownData 

type UpdateRewardUnknownData struct {
	Unknown uint16
}

type UpdateUnknown1 

type UpdateUnknown1 struct {
	Unknown uint32
}

type UpdateUnknown2 

type UpdateUnknown2 struct {
	CharacterID uint32
	Unknown     [4]uint32
}

type UserCensusType 

type UserCensusType byte

UserCensusType enumerates the types of census messages. 

const (
	UserAdd        UserCensusType = 1
	UserChange     UserCensusType = 2
	UserRemove     UserCensusType = 3
	UserListSet    UserCensusType = 4
	UserListAppend UserCensusType = 5
)

type UserStatusChange 

type UserStatusChange struct {
	StatusChangeType byte
	Value            *UserStatusChangeValue   `struct-if:"StatusChangeType == 2"`
	Mastery          *UserStatusChangeMastery `struct-if:"StatusChangeType == 201"`
	Unknown204       *UserStatusChange204     `struct-if:"StatusChangeType == 204"`
}

type UserStatusChange204 

type UserStatusChange204 struct {
	Unknown [72]byte
}

type UserStatusChangeMastery 

type UserStatusChangeMastery struct {
	CharacterID           uint32
	StatusSlot            uint32
	Unknown               [16]byte
	MasteryPowerUpCount   uint16
	MasteryControlUpCount uint16
	MasteryImpactUpCount  uint16
	MasterySpinUpCount    uint16
	MasteryCurveUpCount   uint16
	Unknown2              [16]byte
}

type UserStatusChangeValue 

type UserStatusChangeValue struct {
	StatusID          uint32
	StatusSlot        uint32
	Unknown           uint32
	StatusAmountOld   uint32
	StatusAmountNew   uint32
	StatusAmountDelta int32
	Unknown2          [25]byte
}

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.