ผู้ไม่มีส่วนเกี่ยวข้อง

หน้าหลัก เอกสารอ้างอิงและความช่วยเหลือ
เอกสาร Steamworks
ภาพรวม Steamworks API

ภาพรวม

Steamworks API จะทำให้เกมของคุณสามารถใช้งาน Steam ได้อย่างเต็มที่ ด้วยการเข้าถึงระบบพื้นฐานหลักทั้งหมดที่จัดให้ไว้ผ่านทาง API ซึ่งบรรจุเครื่องมือต่าง ๆ เช่น การหยุดเกมไว้ชั่วคราวเวลาที่ผู้ใช้เปิด โอเวอร์เลย์ Steam การเชิญเพื่อนมาร่วมเล่น การอนุญาตให้ผู้เล่นสามารถปลดล็อค รางวัลความสำเร็จ Steam การอนุญาตให้ผู้เล่นมาแข่งขันกันบน กระดานผู้นำ Steam และอื่น ๆ อีกมากมาย

ข้อมูลอ้างอิงในการใช้งาน Steamworks API ได้รวบรวมและแจกแจงรายละเอียดเกี่ยวกับอินเตอร์เฟส ฟังก์ชัน คอลแบ็ก และประเภทข้อมูลทั้งหมดที่รองรับใน API

อย่างไรก็ตาม ในการนำส่งผลิตภัณฑ์เข้าสู่ Steam ไม่จำเป็นจะต้องประสาน Steamworks API เข้าไว้ด้วย แต่ว่าทางเราขอแนะนำเป็นอย่างยิ่งว่าให้ประสานเข้าไปด้วยกัน นั่นก็เพราะว่าจะสามารถทำให้คุณสามารถใช้งานการปฏิสัมพันธ์ต่าง ๆ หลายอย่างที่ผู้ใช้ Steam คาดหวังว่าจะสามารถใช้งานได้

การเริ่มต้นใช้งาน

หมายเหตุ: Steamworks API รองรับ C++ อย่างเป็นทางการ โดยการใช้ Microsoft Visual Studio 2008+ บน Microsoft Windows, GCC 4.6+ และ Clang 3.0+ บน macOS และ SteamOS / Linux หากคุณใช้เอนจิ้นภายนอกหรือใช้ภาษาการเขียนโปรแกรมภาษาอื่นที่ไม่ใช่ C++ คุณต้องอ่านรายละเอียดที่ การรองรับเอนจิ้นเชิงพาณิชย์และภาษาที่ไม่ใช่ภาษา C++ เสียก่อน เพื่อดูว่ามีคำแนะนำพิเศษเพิ่มเติมอื่น ๆ ในการเริ่มต้นใช้งานเอนจิ้นหรือภาษาการเขียนโปรแกรมที่คุณเลือกใช้หรือไม่ ในบางกรณีคุณอาจจะสามารถข้ามหลายขั้นตอนเหล่านี้ไปได้

  • หากคุณยังไม่ได้ดาวน์โหลด ให้ ดาวน์โหลด Steamworks SDK แล้วคลายซิปไฟล์
  • คัดลอกโฟลเดอร์ส่วนหัวของ Steamworks API public/steam ไปไว้ในที่ที่เหมาะสมในโครงสร้างแหล่งที่มาของแอปพลิเคชันของคุณ
  • บรรจุหนึ่งในไฟล์ส่วนหัวต่อไปนี้ในโปรเจกต์ C++ ของคุณ
    • steam_api.h - บรรจุส่วนหัว Steamworks อื่น ๆ ทั้งหมดและให้จุดเริ่มต้นเพื่อเปิดใช้งาน Steamworks API
    • steam_gameserver.h - จะบรรจุสิ่งนี้หากคุณกำลังใช้งาน Steam GameServer API เท่านั้น ซึ่งรวม steam_api.h ไว้ภายใน ทำให้ไม่จำเป็นต้องรวมไว้ทั้งคู่
  • ให้คัดลอกไฟล์ redistributable ที่เกี่ยวข้องจาก redistributable_bin ไปไว้ในที่ที่เหมาะสมในโฟลเดอร์โปรเจกต์ของคุณ
    • Windows
      คุณต้องมีการเชื่อมโยง steam_api[64].lib ในโปรเจกต์ Visual Studio ของคุณ โดยจะสามารถเชื่อมโยงกับตัวโปรแกรมที่สั่งใช้งานได้หลักหรือโมดูลที่ใช้ Steam ก็ได้ ซึ่งจะอนุญาตให้คุณสามารถเข้าถึงฟังก์ชันการทำงานที่บรรจุใน steam_api[64].dll โดยจะถูกเปิดให้สามารถเข้าใช้งานได้ผ่านทางส่วนหัวของ Steamworks API รายละเอียดเพิ่มเติม: การเชื่อมตัวโปรแกรมที่สั่งใช้งานได้เข้ากับ DLL (MSDN)

      นอกจากนี้ คุณจะต้องนำส่ง steam_api[64].dll ในไดเรกทอรี run-time (ที่อยู่ถัดจากตัวโปรแกรมที่สั่งใช้งานได้หรือเส้นทางค้นหาของ DLL ของคุณ)
    • macOS
      libsteam_api.dylib จะให้ Steam API ทั้งเวอร์ชัน x86 และ x64 คุณจะต้องเชื่อมโยงสิ่งนี้เข้ากับโปรเจกต์ XCode ของคุณ และคุณจะต้องนำส่งร่วมไปกับตัวโปรแกรมที่สั่งใช้งานได้ของคุณ
      รายละเอียดเพิ่มเติม: การใช้งาน Dynamic Libraries
    • Linux
      libsteam_api.so คุณจะต้องเชื่อมโยงและนำส่งสิ่งนี้ร่วมไปกับตัวโปรแกรมที่สั่งใช้งานได้ของคุณ

