คำถามติดแท็ก client-server

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

45 html5  javascript  client-server 

ฉันยังใหม่ต่อการพัฒนาเกม แต่ไม่ได้เขียนโปรแกรม ฉัน (อีกครั้ง) เล่นกับเกมประเภท Pong โดยใช้canvasองค์ประกอบของ JavaScript ฉันสร้างPaddleวัตถุที่มีคุณสมบัติดังต่อไปนี้ ... width height x y colour ฉันยังมีPongวัตถุที่มีคุณสมบัติเช่น ... width height backgroundColour draw(). draw()วิธีการในปัจจุบันคือการรีเซ็ตcanvasและที่เป็นที่คำถามขึ้นมา ควรPaddleวัตถุมีdraw()วิธีการรับผิดชอบสำหรับการวาดภาพหรือควรdraw()ของPongวัตถุต้องรับผิดชอบสำหรับการวาดภาพของนักแสดง (ฉันคิดว่าเป็นคำที่ถูกต้องโปรดแก้ไขฉันหากฉันไม่ถูกต้อง) ฉันคิดว่ามันจะเป็น advantagous สำหรับPaddleการวาดตัวเองที่ผมยกตัวอย่างวัตถุสองและPlayer Enemyถ้ามันไม่ได้อยู่ในPongของdraw()ฉันจะต้องเขียนรหัสที่คล้ายกันสองครั้ง การปฏิบัติที่ดีที่สุดที่นี่คืออะไร? ขอบคุณ

41 rendering  game-loop  html-canvas  mathematics  vector  projection  legal  game-industry  music  copyright  android  multithreading  cocos2d  2d  sprites  art  2d  3d  models  hand-drawn  xna  c#  fonts  c++  directx9  opengl  shaders  glsl  compatibility  nvidia  software-engineering  android  design-patterns  bounding-boxes  octree  java  console  lwjgl  xna  collision-detection  movement  mmo  server  java  android  multithreading  client-server  source-code  xna  hlsl 

วิธีที่ถูกต้องในการบอกตำแหน่งของผู้เล่นท้องถิ่นของเราไปยังเซิร์ฟเวอร์คืออะไร? เอกสารบางฉบับบอกว่าเป็นการดีกว่าที่จะส่งอินพุตเมื่อใดก็ตามที่มีการผลิต และเอกสารบางอย่างบอกว่าลูกค้าส่งตำแหน่งในช่วงเวลาที่แน่นอน ด้วยวิธีการส่งอินพุต: ฉันควรทำอย่างไรหากผู้เล่นกดปุ่มทิศทางค้างไว้ มันหมายความว่าฉันต้องส่งแพคเกจไปยังเซิร์ฟเวอร์ในทุก ๆ เฟรม มันไม่มากเกินไปเหรอ? และยังมีการหมุนของผู้เล่นจากอินพุตของเมาส์ นี่คือตัวอย่าง: http://www.gabrielgambetta.com/fpm_live.html สิ่งที่เกี่ยวกับการส่งตำแหน่งในแนวทางช่วงเวลาคงที่ มันส่งข้อความน้อยเกินไปไปยังเซิร์ฟเวอร์ แต่มันยังลดการตอบสนอง แล้วทางไหนดีกว่ากัน?

23 networking  multiplayer  client-server  first-person-shooter 

ฉันใช้ MMO ที่ผู้เล่นบินไปในอวกาศบนยานอวกาศของเขาควบคุมด้วยปุ่มลูกศรและร่วมมือกับผู้เล่นคนอื่น ๆ ฉันต้องการใช้มันเพื่อให้ผู้เล่นสามารถหลบเรือของเขาจากจรวดหรืออย่างอื่นดังนั้นฉันจึงพยายามทำนายสถานะเกมทั้งหมดในฝั่งไคลเอ็นต์โดยใช้อัลกอริทึมจำลองโลกแบบเดียวกับการใช้เซิร์ฟเวอร์ โลกของเกมนั้นเขียนขึ้นบน C # และจะถูกเรียกภายในไคลเอนต์โดยตรง (มันเขียนบน Unity3D) และผ่าน CLR บนเซิร์ฟเวอร์ C ++ (ภายใต้ Linux) การเชื่อมต่อผ่าน UDP ปัญหาคือวิธีการดูแลรักษาผู้เล่น 1,000 คนในแผนที่เดียว (ไม่รวมวัตถุเกมอื่น ๆ mobs ... ): สมมติว่าฉันจะ: ซิงโครไนซ์เซิร์ฟเวอร์กับไคลเอนต์ 50 ครั้งต่อวินาที ส่งไปยังแต่ละไคลเอนต์ของวัตถุเกม (และผู้เล่น) ซึ่งเขาสามารถมองเห็นได้ (ภายในรัศมี) ต้องส่ง 100 วัตถุไปยังผู้เล่นแต่ละคนภายในรัศมีมุมมองของเขา จะต้องส่งค่าเฉลี่ย 50 ไบต์ต่อวัตถุเกม (มันเป็นรหัส, x, y coords, การหมุน, สถานะ ... ) …

22 mmo  client-server  synchronization 

