การสื่อสารแบบเอนทิตีทำงานอย่างไร

ฉันมีสองกรณีผู้ใช้:

1. จะentity_Aส่งtake-damageข้อความถึงentity_Bอย่างไร
2. HP จะentity_Aค้นหาด้วยวิธีentity_Bใด

นี่คือสิ่งที่ฉันได้พบ:

• คิวข้อความ
  1. entity_Aสร้างtake-damageข้อความและโพสต์ไปentity_Bที่คิวข้อความของ
  2. entity_Aสร้างข้อความและโพสต์ไปยัง query-hp ในการกลับมาสร้างข้อความและโพสต์ไปยังentity_Bentity_Bresponse-hpentity_A
• เผยแพร่ / สมัครสมาชิก
  1. entity_Bสมัครรับtake-damageข้อความ (อาจเป็นไปได้ว่ามีการกรองบางอย่างเพื่อให้ส่งเฉพาะข้อความที่เกี่ยวข้องเท่านั้น) entity_Aผลิตข้อความที่อ้างอิงtake-damageentity_B
  2. entity_Aสมัครรับupdate-hpข้อความ (อาจถูกกรอง) ทุกเฟรมentity_Bออกอากาศupdate-hpข้อความ
• สัญญาณ / สล็อต
  1. ???
  2. entity_Aเชื่อมตupdate-hpสล็อตentity_B's update-hpสัญญาณ

มีอะไรที่ดีกว่านี้ไหม? ฉันมีความเข้าใจที่ถูกต้องหรือไม่ว่าโครงร่างการสื่อสารเหล่านี้จะผูกเข้ากับระบบเอนทิตีของเอ็นจิ้นเกมได้อย่างไร

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

ที่กล่าวว่าฉันเคยใช้และมีความสุขกับรูปแบบสัญญาณ / สล็อตรวมกับการส่งข้อความแบบง่าย ฉันใช้มันใน C ++ และ Lua สำหรับชื่อ iPhone ที่ค่อนข้างประสบความสำเร็จและมีตารางงานที่แน่นมาก

สำหรับกรณีสัญญาณ / สล็อตถ้าฉันต้องการให้เอนทิตี้ A ทำบางสิ่งบางอย่างเพื่อตอบสนองต่อเอนทิตี B ที่ทำ (เช่นปลดล็อกประตูเมื่อมีอะไรบางอย่างตาย) ฉันอาจมีเอนทิตี้ A สมัครสมาชิกโดยตรงกับเหตุการณ์การตายของเอนทิตี้ B หรือเอนทิตี A อาจสมัครสมาชิกกลุ่มแต่ละกลุ่มเพิ่มจำนวนตัวนับในแต่ละเหตุการณ์ที่ถูกไล่ออกและปลดล็อคประตูหลังจากที่ N ของพวกเขาเสียชีวิต นอกจากนี้ "กลุ่มเอนทิตี" และ "N ของพวกเขา" โดยทั่วไปจะถูกกำหนดไว้ในข้อมูลระดับ (นอกเหนือจากนี้นี่เป็นพื้นที่หนึ่งที่ coroutines สามารถส่องแสงได้จริง ๆ เช่น WaitForMultiple ("Dying", entA, entB, entC); door.Unlock ();)

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

สิ่งนี้สามารถ overkill ได้ง่าย (เทียบกับตัวอย่างของ tenpn) นอกจากนี้ยังสามารถขยายตัวได้อย่างไม่มีประสิทธิภาพหากคุณมีการดำเนินการมากมาย แต่ถึงแม้จะมีข้อเสีย แต่วิธี "ข้อความและกิจกรรม" นี้เข้ากันได้ดีกับโค้ดเกมที่เขียนสคริปต์ (เช่นใน Lua) รหัสสคริปต์สามารถกำหนดและตอบสนองต่อข้อความและเหตุการณ์ของตนเองโดยไม่ต้องใช้รหัส C ++ ในการดูแลเลย และโค้ดสคริปต์สามารถส่งข้อความที่เรียกรหัส C ++ เช่นระดับการเปลี่ยนแปลงการเล่นเสียงหรือแม้แต่ปล่อยให้อาวุธตั้งค่าความเสียหายที่ข้อความ TakeDamage ส่งมอบได้อย่างง่ายดาย มันช่วยฉันได้สักระยะเพราะฉันไม่ต้องโง่ไปกับ luabind และให้ฉันเก็บรหัส luabind ทั้งหมดไว้ในที่เดียวเพราะมันมีไม่มาก เมื่อประกอบเข้าด้วยกันอย่างถูกต้อง

นอกจากนี้ประสบการณ์ของฉันกับกรณีการใช้งาน # 2 คือว่าคุณดีกว่าจัดการกับมันเป็นเหตุการณ์ในทิศทางอื่น แทนที่จะถามว่าสุขภาพของกิจการคืออะไรให้เริ่มเหตุการณ์ / ส่งข้อความเมื่อใดก็ตามที่สุขภาพมีการเปลี่ยนแปลงที่สำคัญ

