steam

package module
v0.0.1 Latest Latest
Warning

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

Go to latest
Published: Oct 19, 2023 License: BSD-3-Clause Imports: 34 Imported by: 0

README

Steam for Go

Automate actions on the Steam network with Go.

Introduction

This library implements Steam's protocol to allow automation of different actions on Steam without running an actual Steam client. It is based on SteamKit2, a .NET library.

In addition, it contains APIs to Steam Community features, like trade offers and inventories.

Some of the currently implemented features:

  • Trading and trade offers, including inventories and notifications
  • Friend and group management
  • Chatting with friends
  • Persona states (online, offline, looking to trade, etc.)
  • SteamGuard with two-factor authentication
  • Team Fortress 2: Crafting, moving, naming and deleting items

If this is useful to you, there's also the go-steamapi package that wraps some of the official Steam Web API's types.

This package was originally authored by Philipp15b.

Installation

go get github.com/paralin/go-steam

Usage

You can view the documentation with the godoc tool or online on godoc.org.

You should also take a look at the following sub-packages:

Working with go-steam

Whether you want to develop your own Steam bot or directly work on go-steam itself, there are are few things to know.

  • If something is not working, check first if the same operation works (under the same conditions!) in the Steam client on that account. Maybe there's something go-steam doesn't handle correctly or you're missing a warning that's not obviously shown in go-steam. This is particularly important when working with trading since there are restrictions, for example newly authorized devices will not be able to trade for seven days.
  • Since Steam does not maintain a public API for most of the things go-steam implements, you can expect that sometimes things break randomly. Especially the trade and tradeoffer packages have been affected in the past.
  • Always gather as much information as possible. When you file an issue, be as precise and complete as you can. This makes debugging way easier.
  • If you haven't noticed yet, expect to find lots of things out yourself. Debugging can be complicated and Steam's internals are too.
  • Sometimes things break and other SteamKit ports are fixed already. Maybe take a look what people are saying over there? There's also the SteamKit IRC channel.

Updating go-steam to a new SteamKit version

To update go-steam to a new version of SteamKit, do the following:

cd generator
go get -d -v ./
go build -v
./generator clean proto steamlang

Apply the protocol changes where necessary.

License

Steam for Go is licensed under the New BSD License. More information can be found in LICENSE.txt.

Documentation

Overview

This package allows you to automate actions on Valve's Steam network. It is a Go port of SteamKit.

To login, you'll have to create a new Client first. Then connect to the Steam network and wait for a ConnectedCallback. Then you may call the Login method in the Auth module with your login information. This is covered in more detail in the method's documentation. After you've received the LoggedOnEvent, you should set your persona state to online to receive friend lists etc.

Example code

You can also find a running example in the `gsbot` package.

package main

import (
	"io/ioutil"
	"log"

	"github.com/paralin/go-steam"
	"github.com/paralin/go-steam/protocol/steamlang"
)

func main() {
	myLoginInfo := new(steam.LogOnDetails)
	myLoginInfo.Username = "Your username"
	myLoginInfo.Password = "Your password"

	client := steam.NewClient()
	client.Connect()
	for event := range client.Events() {
		switch e := event.(type) {
		case *steam.ConnectedEvent:
			client.Auth.LogOn(myLoginInfo)
		case *steam.MachineAuthUpdateEvent:
			ioutil.WriteFile("sentry", e.Hash, 0666)
		case *steam.LoggedOnEvent:
			client.Social.SetPersonaState(steamlang.EPersonaState_Online)
		case steam.FatalErrorEvent:
			log.Print(e)
		case error:
			log.Print(e)
		}
	}
}

Events

go-steam emits events that can be read via Client.Events(). Although the channel has the type interface{}, only types from this package ending with "Event" and errors will be emitted.

Index

Constants

This section is empty.

Variables

