《Steam 游戏平台:开发与商业化》2.1 SteamID 与账号身份

SteamID 是 64 位账号身份:AccountID 占低 32 位、Instance 20 位、Type 4 位、Universe 8 位,账号类型决定它是玩家、群组还是游戏服务器。本节讲 CSteamID 的位布局与判定方法族,lab 用 C++ 复现位域编解码与类型判定、IsValid 边界。

2.1 SteamID 与账号身份

上一章把 SDK 初始化起来、确定了 AppID,这一章开始处理接入工程的核心身份对象:SteamID。它是 64 位整数,但不是一个随机 ID——它由四段位域构成:AccountID(低 32 位)、AccountInstance(20 位)、AccountType(4 位)、Universe(8 位)。这个结构决定了接入工程里几乎所有「他是谁」的判断:玩家、群组、游戏服务器,都能从类型字段一眼分出来。

本卷所有接口口径以 Steamworks SDK v1.65(2026-07-23) 为准。本节摘录的签名对照该版本 public/steam/steamclientpublic.h、steamuniverse.h。

本章与站内既有内容的分工

  • Steam 发行专题 (操作手册)讲「后台怎么给玩家授权、查账号」;本节讲「代码里 SteamID 的结构与判定语义」。
  • 卷一《平台机制与商店》讲账号体系机制;本节讲账号身份在代码里的载体——64 位结构与类型判定。
  • lab 用纯 C++ 复现位域编解码与类型判定,不依赖 Steam 客户端运行。

SteamID 的 64 位结构

CSteamID 的底层是一个联合体:既可按 64 位整数整体读写,也可拆成四段位域。v1.65 头文件里的布局(小端序):

// steamclientpublic.h:CSteamID::SteamID_t(SDK v1.65 头文件摘录,已删减)
	// 64 bits total
	union SteamID_t
	{
		struct SteamIDComponent_t
		{
			uint32			m_unAccountID : 32;			// unique account identifier
			unsigned int	m_unAccountInstance : 20;	// dynamic instance ID
			unsigned int	m_EAccountType : 4;			// type of account
			EUniverse		m_EUniverse : 8;			// universe this account belongs to
		} m_comp;

		uint64 m_unAll64Bits;
	} m_steamid;

这个布局给出四条工程结论:

  1. 低 32 位是 AccountID:对个人账号来说它通常就是「SteamID 数字」的核心,但不等于完整 64 位——别把 32 位 AccountID 当 SteamID 用。
  2. AccountInstance 是动态实例:个人账号固定取 k_unSteamUserDefaultInstance = 1,多席位(网吧机)账号的多个实例共享同一个 AccountID。
  3. AccountType 决定「这是什么账号」:4 位字段,取值的意义见下节。
  4. Universe 是环境:k_EUniversePublic = 1 是正式环境,还有 Beta/Internal/Dev 等(steamuniverse.h)。同一个 AccountID 在不同 Universe 下是不同账号——这在区分正式服与测试环境时很关键。

账号类型:EAccountType

AccountType 的枚举值定义账号性质,接入工程至少需要分清「玩家 / 群组 / 游戏服务器 / 匿名」:

// steamclientpublic.h:EAccountType(SDK v1.65 头文件摘录,已删减)
enum EAccountType
{
	k_EAccountTypeInvalid = 0,
	k_EAccountTypeIndividual = 1,		// single user account
	k_EAccountTypeMultiseat = 2,		// multiseat (e.g. cybercafe) account
	k_EAccountTypeGameServer = 3,		// game server account
	k_EAccountTypeAnonGameServer = 4,	// anonymous game server account
	k_EAccountTypePending = 5,			// pending
	k_EAccountTypeContentServer = 6,	// content server
	k_EAccountTypeClan = 7,
	k_EAccountTypeChat = 8,
	k_EAccountTypeConsoleUser = 9,		// Fake SteamID for local PSN account on PS3
	k_EAccountTypeAnonUser = 10,
	k_EAccountTypeMax
};

