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

เล่นโดยผู้เล่นหลายคนร่วมมือหรือแข่งขันภายในหรือจากระยะไกล

1
ผู้เล่นหลายคน HTML5, Node.js, Socket.IO [ปิด]
ปิด คำถามนี้ต้องการรายละเอียดหรือความคมชัด ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ เพิ่มรายละเอียดและชี้แจงปัญหาโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันพยายามสร้างผู้เล่นหลายคนแบบง่าย ๆ ด้วย HTML5 Canvas, JavaScript (เช่นกันโดยใช้ไลบรารี Inheritance ง่าย ๆ ของ John Resig) และ Node.js ด้วย Socket.IO รหัสลูกค้าของฉัน: var canvas = document.getElementById ('เกม'); var context = canvas.getContext ('2d'); var socket = new io.Socket ('127.0.0.1', {พอร์ต: 8080}); ผู้เล่น var = null; var UP = …

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

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

2
ระบบสแนปชอตของเกมจะใช้งานอย่างไรสำหรับเกมเรียลไทม์บนเครือข่าย
ฉันต้องการสร้างเกมแบบเรียลไทม์แบบมัลติ - เพลย์เยอร์ไคลเอ็นต์เซิร์ฟเวอร์เป็นโปรเจ็กต์สำหรับคลาสเครือข่ายของฉัน ฉันได้อ่านมากมายเกี่ยวกับโมเดลเครือข่ายผู้เล่นหลายคนแบบเรียลไทม์และฉันเข้าใจความสัมพันธ์ระหว่างไคลเอนต์กับเซิร์ฟเวอร์และเทคนิคการชดเชยความล่าช้า สิ่งที่ฉันต้องการทำคือสิ่งที่คล้ายกับโมเดลเครือข่าย Quake 3: โดยทั่วไปแล้วเซิร์ฟเวอร์จะเก็บภาพรวมของสถานะเกมทั้งหมด เมื่อได้รับข้อมูลจากลูกค้าเซิร์ฟเวอร์จะสร้างสแน็ปช็อตใหม่ที่สะท้อนถึงการเปลี่ยนแปลง จากนั้นจะคำนวณความแตกต่างระหว่างสแน็ปช็อตใหม่และสแน็ปช็อตสุดท้ายและส่งไปยังไคลเอนต์เพื่อให้สามารถซิงค์ได้ วิธีการนี้ดูเหมือนจะแข็งแกร่งสำหรับฉัน - หากไคลเอนต์และเซิร์ฟเวอร์มีการเชื่อมต่อที่เสถียรจะมีการส่งข้อมูลจำนวนเล็กน้อยที่จำเป็นเพียงเล็กน้อยเพื่อให้ข้อมูลตรงกัน หากไคลเอ็นต์ไม่ซิงค์กันคุณสามารถร้องขอสแน็ปช็อตเต็มรูปแบบได้เช่นกัน อย่างไรก็ตามฉันไม่สามารถหาวิธีที่ดีที่จะใช้ระบบ snapshot ฉันพบว่ามันยากมากที่จะย้ายออกจากสถาปัตยกรรมการเขียนโปรแกรมผู้เล่นเดี่ยวและคิดว่าฉันจะเก็บสถานะของเกมในลักษณะที่: ข้อมูลทั้งหมดจะถูกแยกออกจากตรรกะ สามารถคำนวณความแตกต่างระหว่างสแน็ปช็อตของสถานะเกม เอนทิตีของเกมสามารถจัดการได้อย่างง่ายดายผ่านรหัส ว่าเป็นภาพรวมระดับการดำเนินการ? เอนทิตีและข้อมูลถูกจัดเก็บอย่างไร เอนทิตีของลูกค้าทุกคนมีรหัสที่ตรงกับ ID บนเซิร์ฟเวอร์หรือไม่ คำนวณความแตกต่างของสแนปชอตได้อย่างไร โดยทั่วไป: ระบบสแนปชอตของเกมจะมีการนำไปใช้อย่างไร

2
มีเครื่องมือสำหรับทดสอบรหัสผู้เล่นหลายคนหรือไม่?
มีเครื่องมือที่เชื่อถือได้ที่สามารถจำลองสภาพเครือข่ายเหมือนชีวิตจริงเช่นเครือข่ายที่มีแบนด์วิดธ์ที่แตกต่างกันเวลาแฝงที่แตกต่างกันการสูญเสียตและอื่น ๆ ... ?

