So verwenden Sie den CocosCreator-Objektpool

Vorwort:

Das Erstellen (cc.instantiate) und Löschen (node.destroy) von Knoten zur Laufzeit ist sehr leistungsintensiv. In komplexeren Szenen erstellen wir daher Knoten normalerweise nur in der Szeneninitialisierungslogik (onLoad) und löschen Knoten beim Wechseln der Szenen. Wenn wir ein Actionspiel mit einer großen Anzahl von Feinden oder Kugeln erstellen, die wiederholt generiert und zerstört werden müssen, wie können wir während des Spiels jederzeit Knoten erstellen und zerstören? Hier benötigen wir die Hilfe des Objektpools.

Ein Objektpool ist eine Gruppe wiederverwendbarer Knotenobjekte. Wir initialisieren einen Knotenobjektpool, indem wir eine Instanz von cc.NodePool erstellen. Wenn wir mehrere Prefabs haben, die instanziiert werden müssen, sollten wir normalerweise für jedes Prefab eine cc.NodePool-Instanz erstellen.

Wenn wir einen Knoten erstellen müssen, beantragen wir einen Knoten aus dem Objektpool. Wenn sich im Objektpool ein inaktiver Knoten befindet, wird der Knoten an den Benutzer zurückgegeben. Der Benutzer fügt den neuen Knoten über node.addChild dem Szenenknotenbaum hinzu.
Wenn wir einen Knoten zerstören müssen, rufen wir die Methode put(node) der Objektpoolinstanz auf und übergeben die zu zerstörende Knoteninstanz. Der Objektpool entfernt den Knoten automatisch aus dem Szenenknotenbaum und gibt ihn an den Objektpool zurück.

Dadurch wird das Recycling einiger Knoten erreicht.

Spezifische Operationen

Schritt 1: Vorbereiten des Fertigteils

Richten Sie die Knoten, die Sie erstellen möchten, im Voraus ein und machen Sie sie zu vorgefertigten Ressourcen. Einige von Ihnen wissen vielleicht nicht, wie man vorgefertigte Ressourcen erstellt?
(Ziehen Sie einfach die Ressourcen im Ressourcenmanager in den Hierarchiemanager und ziehen Sie dann die Knoten zurück in den Ressourcenmanager.)
Damit ist die Erstellung des Fertigteils abgeschlossen!

Schritt 2: Initialisieren des Objektpools

Im Initialisierungsskript des Szenenladens können wir die erforderliche Anzahl an Knoten erstellen und sie in den Objektpool einfügen:

Eigenschaften:
    enemyPrefab: cc.Prefab // Erforderliches Prefab},