ในแง่ของอินเทอร์เฟซ btw ฉันลงเอยด้วยคลาสที่สามเพื่อใช้ทั้งหมดนี้: EventHost, EventClient และ MessageClient EventHosts สร้างสล็อต, EventClients สมัครสมาชิก / เชื่อมต่อกับพวกเขาและ MessageClients เชื่อมโยงผู้ได้รับมอบหมายกับข้อความ โปรดทราบว่าเป้าหมายผู้รับมอบสิทธิ์ของ MessageClient ไม่จำเป็นต้องเป็นวัตถุเดียวกับเจ้าของสมาคม ในคำอื่น ๆ MessageClients สามารถมีอยู่เพียงเพื่อส่งต่อข้อความไปยังวัตถุอื่น FWIW คำอุปมาโฮสต์ / ไคลเอ็นต์นั้นไม่เหมาะสม Source / Sink อาจเป็นแนวคิดที่ดีกว่า

ขอโทษฉันเดินไปที่นั่น มันเป็นคำตอบแรกของฉัน :) ฉันหวังว่ามันจะสมเหตุสมผล

// in entity_a's code:
entity_b->takeDamage();

คุณถามว่าเกม comercial ทำอย่างไร ;)

คำตอบที่จริงจังมากขึ้น:

ฉันเห็นกระดานดำใช้มาก Simple version ไม่มีอะไรมากไปกว่า struts ที่อัปเดตด้วยสิ่งต่าง ๆ เช่น HP ของเอนทิตีซึ่งเอนทิตีสามารถค้นหาได้

กระดานดำของคุณอาจเป็นมุมมองของโลกของเอนทิตีนี้ (ถามกระดานดำของ B ว่า HP คืออะไร) หรือมุมมองของเอนทิตีของโลก (A ค้นหากระดานดำเพื่อดูว่าเป้าหมายของ HP คืออะไร

หากคุณอัปเดตกระดานดำที่จุดซิงค์ในเฟรมคุณสามารถอ่านได้จากจุดใดจุดหนึ่งในภายหลังจากเธรดใด ๆ ซึ่งทำให้การทำมัลติเธรดเป็นเรื่องง่าย

กระดานดำขั้นสูงอาจมีลักษณะเหมือนแฮชเทเบิ้ลการจับคู่สตริงกับค่า นี่คือการบำรุงรักษามากขึ้น แต่เห็นได้ชัดว่ามีค่าใช้จ่ายในการทำงาน

กระดานดำเป็นการสื่อสารทางเดียวแบบดั้งเดิม - มันจะไม่จัดการกับความเสียหายที่ dishing

ฉันได้ศึกษาปัญหานี้เล็กน้อยและฉันได้เห็นวิธีแก้ปัญหาที่ดี

โดยทั่วไปทุกอย่างเกี่ยวกับระบบย่อย มันคล้ายกับแนวคิดกระดานดำที่กล่าวถึงโดย tenpn

เอนทิตีทำจากส่วนประกอบ แต่เป็นเพียงถุงทรัพย์สิน ไม่มีการใช้พฤติกรรมในเอนทิตี้ของตัวเอง

สมมติว่าเอนทิตีมีองค์ประกอบสุขภาพและองค์ประกอบความเสียหาย

จากนั้นคุณมี MessageManager และระบบย่อยสามระบบ: ActionSystem, DamageSystem, HealthSystem เมื่อถึงจุดหนึ่ง ActionSystem จะทำการคำนวณบนโลกของเกมและสร้างกิจกรรม:

HIT, source=entity_A target=entity_B power=5

เหตุการณ์นี้ถูกเผยแพร่ไปยัง MessageManager เมื่อถึงจุดหนึ่ง MessageManager จะผ่านข้อความที่ค้างอยู่และพบว่า DamageSystem ได้สมัครรับข่าวสาร HIT ตอนนี้ MessageManager ส่งข้อความ HIT ไปที่ DamageSystem ระบบ DamageSystem จะผ่านรายการของหน่วยงานที่มีองค์ประกอบความเสียหายคำนวณคะแนนความเสียหายขึ้นอยู่กับพลังโจมตีหรือสถานะอื่นของหน่วยงานทั้งสองเป็นต้นและเผยแพร่เหตุการณ์

DAMAGE, source=entity_A target=entity_B amount=7

HealthSystem ได้สมัครรับข้อความ DAMAGE และเมื่อ MessageManager เผยแพร่ข้อความ DAMAGE ไปยัง HealthSystem ระบบ HealthSystem สามารถเข้าถึงเอนทิตีเอนทิตีทั้งสองและเอนทิตีเอนทิตีของคอมโพเนนต์สุขภาพของพวกเขาดังนั้น HealthSystem สามารถทำการคำนวณได้ ไปที่ MessageManager)

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

ฉันไม่รู้ว่าเอ็นจิ้นเกมจริงบางตัวได้นำความคิดนี้ไปใช้หรือไม่ แต่ดูเหมือนว่าจะค่อนข้างแข็งและสะอาดและฉันหวังว่าสักวันหนึ่งที่จะนำไปใช้กับตัวฉันเองสำหรับเอ็นจิ้นเกมระดับงานอดิเรกของฉัน