3
หลักการออกแบบเกมสำหรับผู้เล่นหลายคนแบบเรียลไทม์สำหรับ Node.js
ฉันได้อ่านวาล์วบทความเกี่ยวกับเครือข่ายผู้เล่นหลายที่ได้รับการดัดแปลงมาจาก Yahn เนียกระดาษ 2001 เรียกว่าแฝงชดเชยวิธีการในไคลเอ็นต์ / เซิร์ฟเวอร์ในเกมการออกแบบโปรโตคอลและการเพิ่มประสิทธิภาพ ฉันกำลังสร้างเกมผู้เล่นหลายคนเรียลไทม์โดยใช้เซิร์ฟเวอร์ node.js ที่เชื่อมต่อกับลูกค้าผ่าน socket.io และฉันมีคำถามสองสามข้อเกี่ยวกับหลักการที่อธิบายไว้ด้านล่าง: การแก้ไขเอนทิตี [การแก้ไข] ป้องกันการเคลื่อนไหวที่กระวนกระวายใจซึ่งสิ่งนี้มักจะนำไปสู่โดยการอัพเดทเซิร์ฟเวอร์บัฟเฟอร์จากนั้นเล่นกลับด้วยช่องว่างที่สอดแทรกอย่างราบรื่นระหว่าง นอกจากนี้ยังสามารถป้องกันข้อบกพร่องที่เกิดจากการสูญเสียต การทำนายฝั่งไคลเอ็นต์ การทำนายคือแนวคิดของลูกค้าที่ทำนายผลกระทบของการกระทำของผู้เล่นท้องถิ่นโดยไม่ต้องรอให้เซิร์ฟเวอร์ยืนยัน สถานะที่คาดการณ์ของเอนทิตีถูกทดสอบกับคำสั่งเซิร์ฟเวอร์เมื่อมาถึงจนกว่าจะตรวจจับคู่หรือจับคู่ผิด การชดเชยความล่าช้า การชดเชยความล่าช้าคือแนวคิดของเซิร์ฟเวอร์โดยใช้เวลาแฝงของผู้เล่นในการย้อนเวลาเมื่อประมวลผล [ผู้ใช้งาน] เพื่อดูว่าผู้เล่นเห็นอะไรเมื่อคำสั่งถูกส่ง เมื่อใช้ร่วมกับการคาดการณ์การชดเชยความล่าช้าจะช่วยต่อสู้กับเวลาแฝงของเครือข่ายจนถึงจุดที่เกือบกำจัดมันออกจากมุมมองของผู้โจมตี หลักการใช้กับ TCP เช่นเดียวกับที่ทำกับ UDP และจะมีความแตกต่างในการนำไปใช้หรือไม่? ฉันเห็นว่าการแก้ไขเอนทิตีไม่จำเป็นต้องป้องกันการสูญหายของแพ็คเก็ต แต่ก็เกี่ยวกับมัน ฉันสามารถสื่อสารระหว่างเซิร์ฟเวอร์กับเว็บเบราว์เซอร์และกลับกันโดยใช้ UDP และ Node.js ได้หรือไม่ เนื่องจากกระดาษมีอายุเกินหนึ่งทศวรรษหลักการเหล่านี้ยังคงใช้งานอยู่หรือมีเทคโนโลยีอื่นปรากฏขึ้นมา? ความช่วยเหลือใด ๆ ที่จะได้รับการชื่นชมมาก

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