beim Laden: Funktion () {
    // Objektpool erstellen this.enemyPool = new cc.NodePool();
    
    sei initCount = 5;
    für (lass i = 0; i < initCount; ++i) {
        let enemy = cc.instantiate(this.enemyPrefab); // Einen Knoten erstellen this.enemyPool.put(enemy); // Über die Put-Schnittstelle in den Objektpool einfügen}
}

Die Anzahl der im Objektpool benötigten Anfangsknoten kann entsprechend den Anforderungen des Spiels gesteuert werden. Es spielt keine Rolle, ob unsere Schätzung der Anzahl der Anfangsknoten ungenau ist, wir werden uns später darum kümmern.

Schritt 3: Anfordern eines Objekts aus dem Objektpool

Als nächstes können wir in unserem Laufzeitcode die folgende Methode verwenden, um die im Objektpool gespeicherten Objekte abzurufen:

createEnemy: Funktion (übergeordneter Knoten) {
    lass Feind = null;
    if (this.enemyPool.size() > 0) { // Benutze die Größenschnittstelle, um zu bestimmen, ob im Objektpool freie Objekte vorhanden sind // get(), um das Objekt abzurufen enemy = this.enemyPool.get();
        
    } else { // Wenn kein freies Objekt vorhanden ist, d. h. wenn nicht genügend Ersatzobjekte im Objektpool vorhanden sind, verwenden wir cc.instantiate, um „feind“ neu zu erstellen = cc.instantiate(this.enemyPrefab);
    }
    enemy.parent = parentNode; // Füge den generierten Feind zum Knotenbaum hinzu enemy.getComponent('Enemy').init(); // Als nächstes kannst du das Skript auf dem Feind aufrufen, um ihn zu initialisieren}

Der Schlüssel zur sicheren Verwendung des Objektpools besteht darin, immer die Größe zu verwenden, um zu bestimmen, ob ein Objekt verfügbar ist, bevor das Objekt abgerufen wird. Wenn nicht, verwenden Sie die normale Methode zum Erstellen von Knoten. Dies wird zwar etwas Laufzeitleistung verbrauchen, ist aber besser, als das Spiel zum Absturz zu bringen! Eine andere Möglichkeit besteht darin, get direkt aufzurufen. Wenn im Objektpool kein verfügbarer Knoten vorhanden ist, wird null zurückgegeben. In diesem Schritt ist es auch möglich, eine Beurteilung vorzunehmen.

Schritt 4: Das Objekt in den Objektpool zurückgeben

Wenn wir den Feind töten, müssen wir den feindlichen Knoten für die zukünftige Wiederverwendung in den Objektpool zurückgeben. Wir verwenden diese Methode:

onEnemyKilled: Funktion (Feind) {
    // Feind sollte ein cc.Node sein
    this.enemyPool.put(enemy); // Wie in der Initialisierungsmethode wird der Knoten in den Objektpool eingefügt. Diese Methode ruft auch die removeFromParent-Methode des Knotens auf.
}

Auf diese Weise haben wir einen vollständigen Zyklus abgeschlossen, und es spielt keine Rolle, wie viele Monster der Protagonist töten muss! Das Einfügen und Entfernen von Knoten in den und aus dem Objektpool verursacht keinen zusätzlichen Mehraufwand bei der Speicherverwaltung. Sie sollten daher versuchen, diesen Vorteil nach Möglichkeit auszunutzen.

Schritt 5: Verwenden Sie Komponenten, um Recycling- und Wiederverwendungsereignisse abzuwickeln

Wenn Sie den Konstruktor zum Erstellen eines Objektpools verwenden, können Sie einen Komponententyp oder -namen als die auf dem Knoten bereitgestellte Komponente angeben, um Knotenrecycling- und -wiederverwendungsereignisse zu verarbeiten.

Beim Erstellen eines Objektpools können Sie Folgendes verwenden:

 let menuItemPool = new cc.NodePool('MenuItem'); //Geben Sie einen Komponententyp an

Auf diese Weise wird, wenn menuItemPool.get() zum Abrufen des Knotens verwendet wird, die Wiederverwendungsmethode in MenuItem aufgerufen, um die Registrierung des Klickereignisses abzuschließen.
Wenn menuItemPool.put(menuItemNode) zum Wiederverwenden des Knotens verwendet wird, wird die unuse-Methode in MenuItem aufgerufen, um die Abmeldung des Klickereignisses abzuschließen.

cc.Klasse({
    erweitert: cc.Component,
    beim Laden: Funktion () {
        dieser.Knoten.ausgewählt = falsch;
        dieser.Knoten.auf(cc.Node.EventType.TOUCH_END, dieser.aufAuswahl, dieser.Knoten);
    },
    // put() ruft unuse auf, wenn der Objektpool zurückgefordert wird: function () {
        dieser.Knoten.aus(cc.Node.EventType.TOUCH_END, dieser.onSelect, dieser.Knoten);
    },
    // get() ruft reuse auf, wenn ein Objekt im Objektpool abgerufen wird: function () {
        dieser.Knoten.auf(cc.Node.EventType.TOUCH_END, dieser.aufAuswahl, dieser.Knoten);
    }
});

Darüber hinaus kann cc.NodePool.get() eine beliebige Anzahl von Parametern unterschiedlichen Typs übergeben, die unverändert an die Wiederverwendungsmethode übergeben werden:

// BulletManager.js
let myBulletPool = new cc.NodePool('Bullet'); //Einen Bullet-Objektpool erstellen let newBullet = myBulletPool.get(this); // Übergeben Sie die Manager-Instanz, um Bullets später im Bullet-Skript wiederzuverwenden // Bullet.js
wiederverwenden(BulletManager) {
    this.bulletManager = bulletManager; // Die in get übergebene Verwaltungsklasseninstanz}
Schlag () {
    this.bulletManager.put(this.node); // Aufzählungszeichen über die zuvor übergebene Verwaltungsklasseninstanz wiederherstellen}

Schritt 6: Objektpool leeren

Wenn die Knoten im Objektpool nicht mehr benötigt werden, können wir den Objektpool manuell löschen und alle darin zwischengespeicherten Knoten zerstören:

myPool.clear(); // Rufen Sie diese Methode auf, um den Objektpool zu löschen

Wenn auf die Objektpoolinstanz nirgendwo mehr verwiesen wird, zerstört und recycelt das Garbage Collection-System der Engine automatisch die Knoten im Objektpool. Der Zeitpunkt dieses Vorgangs ist jedoch unkontrollierbar. Darüber hinaus können Speicherlecks auftreten, wenn die Knoten von anderen Stellen referenziert werden. Daher ist es am besten, die Clear-Methode manuell aufzurufen, um die Cache-Knoten zu löschen, wenn Szenen gewechselt werden oder wenn der Objektpool nicht mehr benötigt wird.

Oben finden Sie Einzelheiten zur Verwendung des CocosCreator-Objektpools. Weitere Informationen zum CocosCreator-Objektpool finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!