การเปิดใช้งานและการปิดใช้งาน

SteamAPI_Init

หลังจากที่คุณได้ติดตั้ง Steamworks API ภายในโปรเจกต์ของตนเองแล้ว คุณจะสามารถเริ่มใช้งานโดยการเรียกคอลฟังก์ชัน SteamAPI_Init เพื่อเริ่มใช้งาน API โดยกระบวนการนี้จะดำเนินการติดตั้งสถานะส่วนกลางและรวบรวมพอยน์เตอร์ของอินเตอร์เฟสเอาไว้ด้วยกัน ซึ่งสามารถเข้าถึงได้ผ่านทางฟังก์ชันส่วนกลางที่มีชื่อตรงกันกับอินเตอร์เฟส โดยจะต้องถูกเรียกและค่าคืนให้เรียบร้อยก่อนที่จะเข้าถึง อินเตอร์เฟส Steamworks ใดๆ ก็ตาม!

หากว่า Steamworks API ไม่ทราบไอดีแอปของเกมของคุณ Steamworks API ก็จะไม่เริ่มเปิดใช้งาน เมื่อคุณเปิดใช้งานแอปของคุณจาก Steam แอปดังกล่าวจะมีไอดีแอปพร้อมให้ใช้งานโดยอัตโนมัติ ขณะที่กำลังพัฒนา คุณจำเป็นจะต้องแจ้งเรื่องนี้ให้กับ Steam ทราบด้วยไฟล์ข้อความ ให้สร้างไฟล์ข้อความที่เรียกว่า steam_appid.txt ข้าง ๆ ตัวโปรแกรมที่สั่งใช้งานได้ของคุณ ซึ่งบรรจุเพียงไอดีแอปแต่เพียงอย่างเดียวเท่านั้น โดยไม่มีอะไรอย่างอื่น กระบวนการนี้จะเแทนที่ค่าที่ Steam ได้เตรียมไว้ และคุณไม่ควรนำส่งไฟล์นี้ร่วมไปกับบิลด์ของคุณ ตัวอย่าง:
480

การคืนค่าเป็น false จะระบุหนึ่งในเงื่อนไขข้อใดข้อหนึ่งดังต่อไปนี้:
  • ไคลเอนต์ Steam ไม่ได้ทำงานอยู่ ไคลเอนต์ Steam จำเป็นต้องกำลังทำงานอยู่ เพื่อทำการตระเตรียมการใช้งานอินเตอร์เฟส ๆ ของ Steamworks
  • ไคลเอนต์ Steam ไม่สามารถระบุไอดีแอปของเกมได้ หากคุณกำลังเรียกใช้แอปพลิเคชันของคุณจากตัวโปรแกรมที่สั่งใช้งานได้หรือตัวดีบักโดยตรง คุณจะต้องมี steam_appid.txt ในไดเรกทอรีของเกมที่อยู่กับโปรแกรมที่สั่งใช้งานได้ โดยจะต้องมีไอดีแอปของคุณอยู่ในนั้น และห้ามมีอย่างอื่น Steam จะมองหาไฟล์ดังกล่าวนี้จากไดเรกทอรีปัจจุบันที่กำลังใช้งานอยู่ หากคุณกำลังเรียกใช้ตัวโปรแกรมที่สั่งใช้งานได้ของคุณจากไดเรกทอรีอื่น คุณอาจจำเป็นต้องย้ายไฟล์ steam_appid.txt
  • แอปพลิเคชันของคุณไม่ได้ทำงานภายใต้บริบทของผู้ใช้ OS เดียวกันกับไคลเอนต์ Steam เช่น ผู้ใช้ท่านอื่นหรือระดับการเข้าถึงการดูแลที่แตกต่างกัน
  • กรุณาตรวจสอบให้มั่นใจว่าคุณเป็นเจ้าของใบอนุญาตสิทธิ์ใช้งานไอดีแอปดังกล่าวบนบัญชี Steam ที่กำลังใช้งานอยู่ โดยเกมของคุณจะต้องแสดงขึ้นมาในคลัง Steam ของคุณ
  • ไอดีแอปของคุณยังไม่ได้รับการติดตั้งโดยสมบูรณ์ ซึ่งก็คือ สถานะการวางจำหน่าย: ไม่พร้อมใช้งาน หรือไม่เช่นนั้น ไอดีแอปของคุณได้ขาดแพ็กเกจเริ่มต้นไป
