คำถามติดแท็ก networking

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

21 networking  path-finding  interpolation 

การใช้การชดเชยความล่าช้าของเครือข่ายเป็นเรื่องยากจะหลีกเลี่ยงได้อย่างไร อาจเป็นไปได้ที่จะใช้เทคนิคและสร้างกลไกของเกมในลักษณะที่ความล่าช้าจะได้รับการรับรู้ว่าไม่สำคัญหรือเป็นส่วนหนึ่งของเกม เทคนิคเหล่านั้นคืออะไรและมีเกมใดบ้างที่มีอยู่ (MMORPG, กลยุทธ์, ... ) ที่ใช้เทคนิคดังกล่าว? UPDATE: เกมตามเทิร์นไม่จำเป็นต้องมีการชดเชยความล่าช้า แต่น่าสนใจที่จะเห็นวิธีการแบบเรียลไทม์ (หรือเพียงแค่ความประทับใจในแบบเรียลไทม์ส่วนสำคัญ - ผู้ใช้ไม่ควรถูกบล็อกและบังคับให้รอ) เหตุผลหลักสำหรับฉันที่จะหลีกเลี่ยงการชดเชยความล่าช้าคือความเรียบง่าย

20 networking  mmo  rpg  rts  lag 

แม้กระทั่งเกมที่เป็นไคลเอนต์ / เซิร์ฟเวอร์ 100% บางครั้งก็มีปัญหาเมื่อไคลเอนต์อยู่หลัง NAT เกม Peee-peer เป็นปัญหาที่ใหญ่กว่า เกมบางเกมจำเป็นต้องใช้การส่งสัญญาณหลายครั้ง (เช่น UDP และ TCP) หรือการเชื่อมต่อที่หลากหลาย (เช่นพอร์ต UDP ที่แตกต่างกันสำหรับเสียง) มีวิธีใดบ้างที่จะทำให้แน่ใจว่าเกมทำงานได้อย่างน่าเชื่อถือเมื่อใช้งานเราเตอร์ NAT? เพียร์ - เพียร์: ไม่มีเซิร์ฟเวอร์ส่วนกลางอยู่ ผู้เล่น A เริ่มเกมและผู้เล่น B ต้องการเข้าร่วม ไคลเอนต์ - เซิร์ฟเวอร์: เซิร์ฟเวอร์ส่วนกลางที่อยู่ที่รู้จักกันดี (ชื่อโฮสต์) ยอมรับการเชื่อมต่อที่เข้ามาทั้งหมด ลูกค้าแต่ละรายสื่อสารกับเซิร์ฟเวอร์นั้นเท่านั้น คำสั่งผสม: ตำแหน่งที่เซิร์ฟเวอร์กำลังทำการจับคู่ แต่การอัปเดตเกมเป็นแบบ peer-peer คนรอบข้างที่แตกต่างกันอาจเห็นผู้เล่นแต่ละคนที่มี IP / พอร์ตต่างกันที่อาจเกิดขึ้น (เช่นลูกค้าบางรายอยู่หลัง NAT เดียวกันและบางคนอยู่ในเราเตอร์ที่แตกต่างกัน)

20 networking  multiplayer 

ใน MMO (ไม่จำเป็นต้องเป็น MMORPG) มีเทคนิคอะไรบ้างในการจัดการกับผู้เล่นที่ตัดการเชื่อมต่อในช่วงกลางของ PvP? โดยเฉพาะอย่างยิ่ง - คุณจะหลีกเลี่ยงผลกระทบที่ส่งผลเสียต่อผู้ที่ถูกตัดการเชื่อมต่อเนื่องจากปัญหาเครือข่าย (หรือแม้กระทั่งชีวิตจริง) ได้อย่างไรในขณะที่ไม่ส่งผลเสียต่อคนที่มีส่วนร่วม และที่สำคัญวิธีการที่คุณจะแน่ใจได้ตัดการเชื่อมต่อที่ไม่สามารถนำมาใช้เป็นวิธีการของการโกงหรือไม่?

20 game-design  networking  mmo  balance  pvp 