4
ฐานข้อมูลใด (RDBMS เทียบกับ NoSQL และ BOTH) สำหรับเกม Realtime Multiplayer
ฉันทำงานกับเกมแบบเรียลไทม์ที่จะต้องใช้ฐานข้อมูล (สำหรับคุณสมบัติเช่นโปรไฟล์ผู้เล่นเพื่อนปลดล็อคข่าว ฯลฯ ) เกมนี้เป็นเกมพีซีมาตรฐาน (ไม่ใช่เบราว์เซอร์) และจะใช้ไคลเอนต์เซิร์ฟเวอร์ สถาปัตยกรรม. ฉันยังใหม่กับการใช้ฐานข้อมูลและได้ทำการวิจัยบางอย่างในช่วงไม่กี่วันที่ผ่านมาเมื่อฉันได้พบกับการอภิปรายที่ร้อนแรง: RDBMS vs NoSQL ขณะนี้ฉันกำลังโน้มเอียงไปทาง NoSQL แต่หลังจากอ่านเกี่ยวกับการใช้งานสำหรับแต่ละ (RDBMS และ NoSQL) ฉันก็อยากจะใช้ทั้งสองอย่าง ฉันรู้ว่ามันอาจดูแปลก แต่ขอให้ฉันอธิบายสถานการณ์ของฉัน: ทีมของฉันมีแพ็คเกจเว็บโฮสติ้งที่ใช้ร่วมกันซึ่งมีพื้นที่เก็บข้อมูลและแบนด์วิดธ์ mySQL ไม่ จำกัด ซึ่งเป็นข้อแม้เดียวที่เราสามารถเปิดได้ 25 การเชื่อมต่อในครั้งเดียว (กฎการโฮสต์ที่ใช้ร่วมกัน) ฉันตั้งใจจะใช้สิ่งนี้กับเว็บไซต์ของฉัน (เป็นการใช้งานทั่วไปอย่างไม่ต้องสงสัย) เพื่อโพสต์การอัปเดตข่าวสนับสนุนคุณลักษณะของชุมชน (เช่นความคิดเห็นการอัปโหลดภาพหน้าปกของแฟน ๆ ฯลฯ ) และอื่น ๆ นั่นคือทั้งหมดที่ดีและดี - แต่! นี่คือสิ่งที่น่าสนใจ ... ฉันต้องการแสดงข้อมูลเดียวกันนี้ที่โพสต์บนเว็บไซต์ของฉันในเกม นี่หมายถึงการใช้ mySQL สำหรับทั้งเว็บไซต์และเกมของฉัน นอกจากโพสต์ข่าวและสิ่งที่ชอบฉันวางแผนที่จะใช้มันในเกมสำหรับสิ่งต่าง ๆ เช่นการแชทและรายชื่อเซิร์ฟเวอร์ …

4
วิธีที่มีประสิทธิภาพที่สุดในการจัดอันดับและวัดทักษะผู้เล่นในสภาพแวดล้อมแบบมัลติเพลเยอร์?
ฉันรู้เกี่ยวกับอัลกอริทึม Truskill มันค่อนข้างซับซ้อน แต่มีประสิทธิภาพ คำถามของฉันมีอัลกอริธึม / วิธีอื่นในการกำหนดทักษะของผู้เล่นเพื่อการวัดที่แม่นยำสำหรับการแข่งขันที่มีผู้เล่นหลายคนหรือไม่?