View Source
var CMServers = [][]string{
	{

		"162.254.193.44:27018",
		"162.254.193.44:27019",
		"162.254.193.44:27020",
		"162.254.193.44:27021",
		"162.254.193.45:27017",
		"162.254.193.45:27018",
		"162.254.193.45:27019",
		"162.254.193.45:27021",
		"162.254.193.46:27017",
		"162.254.193.46:27018",
		"162.254.193.46:27019",
		"162.254.193.46:27020",
		"162.254.193.46:27021",
		"162.254.193.47:27019",
		"162.254.193.47:27020",

		"208.78.164.9:27017",
		"208.78.164.9:27018",
		"208.78.164.9:27019",
		"208.78.164.10:27017",
		"208.78.164.10:27018",
		"208.78.164.10:27019",
		"208.78.164.11:27017",
		"208.78.164.11:27018",
		"208.78.164.11:27019",
		"208.78.164.12:27017",
		"208.78.164.12:27018",
		"208.78.164.12:27019",
		"208.78.164.13:27017",
		"208.78.164.13:27018",
		"208.78.164.13:27019",
		"208.78.164.14:27017",
		"208.78.164.14:27018",
		"208.78.164.14:27019",
	},
	{

		"146.66.152.10:27017",
		"146.66.152.10:27018",
		"146.66.152.10:27019",
		"146.66.152.10:27020",
		"146.66.152.11:27017",
		"146.66.152.11:27018",
		"146.66.152.11:27019",
		"146.66.152.11:27020",

		"155.133.242.8:27017",
		"155.133.242.8:27018",
		"155.133.242.8:27019",
		"155.133.242.8:27020",
		"155.133.242.9:27017",
		"155.133.242.9:27018",
		"155.133.242.9:27019",
		"155.133.242.9:27020",

		"146.66.155.8:27017",
		"146.66.155.8:27018",
		"146.66.155.8:27019",
		"146.66.155.8:27020",
		"185.25.182.10:27017",
		"185.25.182.10:27018",
		"185.25.182.10:27019",
		"185.25.182.10:27020",

		"162.254.196.40:27017",
		"162.254.196.40:27018",
		"162.254.196.40:27019",
		"162.254.196.40:27020",
		"162.254.196.40:27021",
		"162.254.196.41:27017",
		"162.254.196.41:27018",
		"162.254.196.41:27019",
		"162.254.196.41:27020",
		"162.254.196.41:27021",
		"162.254.196.42:27017",
		"162.254.196.42:27018",
		"162.254.196.42:27019",
		"162.254.196.42:27020",
		"162.254.196.42:27021",
		"162.254.196.43:27017",
		"162.254.196.43:27018",
		"162.254.196.43:27019",
		"162.254.196.43:27020",
		"162.254.196.43:27021",

		"185.25.180.14:27017",
		"185.25.180.14:27018",
		"185.25.180.14:27019",
		"185.25.180.14:27020",
		"185.25.180.15:27017",
		"185.25.180.15:27018",
		"185.25.180.15:27019",
		"185.25.180.15:27020",
	},
}

CMServers contains a list of worlwide servers

Functions

func GetPublicKey

func GetPublicKey(universe EUniverse) *rsa.PublicKey

func GetRandomCM

func GetRandomCM() *netutil.PortAddr

GetRandomCM returns back a random server anywhere

func GetRandomEuropeCM

func GetRandomEuropeCM() *netutil.PortAddr

GetRandomEuropeCM returns back a random server in europe

func GetRandomNorthAmericaCM

func GetRandomNorthAmericaCM() *netutil.PortAddr

GetRandomNorthAmericaCM returns back a random server in north america

func InitializeSteamDirectory

func InitializeSteamDirectory() error

Load initial server list from Steam Directory Web API. Call InitializeSteamDirectory() before Connect() to use steam directory server list instead of static one.

Types

type AccountInfoEvent

type AccountInfoEvent struct {
	PersonaName          string
	Country              string
	CountAuthedComputers int32
	AccountFlags         EAccountFlags
	FacebookId           uint64 `json:",string"`
	FacebookName         string
}

type Auth

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

func (*Auth) HandlePacket

func (a *Auth) HandlePacket(packet *Packet)

func (*Auth) LogOn

func (a *Auth) LogOn(details *LogOnDetails)

Log on with the given details. You must always specify username and password OR username and loginkey. For the first login, don't set an authcode or a hash and you'll

receive an error (EResult_AccountLogonDenied)

and Steam will send you an authcode. Then you have to login again, this time with the authcode. Shortly after logging in, you'll receive a MachineAuthUpdateEvent with a hash which allows you to login without using an authcode in the future.

If you don't use Steam Guard, username and password are enough.

After the event EMsg_ClientNewLoginKey is received you can use the LoginKey to login instead of using the password.

type ChatActionResultEvent

type ChatActionResultEvent struct {
	ChatRoomId SteamId `json:",string"`
	ChatterId  SteamId `json:",string"`
	Action     EChatAction
	Result     EChatActionResult
}

Fired when a chat action has completed

