Recarrega de jogos ou trava no iPhone ao carregar ativos de vários pacotes remotos (Cocos Creator v3.8.1) – Cocos Creator

Olá pessoal,

Estou desenvolvendo um jogo usando Cocos Creator v3.8.1direcionando os dois nativo e Html5 plataformas.
O jogo está dividido em 29 pacotes remotoscada um representando um mini -jogo. Os tamanhos dos pacotes variam de 128,6 kb a 20 mb.

Durante a jogabilidade:

• Carrego todos os ativos de um pacote quando um mini -jogo é aberto e, depois disso, carrego ativos do próximo pacote para mudar para um mini -jogo diferente.
• Esse processo continua com carga – comutador – carga.

• Sobre navegadores móveis (Safari/Chrome) e aplicativo nativo (iPhone 8 Plus), o jogo também recarregam ou acidentes Depois de carregar ativos de cerca de 10 pacotes. No entanto, o número exato de pacotes é incerto e as possibilities de o acidente/recarregar ocorrências aumentam com os mais ativos carregados.
• Dispositivo de teste usado: iPhone 8 Plus (iOS mais antigo).
• Testes em Android (nota 9) ter Sem problemas.

loadAny(...args: any()): Promise {
    return new Promise(async (resolve, reject) => {
        strive {
            let (property, choices, onProgress, onComplete) = args;
            choices = choices ?? {};  // If choices will not be supplied, initialize as an empty object
            const loadPromises = property.map((assetsInfo) => {
                return new Promise((res, rej) => {
                    const { bundle } = assetsInfo;
                    ResourceMap.log(`(ResourceMap) loadAny assetsInfo`, assetsInfo);
                    if (bundle && bundle.size > 0 && cc(`settings`).querySettings("property", "projectBundles").consists of(bundle)) {
                        this.loadBundle(bundle).then(() => {
                            res(assetsInfo);
                        }).catch((err) => {
                            ResourceMap.error(`(ResourceMap) loadAny err`, err);
                            res(null);
                        });
                    } else {
                        res(assetsInfo);
                    }
                });
            });
            // Look forward to all guarantees to finish
            let outcomes = await Promise.all(loadPromises);
            // Filter out any null outcomes
            property = outcomes.filter(outcome => outcome !== null) as AssetManager.Bundle();
            // After preloading completes, transfer to the loading section
            await this.loadAssetsInParallel(property, choices, (loaded, whole) => {
                if (onProgress) {
                    onProgress(loaded, whole); // Ahead progress throughout preload section
                }
            }, (err, outcomes) => {
                if (err) {
                    if (onComplete) {
                        onComplete(err); // Full callback after loading
                    }
                    resolve(outcomes); // Resolve with the information after each preloading and loading
                } else {
                    if (onComplete) {
                        onComplete(null, outcomes); // Full callback after loading
                    }
                    resolve(outcomes); // Resolve with the information after each preloading and loading
                }
            });
        } catch (error) {
            reject(error); // Reject the promise in case of any error
        }
    });
}
loadAssetsInParallel(property, choices, onProgress, onComplete) {
        let whole = property.size;
        let loaded = 0;
        const assetLoadingPromises = property.map((asset) => {
            return new Promise((resolve, reject) => {
                if (this.uuidMap.has(asset.uuid)) {
                    loaded++;
                    if (onProgress) {
                        onProgress(loaded, whole); // Ahead progress throughout preload section
                    }
                    resolve({ asset: this.uuidMap.get(asset.uuid), information: asset }); // Resolve the promise as soon as the asset is loaded
                } else {
                    assetManager.loadAny(asset, choices, (loaded, whole, merchandise) => {
                        ResourceMap.log(`(ResourceMap) loadAny uuid: ${merchandise.uuid}, path: ${merchandise.url}, bundle: ${merchandise('config').title}, kind: ${js.getClassName(merchandise?.information?.('ctor'))}`);
                    }, (err, knowledge) => {
                        loaded++;
                        if (onProgress) {
                            onProgress(loaded, whole); // Ahead progress throughout preload section
                        }
                        if (err) {
                            ResourceMap.error(`(ResourceMap) loadAny err`, err);
                            resolve(null); // Resolve with null in case of an error
                            return;
                        }
                        resolve({ asset: knowledge, information: asset }); // Resolve the promise as soon as the asset is loaded
                    });
                }
            });
        });

        strive {
            let knowledge = await Promise.all(assetLoadingPromises);
            knowledge = knowledge.filter(outcome => outcome !== null);
            let outcomes = ();
            knowledge.forEach((v) => {
                let a = v.asset;
                if (Array.isArray(a)) {
                    a.forEach((_v) => {
                        outcomes.push(_v);
                        this.updateUUIDMap(_v);
                    });
                } else {
                    outcomes.push(a);
                    this.updateUUIDMap(a);
                }
            });

            if (onComplete) {
                onComplete(null, outcomes); // Full callback after loading
            }
            return outcomes;
        } catch (err) {
            ResourceMap.error(`(ResourceMap) loadAny An error occurred throughout parallel asset loading:`, err);
            if (onComplete) {
                onComplete(err, null);
            }
        }
    }

1. Alguém já teve problemas semelhantes ao carregar ativos de muitos pacotes remotos no iOS?

2. Isso poderia ser devido às limitações de memória do iOS (Baixa RAM ou Restrições de View/Navegador Net)?

3. Existem otimizações para carregar/descarregar ativos para evitar recarga/falhas?

4. Como devo reconsiderar os pacotes divididos para um projeto com muitos mini -jogos?

Quaisquer dicas, pensamentos ou apenas me apontar na direção certa significariam muito. Desde já, obrigado!