หากคุณประสบกับปัญหาเกี่ยวกับการเปิดใช้งาน คุณสามารถดูรายละเอียดได้ที่ การดีบัก Steamworks API เอกสารประกอบเพื่อรับทราบข้อมูลเกี่ยวกับเมธอดต่าง ๆ

SteamAPI_RestartAppIfNecessary

SteamAPI_RestartAppIfNecessary ใช้ตรวจสอบดูว่าตัวโปรแกรมที่สั่งใช้งานได้ของคุณได้ถูกเรียกใช้งานผ่านทาง Steam หรือไม่ และหากยังไม่ได้เรียกผ่านทาง Steam ก็จะเรียกใช้งานตัวโปรแกรมดังกล่าวอีกครั้งผ่านทาง Steam

วิธีนี้เป็นวิธีทางเลือก แต่ก็ขอแนะนำอย่างยิ่งว่าให้ดำเนินการ เพราะว่าบริบท Steam ที่เชื่อมโยงกับแอปพลิเคชันของคุณ (รวมถึงไอดีแอปของคุณ) จะไม่ถูกติดตั้ง หากผู้ใช้เปิดใช้งานตัวโปรแกรมที่สั่งใช้งานได้โดยตรง หากเหตุการณ์นี้เกิดขึ้น SteamAPI_Init จะล้มเหลว และคุณจะไม่สามารถใช้งาน Steamworks API ได้
หากคุณเลือกที่จะใช้งาน คุณควรจะเรียกฟังก์ชัน Steamworks ก่อนที่จะเรียก SteamAPI_Init

หากคืนเป็นค่า true กลับมา แสดงว่าได้เริ่มต้นไคลเอนต์ Steam ตามที่จำเป็นแล้ว และได้เรียกใช้งานเกมของคุณผ่านทางไคลเอนต์ Steam แล้ว และคุณควรจะต้องออกกระบวนการของคุณโดยเร็วที่สุดเท่าที่จะเป็นไปได้ ซึ่งจะทำให้เรียกใช้งาน steam://run/<AppID> อย่างมีประสิทธิภาพ ดังนั้นจึงอาจไม่จำเป็นจะต้องเปิดใช้งานตัวโปรแกรมที่สั่งใช้งานได้ตัวเดิมที่เรียกฟังก์ชันนี้แล้วซ้ำอีกครั้ง (ตัวอย่างเช่น เวลาที่คุณเรียกใช้จากตัวเครื่องมือดีบัก) เพราะต่อไปจะเปิดใช้งานโปรแกรมเวอร์ชันที่ได้ติดตั้งในโฟลเดอร์คลัง Steam ของคุณแต่เพียงอย่างเดียว

หากไม่เช่นนั้นแล้ว หากคืนค่าเป็น false กลับมา แสดงว่าเกมของคุณได้ถูกเปิดใช้งานโดยไคลเอนต์ Steam แล้ว และไม่จำเป็นต้องดำเนินการใด โดยมีข้อยกเว้น 1 ข้อ คือ หากมีไฟล์ steam_appid.txt อยู่ ก็จะคืนค่าเป็น false กลับมาเสมอ ทั้งนี้ก็เพื่อให้คุณสามารถพัฒนาและทดสอบเกม โดยไม่ต้องเปิดเกมของคุณผ่านทางไคลเอนต์ Steam ตรวจสอบให้มั่นใจว่าได้ลบไฟล์ steam_appid.txt ออก เมื่ออัปโหลดเกมของคุณไปยังดีโป Steam เรียบร้อยแล้ว!

หมายเหตุ: หากคุณใช้แรปเปอร์ DRM ของ Steam กับไฟล์ตัวโปรแกรมที่สั่งใช้งานได้ตัวหลักของคุณ ก็ไม่จำเป็นจะต้องใช้การตรวจสอบนี้เพราะว่าตัวแรปเปอร์ DRM จะดำเนินการดังกล่าวนี้ให้แล้วเป็นการภายใน

SteamAPI_Shutdown

เมื่อคุณใช้งาน Steamworks API เสร็จแล้ว คุณก็ควรจะเรียก SteamAPI_Shutdown เพื่อปล่อยทรัพยากรที่แอปพลิเคชันของคุณใช้งานเป็นการภายในอยู่ใน Steam หากเป็นไปได้ คุณควรจะเรียกคำสั่งนี้ในระหว่างการปิดใช้งานกระบวนการ

โดยคำสั่งจะเลิกจุดแทรก โอเวอร์เลย์ Steam ออกจากเกมของคุณ เนื่องจากไม่มีอะไรรับประกันว่า API การเรนเดอร์ของคุณได้ใช้งานเสร็จแล้ว