ทำไมไม่มีคิวข้อความร่วมกัน:

messageQueue.push_back(shared_ptr<Event>(new DamageEvent(entityB, 10, entityA)));

ด้วย:

DamageEvent(Entity* toDamage, uint amount, Entity* damageDealer);

และในตอนท้ายของการวนรอบเกม / การจัดการเหตุการณ์:

while(!messageQueue.empty())
{
    Event e = messageQueue.front();
    messageQueue.pop_front();
    e.Execute();
}

ฉันคิดว่านี่เป็นรูปแบบคำสั่ง และExecute()เป็นเสมือนจริงบริสุทธิ์Eventซึ่งอนุพันธ์กำหนดและทำสิ่งต่าง ๆ ดังนั้นที่นี่:

DamageEvent::Execute() 
{
    toDamage->takeDamage(amount); // Or of course, you could now have entityA get points, or a recognition of damage, or anything.
}

หากเกมของคุณเป็นผู้เล่นคนเดียวให้ใช้วิธีการของวัตถุเป้าหมาย (ตามคำแนะนำจาก tenpn)

หากคุณเป็น (หรือต้องการสนับสนุน) มัลติเพลเยอร์ (มัลติผู้เล่นจะต้องแน่นอน) ให้ใช้คิวคำสั่ง

• เมื่อ A สร้างดาเมจให้กับ B บนไคลเอนต์ 1 เพียงแค่เข้าคิวเหตุการณ์ดาเมจ
• ซิงโครไนซ์คิวคำสั่งผ่านเครือข่าย
• จัดการกับคำสั่งที่จัดคิวทั้งสองด้าน

ฉันจะบอกว่า: ใช้ไม่ได้ตราบใดที่คุณไม่ต้องการคำติชมแบบทันทีทันใดจากความเสียหาย

เอนทิตี / ส่วนประกอบที่รับความเสียหาย / อะไรก็ตามที่ควรผลักดันให้เหตุการณ์ไปสู่คิวเหตุการณ์ในท้องถิ่นหรือระบบในระดับที่เท่ากันซึ่งเก็บเหตุการณ์ความเสียหาย

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

เพียงโทรออก อย่าทำ request-hp ที่ folllowed โดย query-hp - ถ้าคุณทำตามโมเดลนั้นคุณจะอยู่ในโลกที่เจ็บปวด

คุณอาจต้องการดู Mono Continuations ด้วยเช่นกัน ฉันคิดว่ามันจะเหมาะสำหรับ NPC

แล้วจะเกิดอะไรขึ้นถ้าเรามีผู้เล่น A และ B ที่พยายามจะตีกันในรอบการอัพเดทเดียวกัน () สมมติว่า Update () สำหรับผู้เล่น A เกิดขึ้นก่อน Update () สำหรับผู้เล่น B ในรอบที่ 1 (หรือติ๊กหรืออะไรก็ตามที่คุณเรียก) มีสองสถานการณ์ที่ฉันนึกถึง:

1. ประมวลผลทันทีผ่านข้อความ:

   • ผู้เล่น A. อัปเดต () เห็นผู้เล่นต้องการกด B ผู้เล่น B จะได้รับข้อความแจ้งความเสียหาย
   • ผู้เล่น B.HandleMessage () อัพเดท hitpoints สำหรับผู้เล่น B (เขาตาย)
   • ผู้เล่น B.Update () เห็นผู้เล่น B นั้นตายแล้ว .. เขาไม่สามารถโจมตีผู้เล่น A ได้

สิ่งนี้ไม่ยุติธรรมผู้เล่น A และ B ควรตีกันผู้เล่น B เสียชีวิตก่อนที่จะกดปุ่ม A เพียงเพราะเอนทิตี / gameobject ได้รับการอัปเดต () ในภายหลัง

1. การจัดคิวข้อความ

   • ผู้เล่น A. อัปเดต () เห็นผู้เล่นต้องการกด B ผู้เล่น B ได้รับข้อความแจ้งความเสียหายและเก็บไว้ในคิว
   • ผู้เล่น A.Update () ตรวจสอบคิวมันว่างเปล่า
   • ผู้เล่น B.Update () ตรวจสอบการเคลื่อนไหวก่อนเพื่อให้ผู้เล่น B ส่งข้อความไปยังผู้เล่น A ที่มีความเสียหายเช่นกัน
   • ผู้เล่น B.Update () จัดการข้อความในคิวประมวลผลความเสียหายจากผู้เล่น A
   • รอบใหม่ (2): ผู้เล่น A ต้องการดื่มยาเพื่อสุขภาพดังนั้นผู้เล่น A. อัปเดต () จะถูกเรียกและการเคลื่อนไหวถูกประมวลผล
   • ผู้เล่น A.Update () ตรวจสอบคิวข้อความและประมวลผลความเสียหายจากผู้เล่น B

อีกครั้งนี้ไม่ยุติธรรม .. ผู้เล่น A ควรจะได้รับ hitpoint ในเทิร์น / รอบ / เห็บเดียวกัน!