ฉันมีระบบที่มีสิทธิ์ซึ่งเมื่อผู้เล่นเข้าร่วมการแข่งขันมันจะได้รับวัตถุที่เกิดแล้วทั้งหมด - กลับกลายเป็นตัวของมันเอง (ลูกค้า) ดูเหมือนว่านี้: Client ส่งโทเค็นการเข้าถึงไปที่ Server Client ได้รับการยอมรับจาก Server Client สลับฉากกับฉากเกม Serverส่งผู้เล่น, ลัง, วัตถุที่คุณสามารถโต้ตอบด้วยเพื่อให้clientสามารถวางไข่และแสดงพวกเขา แต่วัตถุพื้นดินล่ะ? ตอนนี้ฉันมีฉากเดียวกันที่แน่นอนบนเซิร์ฟเวอร์และไคลเอนต์ - ด้วยระนาบคงที่หนึ่งที่ทำหน้าที่เป็นพื้น ขณะนี้ฉันกำลังเพิ่มสิ่งใหม่ต้นไม้บันไดและสร้างสิ่งต่าง ๆ ด้วยกัน ฉันคิดว่า - เราดี แต่ไม่ควรซิงโครไนซ์สภาพแวดล้อมด้วย? จะเชื่อมต่อเครือข่ายอย่างใด? เป็นเจ้าของเซิร์ฟเวอร์หรือไม่ มาดูLeague of Legendsกัน: มันเป็นสภาพแวดล้อมที่คงที่อาจเป็นตาข่ายเดียว (บันไดหญ้าผนังร้านค้า) แต่มันถูกเก็บไว้ในไคลเอนต์จริง ๆ หรือมันถูกส่งโดยเซิร์ฟเวอร์ในระหว่างการโหลดหน้าจอ?

18 unity  networking  maps 

ไม่มีอะไรที่เหมือนกับกิจวัตรประจำวันของการปรับแต่งตัวแปร, การคอมไพล์โค้ดที่ใช้เวลาสองสามนาที, รันโค้ด, โดยตระหนักว่า tweak ของคุณอยู่ในทิศทางที่ไม่ถูกต้อง ฉันต้องการเริ่มต้นโต้ตอบกับตรรกะเกมของฉันขณะที่เซสชันกำลังดำเนินการอยู่ มีวิธีใดบ้างที่คุณจัดการเรื่องนี้? ฉันจะเปิดให้ฟังโซลูชันสำหรับ iOS, C / C ++ และ C # / XNA

18 networking  debugging 

ฉันกำลังทำงานกับระบบเอนทิตีสำหรับเกมบนเครือข่ายและฉันกำหนดรหัสประจำตัวจำนวนเต็ม 32 บิตที่ไม่ซ้ำกันซึ่งฉันสามารถใช้เพื่ออ้างอิงการอ้างอิงไปยังเอนทิตีและเอนทิตีเองได้ ขณะนี้ฉันเพิ่งเพิ่มตัวนับทุกครั้งที่มีการสร้างเอนทิตี ฉันเดารหัสในที่สุดจะหมด แต่ฉันไม่คาดหวังว่าจะมี 4 พันล้านหน่วย นอกจากนี้สิ่งนี้จะช่วยหลีกเลี่ยงปัญหาหากเอนทิตี # 5 ถูกทำลายและเราได้รับ id 5 มันหมายถึงการอ้างถึง # 5 ใหม่หรือเก่าที่ถูกลบ # 5 หรือไม่ ปัญหาคือฉันไม่แน่ใจว่าจะจัดการ / หลีกเลี่ยงการชนได้อย่างไร ในปัจจุบันหากลูกค้าได้รับการอัปเดตสำหรับเอนทิตีที่มีรหัสสูงกว่า "ฟรีไอดี" ในปัจจุบันมันแค่กระแทกมันเป็นไอดีฟรีจนถึงอดีต แต่นั่นดูไม่แข็งแกร่งนัก ฉันคิดเกี่ยวกับการกำหนดช่วงให้กับลูกค้าแต่ละรายเพื่อให้พวกเขาสามารถจัดสรรเอนทิตีโดยไม่ขัดแย้งกัน (พูดว่า n บิตอันดับแรกคือหมายเลขผู้เล่น) แต่ฉันกังวลว่าจะเกิดอะไรขึ้นถ้าช่วงเริ่มทับซ้อนกันเมื่อเวลาผ่านไป มีวิธีจัดการที่ดีกว่านี้ไหม ฉันควรจะสนใจเกี่ยวกับรหัสล้นหรือจะผ่านจุดสิ้นสุดของช่วงที่อนุญาตหรือไม่ ฉันสามารถเพิ่มรหัสเพื่อตรวจสอบกรณีเหล่านี้ แต่จะทำอย่างไรถ้าเกิดขึ้นนอกเหนือจากความผิดพลาด อีกทางเลือกหนึ่งคือการใช้บางอย่างที่มีโอกาสสูงกว่าในการเป็นเอกลักษณ์เช่น 128- บิต GUID แต่ดูเหมือนว่าหนักมากสำหรับเกมที่พยายามลดปริมาณการใช้เครือข่าย นอกจากนี้ในความเป็นจริงฉันจะไม่ต้องการเอนทิตีเพิ่มเติมในคราวเดียวจากนั้นจะพอดีกับจำนวนเต็ม 32- บิตหรือ 24 บิต ขอบคุณ!