อินเตอร์เฟส Steamworks

Steamworks API ประกอบไปด้วยอินเตอร์เฟสหลายรูปแบบ ซึ่งทั้งหมดจะทำให้สามารถเข้าถึงการใช้งานต่าง ๆ เฉพาะบางส่วนได้

หลังจากที่เปิดใช้งาน Steamworks เรียบร้อยแล้ว คุณจะสามารถเข้าถึงอินเตอร์เฟสได้ผ่านทางฟังก์ชันส่วนกลางของอินเตอร์เฟสนั้น ๆ โดยฟังก์ชันจะต้องมีชื่อที่ตรงกับอินเตอร์เฟสเสมอ อย่างเช่น คุณจะสามารถเข้าถึง ISteamApps ผ่านทางตัวเข้าถึง SteamApps() และ ISteamFriends ผ่านทาง SteamFriends()

คุณสามารถใช้อินเตอร์เฟสเหล่านี้เพื่อทำการเรียก เช่น:
// Get the current users Steam name. const char *name = SteamFriends()->GetPersonaName();

คุณสามารถดูรายการอินเตอร์เฟสทั้งหมดได้ที่ ข้อมูลอ้างอิงในการใช้งาน Steamworks API หรือด้วยการไปดูในไฟล์ส่วนหัวของ Steamworks API

คอลแบ็ก

คอลแบ็กเป็นหนึ่งในวิธีการสำคัญที่สุดของ Steamworks ที่จะอนุญาตให้คุณเรียกใช้ข้อมูลแบบอสมมาตรได้จาก Steam โดยไม่จำเป็นต้องล็อกเกมของคุณ เป้าหมายของการคอลแบ็กคือ การให้กระบวนการยกระดับกิจกรรมแบบอสมมาตรที่ไม่ซับซ้อน ไม่เปลืองทรัพยากร ปลอดภัยต่อประเภทข้อมูล และปลอดภัยต่อเธรด ไว้ให้แก่ออบเจกต์ใด ๆ ก็ตามที่ได้ถูกลงทะเบียนไว้ว่าเป็นตัวเฝ้าฟังเหตุการณ์ (Listener)

โดยทั่วไปแล้วคอลแบ็กจะถูกเรียกใช้งานจากกิจกรรมที่เกิดขึ้นจาก Steam เช่น เวลาที่มีเพื่อนเข้าหรือออกจากระบบ หรือ จากผลลัพธ์แบบอสมมาตรของฟังก์ชันของ API บางฟังก์ชัน โดยคอลแบ็กแต่ละตัวประกอบไปด้วยสตรัคที่บรรจุตัวระบุเฉพาะและข้อมูลชุดเล็ก ๆ เอาไว้ คอลแบ็กจะถูกประกาศอยู่ในไฟล์ส่วนหัวของ ISteam*.h และถูกจัดรวมกลุ่มไว้กับอินเตอร์เฟสที่มีความเกี่ยวข้องด้วยมากที่สุด

ในการรับฟังการคอลแบ็ก สตรัคหรือคลาสจะต้องใช้มาโคร STEAM_CALLBACK( :classname, :functionname, :callbackname ) ที่อยู่ในคำประกาศของสตรัคหรือคลาสนั้น ๆ
  • :classname ต้องเป็นชื่อของสตรัคหรือคลาสที่คุณได้ให้นิยามไว้ (เช่น CGameManager)
  • :functionname จะเป็นชื่อของฟังก์ชันที่ได้รับการคอลแบ็กนี้ (เช่น OnGameOverlayActivated)
  • :callbackname เป็นชื่อของการคอลแบ็ก (เช่น GameOverlayActivated_t)
สิ่งนี้จะนิยามฟังก์ชันสมาชิกภายในให้แก่คลาสดังกล่าว ที่จะถูกสร้างต้นแบบเป็น void :functionname( :callbackname *pCallback ) โดยอัตโนมัติ การสร้างอินสแตนซ์ใหม่ของออบเจ็กต์จะทำให้ฟังก์ชันสมาชิกลงทะเบียนตัวเองเป็นตัวเฝ้าฟังเหตุการณ์ที่มี Steamworks API การทำลายออบเจ็กต์จะทำให้ออบเจ็กต์ปลดตัวเองออกจากทะเบียน

หมายเหตุ: คุณควรตรวจสอบให้มั่นใจว่า Steam ได้ถูกเปิดใช้งานแล้วก่อนที่จะสร้างออบเจ็กต์ที่เฝ้าฟังการคอลแบ็กต่าง ๆ

