การปรับปรุงฟังก์ชั่น O (N ^ 2) (เอนทิตีทั้งหมดทำซ้ำมากกว่าเอนทิตีอื่น ๆ ทั้งหมด)

พื้นหลังเล็กน้อยฉันเขียนโค้ดเกมวิวัฒนาการกับเพื่อนใน C ++ โดยใช้ ENTT สำหรับระบบเอนทิตี สิ่งมีชีวิตที่เดินไปรอบ ๆ ในแผนที่ 2 มิติกินสีเขียวหรือสิ่งมีชีวิตอื่นทำซ้ำและคุณสมบัติของพวกมันกลายพันธุ์

นอกจากนี้ประสิทธิภาพก็ดี (60fps ไม่มีปัญหา) เมื่อเกมทำงานแบบเรียลไทม์ แต่ฉันต้องการที่จะเพิ่มความเร็วอย่างมีนัยสำคัญโดยไม่ต้องรอ 4h เพื่อดูการเปลี่ยนแปลงที่สำคัญ ดังนั้นฉันต้องการได้เร็วที่สุด

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

หากต้องการกินสิ่งมีชีวิตที่อยู่ในภาพควรจะมองไปรอบ ๆ ตัวเองในรัศมี 149.64 (ระยะการมองของมัน) และตัดสินว่าควรกินอาหารชนิดใดซึ่งขึ้นอยู่กับโภชนาการระยะทางและประเภท (เนื้อสัตว์หรือพืช) .

ฟังก์ชั่นที่รับผิดชอบในการค้นหาสิ่งมีชีวิตทุกชนิดของพวกเขาคือการกินอาหารประมาณ 70% ของเวลาใช้งาน ทำให้การเขียนง่ายขึ้นในขณะนี้มันจะเป็นดังนี้:

for (creature : all_creatures)
{
  for (food : all_entities_with_food_value)
  {
    // if the food is within the creatures view and it's
    // the best food found yet, it becomes the best food
  }
  // set the best food as the target for creature
  // make the creature chase it (change its state)
}

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

ฉันเปิดรับแนวคิดเกี่ยวกับวิธีทำให้กระบวนการนี้มีประสิทธิภาพมากขึ้น ฉันชอบที่จะลดความซับซ้อนจากแต่ฉันไม่รู้ว่าเป็นไปได้หรือไม่$O(N^2)$

วิธีหนึ่งที่ฉันปรับปรุงอยู่แล้วคือการจัดall_entities_with_food_valueกลุ่มเพื่อให้สิ่งมีชีวิตซ้ำไปซ้ำมากินอาหารใหญ่เกินกว่าที่มันจะกินมันจะหยุดอยู่ตรงนั้น การปรับปรุงอื่น ๆ เป็นมากกว่าการต้อนรับ!

แก้ไข: ขอบคุณทุกท่านสำหรับคำตอบ! ฉันใช้สิ่งต่าง ๆ จากคำตอบต่าง ๆ :

ฉันทำอย่างแรกและเรียบง่ายเพื่อให้ฟังก์ชั่นความผิดทำงานเพียงแค่ทุก ๆ ห้าเห็บเท่านั้นมันทำให้เกมเร็วขึ้น 4x เท่าในขณะที่ไม่มีการเปลี่ยนแปลงอะไรเกี่ยวกับเกม

หลังจากนั้นฉันเก็บไว้ในระบบการค้นหาอาหารอาร์เรย์ที่มีอาหารวางไข่ในเห็บเดียวกับที่มันทำงาน ด้วยวิธีนี้ฉันเพียงแค่ต้องเปรียบเทียบอาหารที่สัตว์กำลังไล่ล่ากับอาหารใหม่ที่ปรากฏ

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

ตอนนี้การแสดงผลคือสิ่งที่ทำให้ช้าลงของฉัน แต่นั่นเป็นปัญหาสำหรับอีกวัน ขอบคุณทุกคน!