17 networking  entity-system 

ฉันเคยลองเขียนเกมง่ายๆกับ UDP ในหนึ่งสัปดาห์เพื่อทดสอบการโยนทิ้ง มันไปอย่างน่ากลัว ฉันโยนมันออกไปก่อน ปัญหาหลักที่ฉันได้คือการแก้ไขสถานะเกมของผู้เล่น / ศัตรู / วัตถุทั้งหมดให้เป็นสถานะเก่าและส่งต่อเกมอย่างรวดเร็วไปยังช่วงเวลาที่ผู้เล่นกำลังเล่น (เช่นครึ่งวินาทีก่อนที่จะกระโดดกระโดดเร็วหรือช้าเล็กน้อย ทำให้ผู้เล่นพลาดการกระโดด) บางทีวิธีนี้ไม่ใช่วิธีที่ง่ายที่สุด? ฉันสงสัยว่ามันเป็น แต่ฉันออกแบบมันผิดตั้งแต่ต้นและตระหนักในตอนท้ายของวันที่ 2 (ดังนั้นฉันไม่ได้เรียนรู้มากเกินไปหรือเสียเวลามาก) สำหรับตัวเองและคนอื่น ๆ สิ่งที่เกี่ยวข้องกับเกม UDP อย่างง่ายและฉันจะเขียนได้อย่างไร? หรือฉันจะแก้ปัญหาการทำนายการคืนค่าสถานะอย่างถูกต้องได้อย่างไร ฉันจะทำเครื่องหมายนี้เป็น CW bc ฉันรู้ว่าจะมีคำตอบที่เป็นประโยชน์มากมาย

17 architecture  networking 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันกำลังส่งข้อมูลไปมาระหว่างเซิร์ฟเวอร์สำหรับเกมที่ฉันทำอยู่ ขณะนี้ฉันส่งข้อมูลตำแหน่งดังนี้: sendToClient((("UID:" + cl.uid +";x:" + cl.x))); sendToClient((("UID:" + cl.uid +";y:" + cl.y))); sendToClient((("UID:" + cl.uid +";z:" + cl.z))); เห็นได้ชัดว่ามันกำลังส่งค่า X, Y และ Z ที่เกี่ยวข้อง การส่งข้อมูลเช่นนี้จะมีประสิทธิภาพมากขึ้นหรือไม่ sendToClient((("UID:" + cl.uid +"|" + cl.x + "|" + cl.y + "|" + cl.z)));

16 networking 