type ChatEnterEvent

type ChatEnterEvent struct {
	ChatRoomId    steamid.SteamId `json:",string"`
	FriendId      steamid.SteamId `json:",string"`
	ChatRoomType  EChatRoomType
	OwnerId       steamid.SteamId `json:",string"`
	ClanId        steamid.SteamId `json:",string"`
	ChatFlags     byte
	EnterResponse EChatRoomEnterResponse
	Name          string
}

Fired in response to joining a chat

type ChatInviteEvent

type ChatInviteEvent struct {
	InvitedId    steamid.SteamId `json:",string"`
	ChatRoomId   steamid.SteamId `json:",string"`
	PatronId     steamid.SteamId `json:",string"`
	ChatRoomType EChatRoomType
	FriendChatId steamid.SteamId `json:",string"`
	ChatRoomName string
	GameId       uint64 `json:",string"`
}

Fired when a chat invite is received

type ChatMemberInfoEvent

type ChatMemberInfoEvent struct {
	ChatRoomId      steamid.SteamId `json:",string"`
	Type            EChatInfoType
	StateChangeInfo StateChangeDetails
}

Fired in response to a chat member's info being received

type ChatMsgEvent

type ChatMsgEvent struct {
	ChatRoomId SteamId `json:",string"` // not set for friend messages
	ChatterId  SteamId `json:",string"`
	Message    string
	EntryType  EChatEntryType
	Timestamp  time.Time
	Offline    bool
}

Fired when the client receives a message from either a friend or a chat room

func (*ChatMsgEvent) IsMessage

func (c *ChatMsgEvent) IsMessage() bool

Whether the type is ChatMsg

type ClanEventDetails

type ClanEventDetails struct {
	Id         uint64 `json:",string"`
	EventTime  uint32
	Headline   string
	GameId     uint64 `json:",string"`
	JustPosted bool
}

type ClanStateEvent

type ClanStateEvent struct {
	ClandId             steamid.SteamId `json:",string"`
	StateFlags          EClientPersonaStateFlag
	AccountFlags        EAccountFlags
	ClanName            string
	Avatar              string
	MemberTotalCount    uint32
	MemberOnlineCount   uint32
	MemberChattingCount uint32
	MemberInGameCount   uint32
	Events              []ClanEventDetails
	Announcements       []ClanEventDetails
}

Fired when a clan's state has been changed

type Client

type Client struct {
	Auth          *Auth
	Social        *Social
	Web           *Web
	Notifications *Notifications
	Trading       *Trading
	GC            *GameCoordinator

	ConnectionTimeout time.Duration
	// contains filtered or unexported fields
}

Represents a client to the Steam network. Always poll events from the channel returned by Events() or receiving messages will stop. All access, unless otherwise noted, should be threadsafe.

When a FatalErrorEvent is emitted, the connection is automatically closed. The same client can be used to reconnect. Other errors don't have any effect.

func NewClient

func NewClient() *Client

func (*Client) Connect

func (c *Client) Connect() *netutil.PortAddr

Connects to a random Steam server and returns its address. If this client is already connected, it is disconnected first. This method tries to use an address from the Steam Directory and falls back to the built-in server list if the Steam Directory can't be reached. If you want to connect to a specific server, use `ConnectTo`.

func (*Client) ConnectTo

func (c *Client) ConnectTo(addr *netutil.PortAddr)

Connects to a specific server. You may want to use one of the `GetRandom*CM()` functions in this package. If this client is already connected, it is disconnected first.

func (*Client) ConnectToBind

func (c *Client) ConnectToBind(addr *netutil.PortAddr, local *net.TCPAddr)

Connects to a specific server, and binds to a specified local IP If this client is already connected, it is disconnected first.

func (*Client) Connected

func (c *Client) Connected() bool

func (*Client) Disconnect

func (c *Client) Disconnect()

func (*Client) Emit

func (c *Client) Emit(event interface{})

func (*Client) Errorf

func (c *Client) Errorf(format string, a ...interface{})

Emits an error formatted with fmt.Errorf.

func (*Client) Events

func (c *Client) Events() <-chan interface{}

Get the event channel. By convention all events are pointers, except for errors. It is never closed.

func (*Client) Fatalf

func (c *Client) Fatalf(format string, a ...interface{})

Emits a FatalErrorEvent formatted with fmt.Errorf and disconnects.

func (*Client) GetNextJobId

func (c *Client) GetNextJobId() JobId