工程上最常用的四类:

  1. Individual(1):普通玩家账号。好友、成就、匹配都围绕它。
  2. GameServer(3)/ AnonGameServer(4):游戏服务器账号。AnonGameServer 是匿名登录占位——未分配持久账号前用 CreateBlankAnonLogon 造一个「空白」ID,登录成功后由后端填充真实字段(第 9 章展开)。
  3. Clan(7):群组/社区账号。好友与群组功能(第 5 章)会用到。
  4. AnonUser(10):匿名用户占位(CreateBlankAnonUserLogon),一般用于临时会话。

Set 与默认实例

构造/设置一个 SteamID 时,Set 方法根据类型自动决定实例值:

// steamclientpublic.h:CSteamID::Set(SDK v1.65 头文件摘录,已删减)
	void Set( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
	{
		m_steamid.m_comp.m_unAccountID = unAccountID;
		m_steamid.m_comp.m_EUniverse = eUniverse;
		m_steamid.m_comp.m_EAccountType = eAccountType;

		if ( eAccountType == k_EAccountTypeClan || eAccountType == k_EAccountTypeGameServer )
		{
			m_steamid.m_comp.m_unAccountInstance = 0;
		}
		else
		{
			m_steamid.m_comp.m_unAccountInstance = k_unSteamUserDefaultInstance;
		}
	}

注意匿名游戏服务器不在「实例 0」分支里:CreateBlankAnonLogon 是单独的方法(置 AccountID 0、类型 AnonGameServer、实例 0),与 Set 的默认行为不同。这正说明接入工程不能靠「看着像」推断实例值——匿名占位必须走专门入口。

判定方法族与 IsValid

拿到一个 SteamID 后,接入工程先用判定方法族问「它是什么」:

// steamclientpublic.h:CSteamID 判定方法(SDK v1.65 头文件摘录,已删减)
	bool BIndividualAccount() const;
	bool BAnonAccount() const;
	bool BClanAccount() const;
	bool BGameServerAccount() const;	// 含持久与匿名服务器
	bool BBlankAnonAccount() const;		// 匿名空白占位
	bool IsValid() const;				// 类型/宇宙在界内 + 实例约束

IsValid 的边界值得注意(v1.65 实现):类型与宇宙越界即 false;Individual 要求 AccountID 非零且实例为默认实例(1);Clan 要求 AccountID 非零且实例为 0。也就是说「合法」不只是「非空」,还包含类型与实例的配对约束——一个实例为 9 的 Individual 账号是无效的。

工程语义总结:SteamID 的读写用 64 位整体(SetFromUint64/ConvertToUint64),判定用类型方法族,构造用带 Universe/Type 的完整构造器。不要手拼位域,那正是 CSteamID 存在的原因。

接口签名对照

头文件条目语义
steamclientpublic.hEAccountType账号类型枚举(Individual/GameServer/Clan 等)
steamclientpublic.hCSteamID::Set/SetFromUint64/ConvertToUint64构造与 64 位往返
steamclientpublic.hCSteamID::CreateBlankAnonLogon匿名服务器空白占位
steamclientpublic.hBIndividualAccount/BGameServerAccount/BClanAccount/...类型判定方法族
steamclientpublic.hCSteamID::IsValid()合法性与实例约束
steamuniverse.hEUniverse环境枚举(Public=1)

数据口径与来源

  • 位布局、枚举值、Set 与判定方法:SDK v1.65 public/steam/steamclientpublic.h、steamuniverse.h 可实证(本机镜像已核对)。
  • k_unSteamUserDefaultInstance = 1 与各掩码常量:steamclientpublic.h 明文。
  • 具体账号的 SteamID 数值:平台运行时返回,不在此列。

以上接口口径撰写时对照 Steamworks SDK v1.65 头文件与 partner.steamgames.com 官方文档核对;登录后可见数据以官方当前为准。

可运行产物:C++ 最小验证

下面的仿真复现「CSteamID 位域」的工程语义:64 位布局编解码、Set 的实例规则、类型判定方法族、IsValid 边界、匿名空白登录。它与 src/02-1-steamid-identity.cpp 逐字节一致,mock 签名对照 SDK v1.65 头文件:

// file: src/02-1-steamid-identity.cpp
// tier: L1
// verify: clang++ -std=c++20 -Wall -I. src/02-1-steamid-identity.cpp -o bin/02-1-steamid-identity && ./bin/02-1-steamid-identity
//
// mock:复现 CSteamID 的 64 位布局、Set/SetFromUint64/ConvertToUint64 与
// 账号类型判定(BIndividualAccount 等)、IsValid 边界。
// 位布局与枚举对照 SDK v1.65 steamclientpublic.h / steamuniverse.h,
// 非 Valve 实现。
#include "verify.h"

#include <cstdint>

namespace steam_repro {

// EAccountType 枚举值对照 steamclientpublic.h
enum MockAccountType {
  kInvalid = 0,
  kIndividual = 1,
  kMultiseat = 2,
  kGameServer = 3,
  kAnonGameServer = 4,
  kPending = 5,
  kContentServer = 6,
  kClan = 7,
  kChat = 8,
  kConsoleUser = 9,
  kAnonUser = 10,
  kMax = 11,
};

// EUniverse 枚举值对照 steamuniverse.h
enum MockUniverse {
  kUniverseInvalid = 0,
  kUniversePublic = 1,
  kUniverseBeta = 2,
  kUniverseInternal = 3,
  kUniverseDev = 4,
  kUniverseMax,
};

// 复现 CSteamID 的 64 位布局(对照 m_comp,小端):
// bits 0-31 AccountID,32-51 AccountInstance,52-55 AccountType,56-63 Universe
struct MockSteamID {
  static constexpr uint32_t kUserDefaultInstance = 1;

  uint64_t bits = 0;

  MockSteamID() = default;
  // CSteamID(unAccountID, eUniverse, eAccountType)
  MockSteamID(uint32_t accountId, int universe, int type) { set(accountId, universe, type); }

  // CSteamID::Set:Clan/GameServer 置 instance 0,其余置 k_unSteamUserDefaultInstance
  void set(uint32_t accountId, int universe, int type) {
    uint32_t instance = (type == kClan || type == kGameServer) ? 0 : kUserDefaultInstance;
    bits = (static_cast<uint64_t>(universe) << 56) |
           (static_cast<uint64_t>(type) << 52) |
           (static_cast<uint64_t>(instance) << 32) |
           accountId;
  }

  void setFromUint64(uint64_t v) { bits = v; }
  uint64_t convertToUint64() const { return bits; }

  // CSteamID::CreateBlankAnonLogon:匿名游戏服务器空白登录
  void createBlankAnonLogon(int universe) {
    bits = (static_cast<uint64_t>(universe) << 56) |
           (static_cast<uint64_t>(kAnonGameServer) << 52);
  }

  uint32_t accountId() const { return static_cast<uint32_t>(bits & 0xFFFFFFFFu); }
  uint32_t instance() const { return static_cast<uint32_t>((bits >> 32) & 0xFFFFFu); }
  int type() const { return static_cast<int>((bits >> 52) & 0xFu); }
  int universe() const { return static_cast<int>((bits >> 56) & 0xFFu); }

  bool bIndividualAccount() const { return type() == kIndividual; }
  bool bAnonAccount() const { return type() == kAnonUser || type() == kAnonGameServer; }
  bool bClanAccount() const { return type() == kClan; }
  bool bGameServerAccount() const {
    return type() == kGameServer || type() == kAnonGameServer;
  }
  bool bBlankAnonAccount() const {
    return accountId() == 0 && bAnonAccount() && instance() == 0;
  }

  // 对照 CSteamID::IsValid:类型/宇宙在界内,Individual 与 Clan 有实例约束
  bool isValid() const {
    if (type() <= kInvalid || type() >= kMax) return false;
    if (universe() <= kUniverseInvalid || universe() >= kUniverseMax) return false;
    if (type() == kIndividual) {
      if (accountId() == 0 || instance() != kUserDefaultInstance) return false;
    }
    if (type() == kClan) {
      if (accountId() == 0 || instance() != 0) return false;
    }
    if (type() == kGameServer) {
      if (accountId() == 0) return false;
    }
    return true;
  }
};

}  // namespace steam_repro

int main() {
  using namespace steam_repro;

  // 1. 默认构造为无效 ID:64 位为 0
  MockSteamID def;
  CHECK(def.convertToUint64() == 0);
  CHECK(!def.isValid());

  // 2. Set 后 individual 自动带默认实例
  MockSteamID user(123456, kUniversePublic, kIndividual);
  CHECK(user.instance() == MockSteamID::kUserDefaultInstance);
  CHECK(user.bIndividualAccount());

  // 3. 字段编解码往返
  CHECK(user.accountId() == 123456);
  CHECK(user.universe() == kUniversePublic);
  CHECK(user.type() == kIndividual);

  // 4. 64 位布局:universe(56) | type(52) | instance(32) | accountId(0)
  uint64_t expected = (1ull << 56) | (1ull << 52) | (1ull << 32) | 123456ull;
  CHECK(user.convertToUint64() == expected);

  // 5. Clan 实例为 0,且非 individual
  MockSteamID clan(777, kUniversePublic, kClan);
  CHECK(clan.instance() == 0);
  CHECK(clan.bClanAccount());
  CHECK(!clan.bIndividualAccount());

  // 6. 游戏服务器与匿名游戏服务器均判为 server 账号
  MockSteamID gs(555, kUniversePublic, kGameServer);
  MockSteamID anonGs(0, kUniversePublic, kAnonGameServer);
  CHECK(gs.bGameServerAccount());
  CHECK(anonGs.bGameServerAccount());
  CHECK(anonGs.bAnonAccount());

  // 7. 匿名空白登录(CreateBlankAnonLogon 语义):accountId 0 + 匿名 + 实例 0
  MockSteamID blankAnon;
  blankAnon.createBlankAnonLogon(kUniversePublic);
  CHECK(blankAnon.bBlankAnonAccount());
  CHECK(blankAnon.instance() == 0);

  // 8. IsValid 边界:individual 不允许 accountId 0
  MockSteamID zeroUser(0, kUniversePublic, kIndividual);
  CHECK(!zeroUser.isValid());

  // 9. IsValid 边界:individual 实例必须为默认实例
  MockSteamID weirdInst(42, kUniversePublic, kIndividual);
  weirdInst.setFromUint64((1ull << 56) | (1ull << 52) | (9ull << 32) | 42ull);
  CHECK(!weirdInst.isValid());

  // 10. IsValid 边界:Clan 实例必须为 0
  MockSteamID clanBad(777, kUniversePublic, kClan);
  clanBad.setFromUint64((1ull << 56) | (7ull << 52) | (1ull << 32) | 777ull);
  CHECK(!clanBad.isValid());

  // 11. SetFromUint64 / ConvertToUint64 往返一致
  uint64_t round = (2ull << 56) | (1ull << 52) | (3ull << 32) | 888ull;
  MockSteamID r;
  r.setFromUint64(round);
  CHECK(r.convertToUint64() == round);
  CHECK(r.accountId() == 888);
  CHECK(r.instance() == 3);
  CHECK(r.universe() == kUniverseBeta);

  // 12. 不同 accountId 编码为不同 64 位
  MockSteamID a(100, kUniversePublic, kIndividual);
  MockSteamID b(200, kUniversePublic, kIndividual);
  CHECK(a.convertToUint64() != b.convertToUint64());

  // 13. 无效类型(越界)不可用
  MockSteamID badType(1, kUniversePublic, 99);
  CHECK(!badType.isValid());

  return lab::report("02-1 SteamID 与账号身份");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 25/25 通过。

小结

  • SteamID 是四段位域:AccountID(32)、Instance(20)、Type(4)、Universe(8);读写走 64 位整体,判定走方法族。
  • EAccountType 决定账号性质:Individual/GameServer/AnonGameServer/Clan 是接入工程最常打交道的四类。
  • Set 的实例规则:Clan 与 GameServer 置 0,其余置默认实例 1;匿名空白登录走 CreateBlankAnonLogon 专用入口。
  • IsValid 含实例约束:Individual 必须实例 1,Clan 必须实例 0——「合法」不只是非空。

阅读导航:上一节:1.3 AppID 与运行环境 · 下一节:2.2 登录状态与会话票据 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图