ฉันกำลังพัฒนาเกมกลยุทธ์แบบเรียลไทม์สำหรับหลักสูตรวิทยาศาสตร์คอมพิวเตอร์ที่ฉันเรียน หนึ่งในแง่มุมที่ยากกว่าของมันก็คือการเชื่อมต่อเครือข่ายและเซิร์ฟเวอร์ลูกค้า ฉันได้อ่านในหัวข้อนี้ (รวมถึงนักธนู 1500 คน ) แต่ฉันตัดสินใจใช้วิธีไคลเอ็นต์ - เซิร์ฟเวอร์ซึ่งต่างจากรุ่นอื่น ๆ (ผ่าน LAN เป็นต้น) เกมกลยุทธ์เรียลไทม์มาพร้อมกับปัญหาบางอย่าง โชคดีที่การกระทำของผู้เล่นทุกครั้งนั้นถูกกำหนดไว้แล้ว อย่างไรก็ตามมีเหตุการณ์ที่เกิดขึ้นตามช่วงเวลาที่กำหนดไว้ ตัวอย่างเช่นเกมประกอบด้วยกระเบื้องและเมื่อผู้เล่นใช้แผ่นกระเบื้อง 'ระดับพลังงาน' ซึ่งเป็นค่าบนแผ่นกระเบื้องนั้นควรเพิ่มขึ้นทีละวินาทีทุกครั้งหลังจากที่ถ่ายเสร็จ นี่เป็นคำอธิบายสั้น ๆ ที่ควรแสดงให้เห็นถึงกรณีการใช้งานของฉัน ตอนนี้ฉันกำลังทำไคลเอ็นต์แบบ thin ซึ่งเพิ่งส่งแพ็กเก็ตไปยังเซิร์ฟเวอร์และรอการตอบกลับ อย่างไรก็ตามมีปัญหาหลายประการ เมื่อเกมระหว่างผู้เล่นพัฒนาเป็น endgame มักจะมีมากกว่า 50 กิจกรรมต่อวินาที (เนื่องจากเหตุการณ์ที่กำหนดไว้อธิบายก่อนหน้าซ้อนขึ้น) และข้อผิดพลาดในการประสานเริ่มปรากฏขึ้นแล้ว ปัญหาที่ใหญ่ที่สุดของฉันคือแม้แต่ความเบี่ยงเบนเล็กน้อยในสถานะระหว่างลูกค้าอาจหมายถึงการตัดสินใจที่แตกต่างกันของลูกค้าซึ่งก้อนหิมะกลายเป็นเกมที่แยกจากกันโดยสิ้นเชิง ปัญหาอื่น (ซึ่งไม่สำคัญในตอนนี้) คือเวลาแฝงและต้องรอสองสามมิลลิวินาทีแม้แต่วินาทีหลังจากที่พวกเขาขยับเพื่อดูผลลัพธ์ ฉันสงสัยว่ากลยุทธ์และอัลกอริทึมใดที่ฉันสามารถใช้เพื่อทำให้สิ่งนี้ง่ายขึ้นเร็วขึ้นและสนุกสนานยิ่งขึ้นสำหรับผู้ใช้ สิ่งนี้น่าสนใจเป็นพิเศษเนื่องจากมีจำนวนกิจกรรมต่อวินาทีสูงพร้อมกับผู้เล่นหลายคนต่อเกม TL; DR สร้าง RTS ด้วย> 50 กิจกรรมต่อวินาทีฉันจะซิงโครไนซ์ไคลเอ็นต์ได้อย่างไร

16 algorithm  networking  client-server  synchronization  strategy 