สำหรับการคอลแบ็กที่จะส่งไปให้ตัวเฝ้าฟังเหตุการณ์ที่ลงทะเบียนไว้ คุณจะต้องเรียก SteamAPI_RunCallbacks โดยแนะนำให้เรียกเป็นประจำ เนื่องจากการทิ้งเวลาระหว่างการเรียกที่นานขึ้นจะทำให้เกิดความล่าช้าระหว่างกิจกรรมที่เกิดจากการได้รับการเรียกหรือผลลัพธ์ที่ได้จาก Steamworks API โดยทั่วไปแล้วเกมส่วนมากจะเรียกคำสั่งนี้ 1 ครั้ง ต่อ 1 เฟรมเรนเดอร์ ซึ่งขอแนะนำเป็นอย่างยิ่งให้คุณเรียกอย่างน้อย 1 ครั้งต่อ 1 วินาที ฟังก์ชันตัวเฝ้าฟังเหตุการณ์ที่ลงทะเบียนไว้ทั้งหมดจะต้องถูกเรียกใช้ในระหว่างการเรียกนี้ โดยจะเรียกใช้ในบริบทเธรด SteamAPI_RunCallbacks

ตัวอย่าง

หนึ่งในคอลแบ็กที่ขอแนะนำให้คุณใช้ คือ ISteamFriends::GameOverlayActivated_t ซึ่งก็เป็นไปตามชื่อคือจะส่งคอลแบ็กให้กับคุณในทุกครั้งที่ผู้ใช้เปิดหรือปิดการใช้งาน โอเวอร์เลย์ Steam

class CGameManager { private: STEAM_CALLBACK( CGameManager, OnGameOverlayActivated, GameOverlayActivated_t ); }; void CGamemanager::OnGameOverlayActivated( GameOverlayActivated_t* pCallback ) { if ( pCallback->m_bActive ) printf( "Steam overlay now active\n" ); else printf( "Steam overlay now inactive\n" ); }

หนึ่งในกรณีใช้งานที่เป็นที่นิยมและแนะนำให้ใช้กับคอลแบ็ก ISteamFriends::GameOverlayActivated_t คือ การหยุดเกมชั่วคราวเวลาที่โอเวอร์เลย์เปิดขึ้นมา

CallResults

เมธอด Steamworks หลายอย่างจะใช้ผลลัพธ์การเรียกแทนการใช้คอลแบ็ก เพื่อส่งคืนผลลัพธ์แบบอสมมาตรจากการเรียกฟังก์ชัน ความแตกต่างระหว่างการคอลแบ็กและผลลัพธ์การเรียกก็คือ การคอลแบ็กจะถูกกระจายข้อมูลไปยังตัวเฝ้าฟังเหตุการณ์ทั้งหมด ในขณะที่ผลลัพธ์การเรียกจะพุ่งเป้าหมายที่ตัวเฝ้าฟังเหตุการณ์เฉพาะเท่านั้น เช่นเดียวกันกับการคอลแบ็ก เกมของคุณจำเป็นจะต้องเรียก SteamAPI_RunCallbacks เพื่อส่งผลลัพธ์การเรียกไปยังตัวเฝ้าฟังเหตุการณ์

ซึ่งคุณจะสามารถระบุฟังก์ชันที่ให้ผลลัพธ์การเรียกได้จากการดูค่าที่ฟังก์ชันคืนค่า หากฟังก์ชันดังกล่าวคืนค่า SteamAPICall_t และมีแอตทริบิวต์ CALL_RESULT() คุณจะต้องลงทะเบียนเพื่อรับผลลัพธ์การเรียก

หมายเหตุ: การคอลแบ็กและผลลัพธ์การเรียกไม่สามารถนำมาใช้แทนที่กันได้ โดยกิจกรรมจะปรากฏออกมาผ่านอย่างใดอย่างหนึ่งเท่านั้น ไม่ปรากฏออกมาผ่านทั้งสองอย่าง คุณต้องตรวจสอบให้มั่นใจว่าคุณได้ลงทะเบียนประเภทกิจกรรมที่ถูกต้อง!

ผลลัพธ์การเรียกต้องได้รับการสร้างเป็นสมาชิกในสตรัค/คลาส โดยใช้ประเภท CCallResult และคุณยังจำเป็นจะต้องสร้างฟังก์ชันสมาชิกที่จะได้รับการคอลแบ็กดังกล่าว
void func( :callresultname *pCallback, bool bIOFailure ); CCallResult< :classname, :callresultname > m_callresultname;
  • :classname ต้องเป็นชื่อของสตรัคหรือคลาสที่คุณได้ให้นิยามไว้ (เช่น CGameManager)
  • :callresultname เป็นชื่อของการคอลแบ็ก (เช่น NumberOfCurrentPlayers_t)

คุณจะตั้งชื่อฟังก์ชัน พารามิเตอร์ของฟังก์ชัน และประเภท CCallResult เป็นชื่ออะไรก็ได้ที่คุณต้องการ

ตัวอย่าง