GetNextJobId returns the next job ID to use.

func (*Client) RegisterPacketHandler

func (c *Client) RegisterPacketHandler(handler PacketHandler)

Registers a PacketHandler that receives all incoming packets.

func (*Client) SessionId

func (c *Client) SessionId() int32

SessionId returns the session id.

func (*Client) SteamId

func (c *Client) SteamId() steamid.SteamId

SteamId returns the client's steam ID.

func (*Client) Write

func (c *Client) Write(msg IMsg)

Adds a message to the send queue. Modifications to the given message after writing are not allowed (possible race conditions).

Writes to this client when not connected are ignored.

type ClientCMListEvent

type ClientCMListEvent struct {
	Addresses []*netutil.PortAddr
}

A list of connection manager addresses to connect to in the future. You should always save them and then select one of these instead of the builtin ones for the next connection.

type ConnectedEvent

type ConnectedEvent struct{}

type DisconnectedEvent

type DisconnectedEvent struct{}

type FatalErrorEvent

type FatalErrorEvent error

When this event is emitted by the Client, the connection is automatically closed. This may be caused by a network error, for example.

type FriendAddedEvent

type FriendAddedEvent struct {
	Result      EResult
	SteamId     steamid.SteamId `json:",string"`
	PersonaName string
}

Fired in response to adding a friend to your friends list

type FriendStateEvent

type FriendStateEvent struct {
	SteamId      steamid.SteamId `json:",string"`
	Relationship EFriendRelationship
}

func (*FriendStateEvent) IsFriend

func (f *FriendStateEvent) IsFriend() bool

type FriendsListEvent

type FriendsListEvent struct{}

type GCPacketHandler

type GCPacketHandler interface {
	HandleGCPacket(*GCPacket)
}

type GameCoordinator

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

func (*GameCoordinator) HandlePacket

func (g *GameCoordinator) HandlePacket(packet *Packet)

func (*GameCoordinator) RegisterPacketHandler

func (g *GameCoordinator) RegisterPacketHandler(handler GCPacketHandler)

func (*GameCoordinator) SetGamesPlayed

func (g *GameCoordinator) SetGamesPlayed(appIds ...uint64)

Sets you in the given games. Specify none to quit all games.

func (*GameCoordinator) Write

func (g *GameCoordinator) Write(msg IGCMsg)

type GroupStateEvent

type GroupStateEvent struct {
	SteamId      steamid.SteamId `json:",string"`
	Relationship EClanRelationship
}

func (*GroupStateEvent) IsMember

func (g *GroupStateEvent) IsMember() bool

type IgnoreFriendEvent

type IgnoreFriendEvent struct {
	Result EResult
}

Fired in response to ignoring a friend

type LogOnDetails

type LogOnDetails struct {
	Username string

	// If logging into an account without a login key, the account's password.
	Password string

	// If you have a Steam Guard email code, you can provide it here.
	AuthCode string

	// If you have a Steam Guard mobile two-factor authentication code, you can provide it here.
	TwoFactorCode  string
	SentryFileHash SentryHash
	LoginKey       string

	// true if you want to get a login key which can be used in lieu of
	// a password for subsequent logins. false or omitted otherwise.
	ShouldRememberPassword bool
}

type LogOnFailedEvent

type LogOnFailedEvent struct {
	Result EResult
}

type LoggedOffEvent

type LoggedOffEvent struct {
	Result EResult
}

type LoggedOnEvent

type LoggedOnEvent struct {
	Result         EResult
	ExtendedResult EResult
	AccountFlags   EAccountFlags
	ClientSteamId  steamid.SteamId `json:",string"`
	Body           *protobuf.CMsgClientLogonResponse
}

type LoginKeyEvent

type LoginKeyEvent struct {
	UniqueId uint32
	LoginKey string
}

type MachineAuthUpdateEvent

type MachineAuthUpdateEvent struct {
	Hash []byte
}

type NotificationEvent

type NotificationEvent struct {
	Type  NotificationType
	Count uint
}

This event is emitted for every CMsgClientUserNotifications message and likewise only used for trade offers. Unlike the the above it is also emitted when the count of a type that was tracked before by this Notifications instance reaches zero.

type NotificationType

type NotificationType uint
const (
	TradeOffer NotificationType = 1
)

type Notifications

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

func (*Notifications) HandlePacket

func (n *Notifications) HandlePacket(packet *Packet)

type PacketHandler