ฉันต้องการใช้ฐานข้อมูล sql ใน server.exe ของฉัน สมมติว่ามีผู้ใช้ 1,000 คนออนไลน์ และผู้เล่นจะเปลี่ยนข้อมูลเมื่อเล่น และเซิร์ฟเวอร์จำเป็นต้องบันทึกอัพเดตเหล่านี้ แต่อย่างไร ฉันคิดว่ามีสองวิธี: 1) เซิร์ฟเวอร์จะบันทึก ram ในเวลาใช้งานและบางครั้งหรือเซิร์ฟเวอร์รายชั่วโมงจะเขียนข้อมูล (อัพเดต) ไปยังฐานข้อมูล sql จาก ram แต่ถ้ากระแสไฟฟ้าดับหรือเซิร์ฟเวอร์ปิดตัวลงการอัพเดตจะไม่บันทึก แน่นอนฉันไม่ต้องการสูญเสียการปรับปรุง 2) เซิร์ฟเวอร์จะบันทึกอัปเดตในฐานข้อมูล ณ เวลาทำงาน แต่จะเกิดอะไรขึ้นกับความเร็ว ฉันคิดถึงวิธีการหนึ่ง ฉันจะแสดงให้คุณเห็นด้านล่างด้วยภาพ ฉันจะได้รับความเร็วที่เพียงพอสำหรับผู้เล่นออนไลน์ 1,000 คนด้วยวิธีนี้หรือไม่?

22 mmo  client-server  server  sql 

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

20 multiplayer  client-server 

ทำไมการแก้ไขหน่วยความจำของไคลเอนต์เกมจึงใช้งานได้? ทำไมเครื่องมือ "การป้องกันการแฮ็ก" จำนวนมากจึงมากับลูกค้า ถ้าฉันออกแบบเกมไคลเอนต์เซิร์ฟเวอร์ทุกอย่างจะเกิดขึ้นที่เซิร์ฟเวอร์ (การจำลองโลกเกม) และลูกค้าจะเป็นเพียงผู้บริโภคที่ได้รับการอัพเดทสถานะของส่วนหนึ่งของโลกที่อยู่ใกล้ตัวละครส่งข้อมูลบางอย่างเช่น คำสั่ง keystrokes หรือ move / action บางทีฉันอาจจะพลาดอะไรบางอย่างที่นี่ แต่ด้วยการออกแบบนั้นการแฮ็กอย่างเช่นการเพิ่ม STR ของฉันด้วย 200 ในหน่วยความจำไคลเอนต์ (ถ้ามีค่าอยู่เลย) ก็จะไม่มีผล คำอธิบายเดียวที่ฉันคิดได้ก็คือเกมที่การแก้ไขหน่วยความจำให้ส่วนต่างๆของการจำลองทำงานในไคลเอนต์และเซิร์ฟเวอร์จากนั้นก็ซิงโครไนซ์ไคลเอนต์ทั้งหมดเป็นระยะ ฉันสามารถเข้าใจการออกแบบสำหรับเกม Real Time Strategy ที่มีจำนวนผู้เล่นที่แน่นอนเมื่อมีการกำหนดค่าการแข่งขัน แต่ทำไมใน MMORPG มันเป็นกลยุทธ์ในการลดโหลดเซิร์ฟเวอร์หรือไม่

19 mmo  client-server  online  anti-cheat  hacks 

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

19 server  client-server 

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

16 algorithm  networking  client-server  synchronization  strategy 

ฉันกำลังทำงานกับนักยิงจากบนลงล่าง 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 

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

15 client-server 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นไปตามหัวข้อสำหรับ Game Exchange Stack Exchange ปิดให้บริการใน6 ปีที่ผ่านมา ความคิดของฉันอีกคำถามสุดท้าย ถ้าฉันจะทำเกมไคลเอนต์ / เซิร์ฟเวอร์ที่มี unity3d ฉันจะสามารถเขียนโปรแกรมเซิร์ฟเวอร์ด้วยความสามัคคีได้หรือไม่? ถ้าฉันไม่สามารถใช้ C # .net? ถ้าไม่เช่นนั้นจะมีแพ็คเกจหรือ lib ที่ฉันสามารถใช้กับ C ++ ได้ไหม? การสื่อสารเป็นเพียงแค่ซ็อกเก็ตดิบหรือไม่

15 unity  client-server 

สมมติว่าเกมไคลเอนต์ / เซิร์ฟเวอร์มาตรฐานที่เรียบง่าย สำหรับเซิร์ฟเวอร์มันคุ้มค่าหรือไม่ที่จะมีกระบวนการแยกต่างหากที่รับฟังการเชื่อมต่อและข้อความจากไคลเอนต์และส่งข้อมูลผ่านซ็อกเก็ตท้องถิ่นหรือ stdin ไปยังกระบวนการอื่นที่รันเซิร์ฟเวอร์เกมจริง อีกทางเลือกหนึ่งคือให้ทำทั้งสองอย่างในขั้นตอนเดียว การจัดคิวข้อความขาเข้าและดำเนินการตามลำดับที่ถูกต้องไม่ควรมีปัญหาการหยุดชะงัก ฉันสงสัยว่าทรัพยากรพิเศษที่จะแยก "กิจกรรม" สองรายการนั้นคุ้มค่าหรือไม่ ฉันควรตัดสินใจอย่างไร ฉันต้องการได้ยินข้อดี / ข้อเสียใด ๆ

14 architecture  server  design-patterns  client-server 

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

14 networking  server  client-server  state  turn-based