นี่เป็นตัวอย่างของวิธีการใช้ ISteamUserStats::GetNumberOfCurrentPlayers API ที่จะสร้างผลลัพธ์การเรียก ISteamUserStats::NumberOfCurrentPlayers_t
// In your class definition class CGameManager { public: void GetNumberOfCurrentPlayers(); private: void OnGetNumberOfCurrentPlayers( NumberOfCurrentPlayers_t *pCallback, bool bIOFailure ); CCallResult< CGameManager, NumberOfCurrentPlayers_t > m_NumberOfCurrentPlayersCallResult; }; // Make the asynchronous request to receive the number of current players. void CGameManager::GetNumberOfCurrentPlayers() { printf( "Getting Number of Current Players\n" ); SteamAPICall_t hSteamAPICall = SteamUserStats()->GetNumberOfCurrentPlayers(); m_NumberOfCurrentPlayersCallResult.Set( hSteamAPICall, this, &CGameManager::OnGetNumberOfCurrentPlayers ); } // Called when SteamUserStats()->GetNumberOfCurrentPlayers() returns asynchronously, after a call to SteamAPI_RunCallbacks(). void CGameManager::OnGetNumberOfCurrentPlayers( NumberOfCurrentPlayers_t *pCallback, bool bIOFailure ) { if ( bIOFailure || !pCallback->m_bSuccess ) { printf( "NumberOfCurrentPlayers_t failed!\n" ); return; } printf( "Number of players currently playing: %d\n", pCallback->m_cPlayers ); }

หมายเหตุ: หากคุณไม่สามารถใช้ระบบ CCallResult ได้ คุณอาจจะสามารถใช้ ISteamUtils::IsAPICallCompleted, ISteamUtils::GetAPICallResult และ ISteamUtils::GetAPICallFailureReason เพื่อติดตามสถานะของผลลัพธ์การเรียกได้

เซิร์ฟเวอร์เกม Steam

Steamworks API ให้การรองรับการใช้งานเซิร์ฟเวอร์เกมเช่นเดียวกันกับที่รองรับไคลเอนต์ธรรมดา เซิร์ฟเวอร์เกมในความหมายของ Steamworks API นั้นคือเอนทิตีในระบบที่ผู้ใช้ทั่วไปจะเชื่อมต่อเพื่อเล่นเกมแบบผู้เล่นหลายคน โดยจะสามารถเชื่อมต่อผ่านทางอินเทอร์เน็ตไปยังเซิร์ฟเวอร์เกมระยะไกล หรือจะเชื่อมต่อกับเซิร์ฟเวอร์เกมภายในเครื่องที่อยู่ในกระบวนการเดียวกันกับไคลเอนต์ก็ได้ ซึ่งเซิร์ฟเวอร์เกมจะมีชุดฟังก์ชัน API ที่เอาไว้ใช้งานเป็นของตัวเอง แต่จะมีไอดี Steam เฉพาะของตัวเองไว้ให้ผู้ใช้อื่นเรียกเวลาจะใช้งานอีกด้วย

ในการใช้ API ของเซิร์ฟเวอร์เกม Steam คุณจะต้องบรรจุ steam_gameserver.h ก่อนแทนที่จะเป็น steam_api.h

การเริ่มเปิดใช้งานและการใช้งาน API ของเซิร์ฟเวอร์เกมจะมีวิธีที่คล้ายคลึงกับ API ธรรมดาทั่วไปอย่างมาก:

หลังจากที่เริ่มเปิดใช้งานเซิร์ฟเวอร์เกมแล้ว คุณจะสามารถเข้าถึงอินเตอร์เฟสเฉพาะของเซิร์ฟเวอร์เกม 2 อินเตอร์เฟสได้ ซึ่งก็คือ ISteamGameServer และ ISteamGameServerStats

คุณยังสามารถที่จะเข้าถึงอินเตอร์เฟสธรรมดาดังต่อไปนี้ได้จากเซิร์ฟเวอร์เกมอีกด้วย:
  • ISteamClient ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerClient()
  • ISteamUtils ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerUtils()
  • ISteamNetworking ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerNetworking()
  • ISteamHTTP ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerHTTP()
  • ISteamInventory ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerInventory()
  • ISteamUGC ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerUGC()
  • ISteamApps ซึ่งคุณสามารถเข้าถึงได้ผ่านทางอินเตอร์เฟสส่วนกลาง: SteamGameServerApps()

หากคุณกำลังเรียกใช้เซิร์ฟเวอร์เกมเฉพาะ (ซึ่งจะไม่มีส่วนประกอบของไคลเอนต์อยู่เลย) คุณจำเป็นจะต้องเปิดใช้งานเพียงส่วนประกอบของ API เซิร์ฟเวอร์เกมเท่านั้น โดยคุณไม่จำเป็นจะต้องเปิดใช้งาน API ของผู้ใช้ธรรมดา

กรุณาดู แอปพลิเคชันตัวอย่างของ Steamworks API (SpaceWar) สำหรับตัวอย่างการใช้งาน API ของเซิร์ฟเวอร์เกมอย่างละเอียด

การรองรับเอนจิ้นเชิงพาณิชย์และภาษาที่ไม่ใช่ภาษา C++