ฉันรู้ว่าคุณไม่ได้คิดเรื่องนี้เป็นความขัดแย้ง แต่สิ่งที่คุณกำลังทำคือการชนกันเป็นวงกลมอยู่ตรงกลางที่สิ่งมีชีวิตด้วยอาหารทั้งหมด

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

สิ่งมีชีวิตที่หาอาหาร

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

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

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

หากคุณทำให้ขนาดของเซลล์เป็นพลังงานของสองคุณสามารถค้นหาเซลล์ที่สิ่งมีชีวิตอยู่เพียงแค่ตัดพิกัดของมัน

คุณสามารถทำงานกับระยะทางกำลังสอง (aka ห้ามทำ sqrt) ในขณะที่เปรียบเทียบเพื่อค้นหาสิ่งที่ใกล้เคียงที่สุด การดำเนินงาน sqrt ที่น้อยลงหมายถึงการดำเนินการที่รวดเร็วยิ่งขึ้น

เพิ่มอาหารใหม่

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

น่าสนใจยิ่งกว่านี้หากคุณใส่คำอธิบายประกอบลงไปในสิ่งมีชีวิตมันอยู่ห่างจากอาหารแค่ไหนคุณกำลังไล่ตาม ... คุณสามารถตรวจสอบกับระยะทางนั้นได้โดยตรง

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

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

ข้ามการจำลอง

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

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

ข้ามไปที่ช่วงเวลานั้น คุณไม่จำเป็นต้องจำลองสิ่งมีชีวิตที่เคลื่อนไหวไปมา

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

ในการสร้างลำดับชั้นวางชิ้นส่วนอาหารไว้ใกล้ ๆ กันใน AABB จากนั้นใส่ AABBs เหล่านั้นใน AABB ที่ใหญ่กว่าอีกครั้งโดยระยะห่างระหว่างพวกเขา ทำสิ่งนี้จนกว่าคุณจะมีโหนดรูท

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

คุณยังสามารถใช้ประโยชน์จากห้องสมุดAABB.cc

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

ปัญหาของคุณคือคุณเก็บข้อมูลการลงคะแนน มันเหมือนกับว่ามีเด็ก ๆ ที่เบาะหลังเพื่อขอเวลาหนึ่งพัน "เรายังมี" ยังไม่จำเป็นต้องทำเช่นนั้นคนขับจะแจ้งให้ทราบเมื่อคุณอยู่ที่นั่น

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

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

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

คุณสามารถใช้อัลกอริทึมการกวาดบรรทัดเพื่อลดความซับซ้อนเป็น Nlog (N) ทฤษฎีคือแผนภาพ Voronoi ซึ่งทำให้การแบ่งส่วนของพื้นที่โดยรอบสิ่งมีชีวิตในภูมิภาคที่ประกอบด้วยจุดทั้งหมดที่อยู่ใกล้กับสิ่งมีชีวิตนั้นมากกว่าสิ่งอื่นใด

อัลกอริธึมที่เรียกว่าของฟอร์จูนทำเพื่อคุณใน Nlog (N) และหน้า wiki ที่มีรหัสหลอกเพื่อนำไปใช้ ฉันแน่ใจว่ามีการใช้งานห้องสมุดที่นั่นเช่นกัน https://en.wikipedia.org/wiki/Fortune%27s_algorithm

ทางออกที่ง่ายที่สุดคือการรวมเครื่องยนต์ฟิสิกส์และใช้อัลกอริทึมตรวจจับการชนเท่านั้น เพียงแค่สร้างวงกลม / ทรงกลมรอบ ๆ เอนทิตี้แต่ละแห่งและให้เอนจินฟิสิกส์คำนวณการชนกัน สำหรับ 2D ฉันขอแนะนำBox2DหรือChipmunkและBulletสำหรับ 3D

หากคุณรู้สึกว่าการบูรณาการกลไกฟิสิกส์ทั้งหมดนั้นมากเกินไปฉันขอแนะนำให้มองหาอัลกอริทึมการชนที่เฉพาะเจาะจง ห้องสมุดตรวจจับการชนกันส่วนใหญ่ทำงานในสองขั้นตอน:

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