ฉันมีคำถามเกี่ยวกับ UDP สำหรับบริบทฉันทำงานในเกมแอ็คชั่นตามเวลาจริง ฉันได้อ่านบ้างเล็กน้อยเกี่ยวกับความแตกต่างระหว่าง UDP และ TCP และฉันรู้สึกว่าเข้าใจค่อนข้างดี แต่มีชิ้นส่วนหนึ่งที่ไม่เคยรู้สึกถูกต้องและน่าเชื่อถือและมีการตอบรับเป็นพิเศษ ฉันเข้าใจว่า UDP ไม่ได้ให้ความน่าเชื่อถือตามค่าเริ่มต้น (เช่นแพ็คเก็ตสามารถถูกทิ้ง เมื่อจำเป็นต้องมีความน่าเชื่อถือโซลูชันที่ฉันเห็น (ซึ่งเหมาะสมตามแนวคิด) คือการใช้ acceptgments (เช่นเซิร์ฟเวอร์ส่งแพ็กเก็ตไปยังไคลเอ็นต์และเมื่อไคลเอ็นต์ได้รับข้อความนั้นจะส่งการตอบกลับไปยังเซิร์ฟเวอร์) . จะเกิดอะไรขึ้นเมื่อการตอบรับลดลง ในตัวอย่างข้างต้น (เซิร์ฟเวอร์หนึ่งกำลังส่งแพ็คเก็ตไปยังไคลเอนต์หนึ่ง) เซิร์ฟเวอร์จัดการการสูญหายของแพ็กเก็ตที่อาจเกิดขึ้นโดยการส่งแพ็กเก็ตใหม่ทุกเฟรมจนกว่าจะได้รับการตอบรับสำหรับแพ็กเก็ตเหล่านั้น คุณยังอาจพบปัญหาเกี่ยวกับแบนด์วิดท์หรือข้อความที่ไม่เป็นไปตามคำสั่ง แต่จากมุมมองการสูญเสียแพ็คเก็ตเซิร์ฟเวอร์ครอบคลุม อย่างไรก็ตามหากลูกค้าส่งการตอบรับที่ไม่เคยมาถึงเซิร์ฟเวอร์จะไม่มีทางเลือกนอกจากต้องหยุดส่งข้อความในที่สุดซึ่งอาจทำลายเกมได้หากจำเป็นต้องมีข้อมูลในแพ็คเก็ตนั้น คุณสามารถใช้วิธีการที่คล้ายกันไปยังเซิร์ฟเวอร์ (เช่นส่งการตอบรับจนกว่าคุณจะได้รับ ack สำหรับ ack?) แต่วิธีการนั้นจะทำให้คุณวนกลับไปกลับมาตลอดไป (เนื่องจากคุณต้องการ ack สำหรับ ack สำหรับ ack และอื่น ๆ ) ฉันรู้สึกว่าตรรกะพื้นฐานของฉันถูกต้องตรงนี้ซึ่งทำให้ฉันมีสองตัวเลือก ส่งแพ็คเก็ตการตอบรับเพียงครั้งเดียวและหวังว่าจะดีที่สุด ส่งแพ็คเก็ตการรับทราบจำนวนหนึ่ง (อาจ 3-4) และหวังว่าจะดีที่สุดโดยสมมติว่าจะไม่ทิ้งทั้งหมด มีคำตอบสำหรับปัญหานี้หรือไม่? ฉันเข้าใจอะไรผิดหรือเปล่า? มีการรับประกันการใช้ …

16 networking  udp 

ฉันกำลังทำงานกับนักยิงจากบนลงล่าง 2D และพยายามอย่างเต็มที่เพื่อคัดลอกแนวคิดที่ใช้ในเกมบนเครือข่ายเช่น Quake 3 ฉันมีเซิร์ฟเวอร์ที่เชื่อถือได้ เซิร์ฟเวอร์ส่งสแน็ปช็อตไปยังลูกค้า สแน็ปช็อตมีการประทับเวลาและตำแหน่งเอนทิตี เอนทิตีถูกสอดแทรกระหว่างตำแหน่งสแน็ปช็อตเพื่อให้การเคลื่อนไหวดูราบรื่น ตามความจำเป็นการแก้ไขเอนทิตีเกิดขึ้นเล็กน้อย "ในอดีต" เพื่อให้เรามีสแนปชอตหลายรายการที่จะแก้ไขระหว่าง ปัญหาที่ฉันเผชิญคือ "การซิงโครไนซ์นาฬิกา" เพื่อความเรียบง่ายเรามาเสแสร้งสักครู่ว่าไม่มีเวลาแฝงเป็นศูนย์เมื่อทำการโอนย้ายแพ็คเก็ตไปและกลับจากเซิร์ฟเวอร์ หากนาฬิกาเซิร์ฟเวอร์คือ 60 วินาทีข้างหน้าของนาฬิกาไคลเอนต์การประทับเวลาสแน็ปช็อตจะเป็น 60000ms ล่วงหน้าของการประทับเวลาโลคัลไคลเอ็นต์ ดังนั้นสแนปชอตเอนทิตีจะรวบรวมและนั่งประมาณ 60 วินาทีก่อนที่ลูกค้าจะเห็นเอนทิตีที่กำหนดใด ๆ ที่ทำให้การเคลื่อนไหวของเขาเพราะมันใช้เวลานานขนาดนั้นในการติดตามลูกค้า ฉันจัดการเอาชนะมันได้โดยการคำนวณความแตกต่างระหว่างเซิร์ฟเวอร์และนาฬิกาลูกค้าในแต่ละครั้งที่ได้รับสแนปชอต // For simplicity, don't worry about latency for now... client_server_clock_delta = snapshot.server_timestamp - client_timestamp; เมื่อกำหนดระยะเวลาในการแก้ไขเอนทิตีฉันจะเพิ่มความแตกต่างให้กับเวลาปัจจุบันของลูกค้า อย่างไรก็ตามปัญหานี้ก็คือมันจะทำให้เกิดความสะเพร่าเนื่องจากความแตกต่างระหว่างนาฬิกาทั้งสองจะเปลี่ยนแปลงอย่างฉับพลันเนื่องจากสแน็ปช็อตมาถึงเร็วกว่า / ช้ากว่าคนอื่น ฉันจะซิงโครไนซ์นาฬิกาอย่างใกล้ชิดได้อย่างไรว่าการหน่วงเวลาที่รับรู้ได้เพียงอย่างเดียวคือการเข้ารหัสแบบยากสำหรับการแก้ไขและสิ่งที่เกิดจากเวลาแฝงของเครือข่ายปกติ กล่าวอีกนัยหนึ่งฉันจะป้องกันไม่ให้การแก้ไขเริ่มต้นช้าเกินไปหรือเร็วเกินไปเมื่อนาฬิกาถูกซิงโครไนซ์อย่างมีนัยสำคัญโดยไม่มีการกระตุก แก้ไข: ตามวิกิพีเดีย NTP สามารถใช้เพื่อซิงโครไนซ์นาฬิกาผ่านอินเทอร์เน็ตได้ภายในเวลาไม่กี่มิลลิวินาที …

15 networking  server  client-server  synchronization  socket 

ฉันกำลังเขียนโปรแกรมเกมของฉันโดยใช้แบบจำลองไคลเอนต์ - เซิร์ฟเวอร์ เมื่อเล่นกับ singleplayer เกมจะเริ่มต้นเซิร์ฟเวอร์ภายในและโต้ตอบกับมันเหมือนกับเซิร์ฟเวอร์ระยะไกล (ผู้เล่นหลายคน) ฉันได้ทำเช่นนี้เพื่อหลีกเลี่ยงการเข้ารหัสแยก singleplayer และรหัสผู้เล่นหลายคน ฉันเพิ่งเริ่มเขียนโค้ดและพบปัญหาใหญ่ ขณะนี้ฉันกำลังพัฒนาเกมใน Eclipse โดยมีคลาสเกมทั้งหมดจัดเป็นแพ็คเกจ จากนั้นในรหัสเซิร์ฟเวอร์ของฉันฉันใช้คลาสทั้งหมดในแพ็คเกจไคลเอ็นต์ ปัญหาคือคลาสไคลเอนต์เหล่านี้มีตัวแปรเฉพาะสำหรับการเรนเดอร์ซึ่งแน่นอนว่าไม่สามารถทำได้บนเซิร์ฟเวอร์ ฉันควรสร้างคลาสไคลเอนต์ที่แก้ไขแล้วเพื่อใช้ในเซิร์ฟเวอร์หรือไม่ หรือฉันควรแก้ไขคลาสไคลเอ็นต์ด้วยบูลีนเพื่อระบุว่าไคลเอ็นต์ / เซิร์ฟเวอร์ใช้หรือไม่ ฉันมีตัวเลือกอื่น ๆ อีกไหม? ฉันเพิ่งคิดว่าอาจใช้คลาสเซิร์ฟเวอร์เป็นคลาสหลักจากนั้นขยายด้วยการเรนเดอร์เนื้อหา?

15 java  networking  server  client-server  metaprogramming 

เมื่อออกแบบเกมแบบผู้เล่นหลายคนในเครือข่ายที่ผู้เล่นคนหนึ่งเป็นเจ้าภาพและคนอื่น ๆ เชื่อมต่อมีสองวิธีที่ฉันรู้: ให้เกมของผู้เล่นโฮสต์เป็นผู้มีอำนาจโดยมีผู้เล่นคนอื่น ๆ ทั้งหมดที่เป็นลูกค้าใบ้พยายามที่จะไล่ตามสถานะเกมปัจจุบัน ในรหัสนั้นจะต้องมีหลายกรณีพิเศษขึ้นอยู่กับว่าผู้เล่นปัจจุบันเป็นเจ้าบ้านหรือไม่ ทำให้โฮสต์เป็นลูกค้าที่โง่เหมือนคนอื่น ๆ โดยการเรียกใช้เซิร์ฟเวอร์เฉพาะที่ซ่อนอยู่ในเธรดอื่น เซิร์ฟเวอร์เฉพาะจะเป็นสิทธิ์และโฮสต์จะเชื่อมต่อกับมันเหมือนทุกคน (ผ่าน localhost) ข้อดี / ข้อเสียของแต่ละข้อคืออะไร? ใช้บ่อยที่สุด (หรือแตกต่างกันไปตามประเภท / ขนาดของเกม)

15 game-design  networking  multiplayer 

ฉันกำลังคิดที่จะสร้างเซิร์ฟเวอร์ MMO และฉันดูว่าเกมอื่น ๆ จัดโครงสร้างเครือข่ายของพวกเขาอย่างไร สิ่งหนึ่งที่ฉันสังเกตเห็นคือมีเซิร์ฟเวอร์เข้าสู่ระบบเสมอและเซิร์ฟเวอร์เกม ฉันยังคงตัดสินใจว่าควรทำเช่นนี้หรือไม่ แต่ฉันต้องการที่จะได้ยินความคิดเห็นบางอย่างก่อน อะไรคือข้อดีของสิ่งนี้และเซิร์ฟเวอร์ล็อกอินสื่อสารกับเซิร์ฟเวอร์เกมเพื่อจัดการการเข้าสู่ระบบอย่างไร

15 mmo  networking  server  scalability