5
ไลบรารีเลเยอร์เครือข่าย [ปิด]
ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังว่าคำตอบจะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ฉันกำลังมองหาเลเยอร์เครือข่ายใด ๆ ที่พร้อมที่จะเพิ่มให้กับเกมของฉันไม่ว่าจะฟรีหรือราคาที่ยุติธรรมสำหรับเกมอินดี้ โดยเลเยอร์เครือข่ายฉันหมายถึงห้องสมุดบางประเภทที่ฉันสามารถเชื่อมต่อกับที่ฉันจะสามารถส่งข้อความไปและรับข้อความจากและมันจะจัดการข้อมูลระดับต่ำทั้งหมดด้วยตัวเอง ฉันกำลังมองหาโดยเฉพาะอย่างยิ่ง: ห้องสมุดคุณภาพสูงที่เข้าใจและจัดการกับสิ่งที่ซับซ้อนเช่นความแออัดของเครือข่าย ห้องสมุดที่ปรับขนาดได้ซึ่งจะทำให้ฉันมีผู้เล่นจำนวนมากเล่นด้วยกัน ควรเป็นโซลูชันเพียร์ทูเพียร์ไม่ใช่เซิร์ฟเวอร์ที่ใช้ ควรเป็นไลบรารีที่มีผลผูกพันกับภาษาระดับสูง (เช่น Java หรือ C #) ตัวอย่างของสิ่งที่ฉันกำลังมองหาคือGrappleแต่ฉันรู้ว่ามีห้องสมุดอื่น ๆ

3
ข้อ จำกัด ของเกม p2p ที่มีผู้เล่นหลายคนเทียบกับไคลเอนต์เซิร์ฟเวอร์ [ปิด]
ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันกำลังอ่านข้อมูลเกี่ยวกับสถาปัตยกรรมเกมแบบผู้เล่นหลายคน จนถึงที่สุดของบทความที่ฉันได้พบข้อตกลงกับรูปแบบลูกค้า - เซิร์ฟเวอร์ ฉันต้องการทราบว่ามีข้อ จำกัด ในการใช้สถาปัตยกรรม p2p อย่างไร สิ่งที่ "คลาส" ของเกมเป็นไปได้ (หรือมากกว่าปกติ) เพื่อใช้งานหรือไม่ อันไหน และโดยทั่วไปแล้วอะไรคือข้อแตกต่างและข้อ จำกัด หลักกับแบบจำลองไคลเอ็นต์ - เซิร์ฟเวอร์

2
จะชดเชยการเคลื่อนย้ายวัตถุด้วยการทำนายฝั่งไคลเอ็นต์ได้อย่างไร
ผมดำเนินการเซิร์ฟเวอร์เกมที่สนับสนุนดาวควบคุมเหมือนกันพัลวัน ดังนั้นคุณต้องมีเรือที่บินและยิงด้วยฟิสิกส์ความเร็ว / การเร่งความเร็ว / ลดแรงกระแทกที่ง่ายที่สุดในการขับเคลื่อนการเคลื่อนไหว ฉันได้อ่าน Valve, Gafferon และ Gambetta และใช้อัลกอริทึมของ Gambettaเพื่อการคาดการณ์ลูกค้า: การทำนายลูกค้าทำงานบนเรือของผู้เล่นโดยอัพเดทตำแหน่งจากเซิร์ฟเวอร์ตามที่มาและจากนั้นนำอินพุตที่ยังไม่ได้ประมวลผลโดยเซิร์ฟเวอร์ไปยังผู้เล่น น่าเสียดายที่เกมของฉันใช้งานไม่ได้ ฉันเชื่อว่ามันเกี่ยวข้องกับความจริงที่ว่าตัวอย่างของ Gambetta ไม่ได้คำนึงถึงวัตถุที่เคลื่อนไหวอยู่แล้วหรือคำสั่งที่ได้รับการปรับปรุงทีละขั้นตอน (โดย "ขั้นตอน" ฉันหมายถึงเฟรม) ดังนั้นในเกมของฉันผู้เล่นกดขึ้นเพื่อเร่งการส่ง (ที่กำลังเคลื่อนไหว) ซึ่งยังคงเคลื่อนที่บนไคลเอนต์ส่งคำสั่งไปยังเซิร์ฟเวอร์และมักจะได้รับสแนปช็อตโลกจากเซิร์ฟเวอร์ในขั้นตอนถัดไป ฉันได้รับสิ่งที่ชอบมากขึ้น: คำสั่ง player รันที่ไคลเอ็นต์ขั้นตอน 3แต่บนเซิร์ฟเวอร์จะรันที่เซิร์ฟเวอร์ขั้นตอนที่ 5เท่านั้น เมื่อถึงเวลาที่ลูกค้าได้รับสแนปชอตของโลกในขั้นตอนที่ 6ลูกค้าการคาดการณ์จะถูกปิดโดยเฉพาะอย่างยิ่งในความเร็วที่เร็วขึ้น ปมของปัญหาคือว่าลูกค้ารันคำสั่งในขั้นตอนที่ 5แต่เซิร์ฟเวอร์ทำงานมันในขั้นตอนที่ 6 ฉันคิดถึงการส่งขั้นตอนไคลเอนต์ด้วยคำสั่งและให้เซิร์ฟเวอร์ย้อนกลับและเรียกใช้คำสั่งอีกครั้งด้วยขั้นตอนเวลาของไคลเอ็นต์ สิ่งนี้อาจนำไปสู่ปัญหาอื่น ๆ ที่เกิดขึ้นเช่น - สิ่งที่เกิดขึ้นกับคำสั่งที่ได้รับตั้งแต่การย้อนกลับหรือการโกงลูกค้าสามารถใช้ประโยชน์จากการเปลี่ยนขั้นตอนการส่ง การอ่านและการดูวิดีโอเช่นนี้จาก Google กล่าวถึงวิธีการที่แตกต่างกันซึ่งคุณจะค่อยๆเปลี่ยนตำแหน่งผู้เล่นเพื่อให้ตรงกับภาพรวมในไม่กี่ขั้นตอน คำถามของฉัน: คุณสามารถทำให้อัลกอริทึมของ Gambetta ทำงานกับการเคลื่อนที่แบบสเต็ปคงที่ได้หรือไม่? หรือมันขัดกับแนวคิดของเกมของฉัน? การแก้ไขแบบค่อยเป็นค่อยไปเหนือขั้นตอนเป็นวิธีที่ถูกต้องหรือไม่? …

3
เหตุใดจึงไม่สามารถเล่นเกมแบบผู้เล่นหลายคนข้ามแพลตฟอร์มได้
อย่างน้อยทำไมพวกเขาถึงทำยาก - สมมติว่านั่นเป็นเหตุผลว่าทำไมแม้แต่สตูดิโอ AAA ก็ไม่สามารถทำเกมนี้ให้สำเร็จได้ โดยเฉพาะอย่างยิ่งกับเอ็นจิ้นเกมข้ามแพลตฟอร์มที่ทันสมัยเช่น Unreal และ Unity ที่สามารถสร้างบน Xbox, PS4 และพีซีทำไมยังไม่ได้ทำสิ่งนี้ในขนาดใหญ่ ตัวอย่างเช่น Diablo III เป็นเกมที่วางจำหน่ายบนแพลตฟอร์มที่หลากหลาย แม้จะเป็นผลิตภัณฑ์ของ Blizzard ซึ่งเป็นหนึ่งใน บริษัท วิดีโอเกมที่ร่ำรวยที่สุดในโลก แต่ก็ไม่อนุญาตให้ผู้เล่น Xbox เล่นกับใครบางคนที่ใช้พีซี

2
วิธีซิงโครไนซ์การกระทำเช่นการกระโดดในผู้เล่นหลายคนได้อย่างไร
ฉันเป็นนักพัฒนาเกมมือใหม่และฉันค้นคว้าเกี่ยวกับเกมที่มีผู้เล่นหลายคน ฉันสังเกตว่ามันมีเวลาแฝงอยู่เสมอผู้เล่นจะได้รับการอัพเดตจากการกระทำในอดีตเสมอ แต่มีเทคนิคต่าง ๆ เช่นการคำนวณคนตายเพื่อจัดการเวลาแฝง ฉันสามารถทำนายการเคลื่อนไหวและทำให้การเคลื่อนไหวราบรื่น แต่ฉันจะทำให้การประสานเหมือนกระโดดหยุดเดินได้อย่างไร สมมติว่าลูกค้า A กำลังเคลื่อนไหวเขาอยู่ที่ 100m ในเวลา 10.2 ด้วยความเร็ว 100m / วินาทีและส่งข้อมูลนี้ ลูกค้า B จะได้รับข้อมูลนี้ในภายหลังให้เป็น 10.4 ดังนั้นที่ลูกค้า B ฉันสามารถใช้การคาดการณ์และวางลูกค้า A ที่ 120m แต่ถ้าลูกค้าทำกระโดดได้ที่ 110m ที่ 10.3 ฉันไม่สามารถคาดการณ์ได้และเนื่องจากฉันใช้การคาดการณ์ฉันจึงไม่สามารถแสดงให้ลูกค้า A กระโดดข้ามไปในอดีต ฉันอาจจัดการกับปัญหานี้โดยไม่ส่งการกระทำข้ามเลย แต่ถ้าเกมของฉันมีช่องว่างบางอย่างที่ผู้เล่นสามารถล้มและตาย ดังนั้นถ้าฉันไม่ซิงค์แอคชั่นกระโดดผู้เล่นคนอื่นจะสังเกตเห็นว่าผู้เล่นคนหนึ่งกำลังทำงานอยู่เขาจะตกเป็นโมฆะและปรากฏบนหน้าจออีกครั้งเพื่อทำลายการมีส่วนร่วมทางสายตา Jump เป็นเพียงตัวอย่างอาจมีหลายสถานการณ์ที่การทำนายไม่สามารถทำได้ ดังนั้นจะจัดการกับพวกเขาอย่างไร ตัวอย่างหนึ่งดังกล่าวสามารถเป็นได้หลายเกมออนไลน์เวทีการต่อสู้เช่น Awesomenauts

3
ฉันรู้ว่าการตั้งค่าผู้เล่นหลายคนที่เรียบง่ายของฉันอาจไม่ใช่ความคิดที่ดี แต่ทำไม?
ฉันกำลังสร้าง MOBA ตัวเล็ก ๆ ง่ายๆเพื่อความสนุกสนาน ฉันทำทุกอย่างที่ผู้เล่นคนเดียวแล้วฉันก็รู้ว่า "โอ้ฉันน่าจะเพิ่มหลายคนเหรอ" ฉันไม่เคยทำอะไรกับระบบเครือข่ายมาก่อนดังนั้นการเรียนรู้วิธีรวมLidgrenเข้ากับเกมของฉันนั้นสนุกและยอดเยี่ยม สิ่งคือฉันค่อนข้างรู้ว่าฉันทำสิ่งต่าง ๆ ผิดเพราะมันไม่แข็งแรงพอสำหรับเกมกระแสหลักที่จะใช้เท่าที่ฉันรู้ แต่มีอะไรผิดปกติกับมัน? สิ่งที่ฉันทำคือโดยทั่วไปเมื่อใดก็ตามที่ผู้เล่นทำการกระทำมันจะส่งข้อความไปยังเซิร์ฟเวอร์ว่า "เฮ้ฉันเพิ่งทำสิ่งนี้" เซิร์ฟเวอร์และไคลเอนต์ต่างก็ใช้การจำลองสถานการณ์เดียวกัน จากนั้นเซิร์ฟเวอร์จะส่งข้อความไปยังลูกค้ารายอื่นทั้งหมดบอกพวกเขาว่าผู้ชายคนนั้นทำสิ่งนั้น ส่วนใหญ่ยกเว้นในบางกรณีเมื่อผู้เล่นทำสิ่งใดลูกค้าถือว่ามันเจ๋งและก้าวไปข้างหน้าด้วยตัวมันเอง ดังนั้นเมื่อคุณคลิกขวาที่ใดที่หนึ่งเพื่อย้ายไปที่นั่นไคลเอนต์ของผู้เล่นนั้นเพิ่งเริ่มเคลื่อนย้ายคนที่แต่งตัวประหลาดของเขาที่นั่นแล้วส่งข้อความไปยังเซิร์ฟเวอร์ที่บอกเรื่องนี้ ดังนั้นโดยทั่วไป: ผู้เล่นคนที่ 1 ร่ายคาถาเพื่อให้เขาเคลื่อนที่เร็วขึ้น 100% เป็นเวลาหกวินาที ลูกค้าในพื้นที่ของผู้เล่น 1 เพิ่มบัฟนั้นไปยังวัตถุหน่วยของเขา ลูกค้าของผู้เล่น 1 ส่งข้อความไปยังเซิร์ฟเวอร์ว่า "เฮ้ฉันเพิ่งเสกคาถานี้" เซิร์ฟเวอร์ทำให้แน่ใจว่าเขามีมานามากพอที่จะใช้คาถานั้นและถ้าเป็นเช่นนั้นจะเพิ่ม buff นั้นลงในสำเนาของเซิร์ฟเวอร์ของวัตถุหน่วย เซิร์ฟเวอร์ส่งข้อความถึงลูกค้ารายอื่นว่า "เฮ้คนนี้เพิ่งเสกคาถานี้" ลูกค้าอื่น ๆ ทุกคนจะได้รับข้อความและไปที่ "อ่าโอเคเจ๋ง" และเพิ่มบัฟนั้นไปยังออบเจคยูนิตในพื้นที่ของตนสำหรับผู้เล่นนั้น ฉันได้อ่านข้อมูลต่าง ๆ เพื่อดูว่าเกมใหญ่ ๆ เล่นหลายคนได้อย่างไรและมันค่อนข้างสับสนสำหรับใครบางคนที่เพิ่งเริ่มตะลุยสิ่งนี้ แต่ดูเหมือนว่า Source engineจะส่งแพ็คเก็ตที่มีการเปลี่ยนแปลงทุกอย่างใน โลกทุกเห็บ? …

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.