หากคุณกำลังเรียกใช้เอนจิ้นเชิงพาณิชย์ หรือภาษาที่ไม่ใช่ภาษา C หรือ C++ เราขอแนะนำให้คุณตรวจสอบระดับการรองรับที่เอนจิ้นหรือภาษาดังกล่าวได้มีให้แก่ Steamworks API
เพราะในบางเอนจิ้นนั้นอาจจะมีการรองรับภายในโดยพื้นฐาน และในบางเอนจิ้นคุณอาจจำเป็นจะต้องใช้โซลูชันภายนอก

หากเอนจิ้นของคุณไม่มีการรองรับโดยพื้นฐาน คุณสามารถใช้ Steam Web API เพื่อเข้าถึงคุณสมบัติหลาย ๆ อย่างที่ Steam ให้การรองรับได้

อย่างไรก็ตาม คุณจำเป็นจะต้องมี Steamworks SDK เวอร์ชันล่าสุดจึงจะ อัปโหลดแอปพลิเคชันของคุณลงใน Steam ได้ โดยไม่คำนึงถึงว่าในเอนจิ้นของคุณจะปรับใช้ Steamworks SDK หรือไม่

หมายเหตุ: หากซอฟต์แวร์ที่คุณจะนำส่งบน Steam สามารถใช้งานได้ตามใบอนุญาตสิทธิ์โอเพ่นซอร์สแบบจำกัดสิทธิ์ กรุณาดู การจัดจำหน่ายแอปพลิเคชันประเภท Open Source บน Steam เพื่อรับทราบรายละเอียดเพิ่มเติม

ต่อไปนี้เป็นเอนจิ้นทั่วไปที่ผู้คนใช้นำส่งเกมบน Steam อยู่เป็นประจำ และเอกสารการใช้งานที่เกี่ยวข้องเกี่ยวกับวิธีการเริ่มการใช้งาน Steamworks SDK กับเอนจิ้นเหล่านั้น

หมายเหตุ: ทาง Valve ไม่ได้ให้การสนับสนุนเอนจิ้นหรือโซลูชันจากภายนอกเหล่านี้ไม่ว่าในทางใดหรือทางหนึ่งทั้งสิ้น รายการดังกล่าวนี้ได้ถูกเรียงลำดับก่อนหลังตามชื่อ และรายการนี้ไม่มีความสมบูรณ์ รายการนี้มีไว้เพื่อเป็นแนวทางในการเริ่มต้นใช้งานเท่านั้น โดยจะระบุเอนจิ้นในกรณีที่เอนจิ้นดังกล่าวมีการรองรับโดยพื้นฐานเท่านั้น หรือมีโซลูชันภายนอกที่สอดรับกับแนวทางปฏิบัติใช้งาน โซลูชันภายนอกจะถูกระบุในกรณีที่ได้รับการอัปเดตเป็นปัจจุบันเพื่อรองรับ Steamworks SDK อย่างเป็นที่น่าพอใจเท่านั้น และอนุญาตให้ใช้งานได้โดยไม่เสียค่าใช้จ่ายตามใบอนุญาตสิทธิ์ให้ใช้งาน (กรุณาดู: การจัดจำหน่ายแอปพลิเคชันประเภท Open Source บน Steam) และมีกระทู้อยู่บน กระดานสนทนา Steamworks ทางเราขอแนะนำให้คุณปรึกษาชุมชนเพื่อดูว่าตัวเลือกใดเป็นตัวเลือกที่ดีที่สุดต่อการใช้งานเฉพาะของคุณ

เอนจิ้น:

เอนจิ้นมีการรองรับโดยพื้นฐานหรือไม่?ข้อมูล
CRYENGINE ✔️
GameMaker Studio 2 ✔️ การใช้ Steamworks SDK ร่วมกับ GameMaker: Studio
Godot ภายนอก: GodotSteam - กระทู้ฝ่ายสนับสนุนกระดานสนทนาผู้พัฒนา Steamworks
Haxe ภายนอก: SteamWrap - กระทู้ฝ่ายสนับสนุนกระดานสนทนาผู้พัฒนา Steamworks
Leadwerks Game Engine ✔️ ข้อมูลอ้างอิงในการใช้งาน Leadwerks API › Steamworks
RPG Maker MV ภายนอก: Greenworks - กระทู้ฝ่ายสนับสนุนกระดานสนทนาผู้พัฒนา Steamworks
Source 2013 ✔️ การจัดจำหน่ายเกมที่ใช้ Source Engine
Unity ภายนอก: Facepunch.Steamworks - กระทู้ฝ่ายสนับสนุนกระดานสนทนาผู้พัฒนา Steamworks
ภายนอก: http://steamworks.github.io - กระทู้ฝ่ายสนับสนุนกระดานสนทนาผู้พัฒนา Steamworks
Unreal Engine 4 ✔️ Steam โดยใช้ Steam SDK ระหว่างการพัฒนา
Visionaire Studio ✔️ เผยแพร่บน Steam