type PacketHandler interface {
	HandlePacket(*Packet)
}

type PersonaStateEvent

type PersonaStateEvent struct {
	StatusFlags            EClientPersonaStateFlag
	FriendId               steamid.SteamId `json:",string"`
	State                  EPersonaState
	StateFlags             EPersonaStateFlag
	GameAppId              uint32
	GameId                 uint64 `json:",string"`
	GameName               string
	GameServerIp           uint32
	GameServerPort         uint32
	QueryPort              uint32
	SourceSteamId          steamid.SteamId `json:",string"`
	GameDataBlob           []byte
	Name                   string
	Avatar                 string
	LastLogOff             uint32
	LastLogOn              uint32
	ClanRank               uint32
	ClanTag                string
	OnlineSessionInstances uint32
	PublishedSessionId     uint32
	PersonaSetByUser       bool
	FacebookName           string
	FacebookId             uint64 `json:",string"`
}

Fired when someone changing their friend details

type ProfileInfoEvent

type ProfileInfoEvent struct {
	Result      EResult
	SteamId     steamid.SteamId `json:",string"`
	TimeCreated uint32
	RealName    string
	CityName    string
	StateName   string
	CountryName string
	Headline    string
	Summary     string
}

Fired in response to requesting profile info for a user

type SentryHash

type SentryHash []byte

type Social

type Social struct {
	Friends *socialcache.FriendsList
	Groups  *socialcache.GroupsList
	Chats   *socialcache.ChatsList
	// contains filtered or unexported fields
}

Social provides access to social aspects of Steam.

func (*Social) AddFriend

func (s *Social) AddFriend(id steamid.SteamId)

AddFriend a friend to your friends list or accepts a friend. You'll receive a FriendStateEvent for every new/changed friend

func (*Social) BanChatMember

func (s *Social) BanChatMember(room steamid.SteamId, user SteamId)

BanChatMember the specified chat member from the given chat room

func (*Social) GetAvatar

func (s *Social) GetAvatar() string

GetAvatar the local user's avatar

func (*Social) GetPersonaName

func (s *Social) GetPersonaName() string

GetPersonaName the local user's persona name

func (*Social) GetPersonaState

func (s *Social) GetPersonaState() EPersonaState

GetPersonaState the local user's persona state

func (*Social) HandlePacket

func (s *Social) HandlePacket(packet *Packet)

HandlePacket handles a Steam packet.

func (*Social) IgnoreFriend

func (s *Social) IgnoreFriend(id steamid.SteamId, setIgnore bool)

IgnoreFriend ignores or unignores a friend on Steam

func (*Social) JoinChat

func (s *Social) JoinChat(id steamid.SteamId)

JoinChat attempts to join a chat room

func (*Social) KickChatMember

func (s *Social) KickChatMember(room steamid.SteamId, user SteamId)

KickChatMember the specified chat member from the given chat room

func (*Social) LeaveChat

func (s *Social) LeaveChat(id steamid.SteamId)

LeaveChat attempts to leave a chat room

func (*Social) RemoveFriend

func (s *Social) RemoveFriend(id steamid.SteamId)

RemoveFriend removes a friend from your friends list

func (*Social) RequestFriendInfo

func (s *Social) RequestFriendInfo(id steamid.SteamId, requestedInfo EClientPersonaStateFlag)

RequestFriendInfo requests persona state for a specified SteamId

func (*Social) RequestFriendListInfo

func (s *Social) RequestFriendListInfo(ids []steamid.SteamId, requestedInfo EClientPersonaStateFlag)

RequestFriendListInfo requests persona state for a list of specified SteamIds

func (*Social) RequestProfileInfo

func (s *Social) RequestProfileInfo(id steamid.SteamId)

RequestProfileInfo requests profile information for a specified SteamId

func (*Social) SendMessage

func (s *Social) SendMessage(to steamid.SteamId, entryType EChatEntryType, message string)

SendMessage a chat message to ether a room or friend

func (*Social) SetPersonaName

func (s *Social) SetPersonaName(name string)

SetPersonaName the local user's persona name and broadcasts it over the network

func (*Social) SetPersonaState

func (s *Social) SetPersonaState(state EPersonaState)

SetPersonaState the local user's persona state and broadcasts it over the network

func (*Social) UnbanChatMember

func (s *Social) UnbanChatMember(room steamid.SteamId, user SteamId)

UnbanChatMember the specified chat member from the given chat room

type StateChangeDetails

