วิธีหลีกเลี่ยงวัตถุเกมลบโดยไม่ตั้งใจใน C ++

สมมติว่าเกมของฉันมีสัตว์ประหลาดที่สามารถโจมตีได้ด้วยระเบิด เรามาเลือกชื่อสัตว์ประหลาดตัวนี้แบบสุ่ม: Creeper ดังนั้นCreeperคลาสมีวิธีการที่มีลักษณะดังนี้:

void Creeper::kamikaze() {
    EventSystem::postEvent(ENTITY_DEATH, this);

    Explosion* e = new Explosion;
    e->setLocation(this->location());
    this->world->addEntity(e);
}

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

void World::handleEvent(int type, void* context) {
    if(type == ENTITY_DEATH){
        Entity* ent = dynamic_cast<Entity*>(context);
        removeEntity(ent);
        delete ent;
    }
}

เพราะCreeperวัตถุที่ได้รับการลบในขณะที่วิธีการที่จะยังคงทำงานก็จะมีปัญหาเมื่อพยายามที่จะเข้าถึงkamikazethis->location()

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

ใน C ++ มีวิธีแก้ปัญหาทั่วไปที่ดีกว่าสำหรับปัญหานี้หรือไม่ที่วัตถุจะลบตัวเองออกจากภายในหนึ่งในวิธีการใด ๆ

อย่าลบ this

แม้โดยปริยาย

- เคย -

การลบวัตถุในขณะที่หนึ่งในฟังก์ชั่นสมาชิกของมันยังคงอยู่ในสแต็กกำลังขอให้มีปัญหา สถาปัตยกรรมโค้ดใด ๆ ที่ส่งผลให้เกิดขึ้น ("บังเอิญ" หรือไม่) นั้นไม่ดีตามวัตถุประสงค์มีอันตรายและควรได้รับการเปลี่ยนใหม่ทันทีทันที ในกรณีนี้ถ้าสัตว์ประหลาดของคุณจะได้รับอนุญาตให้โทร 'World :: handleEvent' อย่าลบสัตว์ประหลาดในฟังก์ชั่นนั้นไม่ว่าในกรณีใด!

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

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

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

ตัวอย่างของคลาสนั้นจะเป็นดังนี้: http://ideone.com/7Upza

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

ตัวอย่างเช่น

Object* o = gFactory->Create("Explosion");

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

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

คุณสามารถใช้หน่วยความจำที่มีการจัดการใน C ++ ด้วยตัวคุณเองดังนั้นเมื่อENTITY_DEATHมีการเรียกใช้สิ่งที่เกิดขึ้นคือจำนวนการอ้างอิงของมันลดลงหนึ่งรายการ

ในภายหลังตาม @John แนะนำที่การขอร้องของทุกเฟรมคุณสามารถตรวจสอบว่าเอนทิตีใดที่ไร้ประโยชน์ (ที่มีการอ้างอิงเป็นศูนย์) และลบออก ตัวอย่างเช่นคุณสามารถใช้boost::shared_ptr<T>( เอกสารที่นี่ ) หรือถ้าคุณใช้ C ++ 11 (VC2010)std::tr1::shared_ptr<T>

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

สิ่งที่เราทำในเกมคือใช้ตำแหน่งใหม่

SomeEvent* obj = new(eventPool.alloc()) new SomeEvent();

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

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

สิ่งนี้ทำให้เรามีความเร็วมากขึ้น

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