ภาษา:

รายละเอียดทางเทคนิค

Steam จะใช้เทคนิคหลากหลายแบบเพื่อทำให้แอปพลิเคชันของคุณสามารถเข้าถึงฟังก์ชันการทำงานต่าง ๆ ได้ แม้การเข้าใจถึงวิธีการทำงานของ Steamworks API อย่างถ่องแท้จะไม่ได้เป็นเรื่องสำคัญที่จำเป็นต้องทำ แต่ก็ถือว่าเป็นเรื่องไม่ยากและเป็นประโยชน์ในการวางแผนการเขียนโปรแกรมเกมของคุณให้มีความสอดรับกับ Steam

เมื่อคุณเชื่อมโยงกับ steam_api[64][.dll/.so/dylib] จะให้การเข้าถึง ฟังก์ชันของ C จำนวนเล็กน้อย ซึ่งจะมีการใส่ข้อมูลนำหน้าด้วยมาโคร S_API โดยฟังก์ชันเหล่านี้ทั้งหมดจะถูกแสดงอยู่ใน steam_api.h และ steam_gameserver.h โดยโมดูล steam_api เองมีขนาดเล็ก และจะแสดงฟังก์ชันการทำงานพื้นฐานในการเปิดและปิดใช้งาน Steamworks API เท่านั้น

เมื่อ Steamworks API เปิดใช้งาน ก็จะค้นหากระบวนการของไคลเอนต์ Steam ที่กำลังทำงานอยู่แล้วโหลด steamclient.dll จากเส้นทางนั้น steamclient.dll โดยเฉพาะอย่างยิ่งเป็นแกนกลางของไคลเอนต์ Steam ซึ่งจะบรรจุและดูแลรักษาข้อมูลที่จำเป็นในการเรียกใช้ Steam UI ของไคลเอนต์ Steam จะใช้ชุดฟังก์ชันที่คล้ายคลึงกันกับที่ได้แสดงไว้ที่นี่ในการเข้าถึงข้อมูลที่ได้ให้ไว้โดย steamclient.dll เนื่องจากข้อมูลนี้อยู่ในกระบวนการของ Steam จึงทำให้การเรียก API ของ Steam ทั้งหมดถูกทำให้มีความโปร่งใสและถูกส่งผ่านทางกลไก RPC/IPC (A cross-process pipe, ISteamClient::HSteamPipe).

กระบวนการ Steam ผ่านทาง steamclient.dll จะรักษาการเชื่อมต่อกับเซิร์ฟเวอร์แบ็คเอนด์ของ Steam อยู่ตลอดเวลา ซึ่งการสื่อสารในการตรวจสอบความถูกต้อง การค้นหาแมตช์ การดูรายการเพื่อน และ VAC ทั้งหมดนั้นจะดำเนินการผ่านช่องทางการเชื่อมต่อนี้ การเชื่อมต่อดังกล่าวนี้อาจจะถูกตัดขาดได้ หากผู้ใช้ประสบปัญหาทางด้านเครือข่าย หรือเซิร์ฟเวอร์ Steam ที่ผู้ใช้กำลังเชื่อมต่ออยู่นั้นได้รับการอัปเดต หากการเชื่อมต่อถูกตัดขาดหรือสร้างการเชื่อมต่อขึ้นใหม่ การคอลแบ็กจะถูกโพสต์ไปยังแอปที่กำลังทำงานอยู่ ไคลเอนต์ Steam จะพยายามทำการเชื่อมต่อใหม่โดยอัตโนมัติ และไคลเอนต์ที่เรียกใช้แอปอยู่จะได้รับการจัดความสำคัญให้อยู่ก่อน เพราะฉะนั้น โดยทั่วไปแล้วเวลาในการเชื่อมต่อใหม่จะต่ำกว่า 10 วินาที แต่ว่าในบางกรณี ซึ่งถือว่าเป็นกรณีที่เกิดขึ้นได้ยากนั้น อาจจะต้องใช้เวลาถึง 5 นาที

Steamworks API จะถูกจัดเวอร์ชันผ่านทางกลไกลประเภท COM ซึ่งจะส่งผ่านชื่อสตริงและเวอร์ชันของอินเตอร์เฟสไปยัง steamclient.dll ที่จะคืนค่าเวอร์ชันของอินเตอร์เฟสที่ถูกต้องกลับมาให้แก่ตัวคอล steamclient.dll ประกอบไปด้วยชุดของอะแดปเตอร์สำหรับเวอร์ชันของอินเตอร์เฟสที่ได้ถูกปล่อยออกมาทั้งหมด ซึ่งจะเปลี่ยนเส้นทางและตีความการเรียกเก่าใหม่อีกครั้งในบริบทของอินเตอร์เฟสล่าสุด โดยชุดอะแดปเตอร์นี้จะอยู่ในไคลเอนต์ Steam เพื่อให้ง่ายต่อการอัปเดต หากมีปัญหาใด ๆ เกิดขึ้น