type StateChangeDetails struct {
	ChatterActedOn SteamId `json:",string"`
	StateChange    EChatMemberStateChange
	ChatterActedBy SteamId `json:",string"`
}

type SteamFailureEvent

type SteamFailureEvent struct {
	Result EResult
}

Returned when Steam is down for some reason. A disconnect will follow, probably.

type TradeProposedEvent

type TradeProposedEvent struct {
	RequestId TradeRequestId
	Other     SteamId `json:",string"`
}

type TradeRequestId

type TradeRequestId uint32

type TradeResultEvent

type TradeResultEvent struct {
	RequestId TradeRequestId
	Response  EEconTradeResponse
	Other     SteamId `json:",string"`
	// Number of days Steam Guard is required to have been active
	NumDaysSteamGuardRequired uint32
	// Number of days a new device cannot trade for.
	NumDaysNewDeviceCooldown uint32
	// Default number of days one cannot trade after a password reset.
	DefaultNumDaysPasswordResetProbation uint32
	// See above.
	NumDaysPasswordResetProbation uint32
}

type TradeSessionStartEvent

type TradeSessionStartEvent struct {
	Other SteamId `json:",string"`
}

type Trading

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

Provides access to the Steam client's part of Steam Trading, that is bootstrapping the trade. The trade itself is not handled by the Steam client itself, but it's a part of the Steam website.

You'll receive a TradeProposedEvent when a friend proposes a trade. You can accept it with the RespondRequest method. You can request a trade yourself with RequestTrade.

func (*Trading) CancelRequest

func (t *Trading) CancelRequest(other SteamId)

This cancels a request made with RequestTrade.

func (*Trading) HandlePacket

func (t *Trading) HandlePacket(packet *Packet)

func (*Trading) RequestTrade

func (t *Trading) RequestTrade(other SteamId)

Requests a trade. You'll receive a TradeResultEvent if the request fails or if the friend accepted the trade.

func (*Trading) RespondRequest

func (t *Trading) RespondRequest(requestId TradeRequestId, accept bool)

Responds to a TradeProposedEvent.

type Web

type Web struct {

	// The `sessionid` cookie required to use the steam website.
	// This cookie may contain a characters that will need to be URL-escaped, otherwise
	// Steam (probably) interprets is as a string.
	// When used as an URL paramter this is automatically escaped by the Go HTTP package.
	SessionId string
	// The `steamLogin` cookie required to use the steam website. Already URL-escaped.
	// This is only available after calling LogOn().
	SteamLogin string
	// The `steamLoginSecure` cookie required to use the steam website over HTTPs. Already URL-escaped.
	// This is only availbile after calling LogOn().
	SteamLoginSecure string
	// contains filtered or unexported fields
}

func (*Web) HandlePacket

func (w *Web) HandlePacket(packet *Packet)

func (*Web) LogOn

func (w *Web) LogOn()

Fetches the `steamLogin` cookie. This may only be called after the first WebSessionIdEvent or it will panic.

type WebLogOnErrorEvent

type WebLogOnErrorEvent error

type WebLoggedOnEvent

type WebLoggedOnEvent struct{}

type WebSessionIdEvent

type WebSessionIdEvent struct{}

Directories

Path Synopsis
dota
economy
inventory
Includes inventory types as used in the trade package
Includes inventory types as used in the trade package
This program generates the protobuf and SteamLanguage files from the SteamKit data.
This program generates the protobuf and SteamLanguage files from the SteamKit data.
A simple example that uses the modules from the gsbot package and go-steam to log on to the Steam network.
A simple example that uses the modules from the gsbot package and go-steam to log on to the Steam network.
Includes helper types for working with JSON data
Includes helper types for working with JSON data
This package includes some basics for the Steam protocol.
This package includes some basics for the Steam protocol.
steamlang
Contains code generated from SteamKit's SteamLanguage data.
Contains code generated from SteamKit's SteamLanguage data.
Utilities for reading and writing of binary data
Utilities for reading and writing of binary data
tf2
Provides access to TF2 Game Coordinator functionality.
Provides access to TF2 Game Coordinator functionality.
Allows automation of Steam Trading.
Allows automation of Steam Trading.
tradeapi
Wrapper around the HTTP trading API for type safety 'n' stuff.
Wrapper around the HTTP trading API for type safety 'n' stuff.
Implements methods to interact with the official Trade Offer API.
Implements methods to interact with the official Trade Offer API.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL