Hallo,

Voor een spelletje gebruik ik een Loader object om bestanden in te laden (in dit geval 648 geluidsbestandjes).

Maar omdat er zoveel ingeladen moet worden crasht de website en loopt de browser vast (als het te lang duurt). Hoe los ik dit op?

Dit is het Loader object:

/**
 * @class Loader
 * @param {Client} parent
 */
var Loader = function Loader(parent)
{
	/**
	 * @returns {Array}
	 */
	this._imageDataList;

	/**
	 * @returns {Uint}
	 */
	this._imagesLoaded;

	/**
	 * @returns {Array}
	 */
	this._soundDataList;

	/**
	 * @returns {Uint}
	 */
	this._soundsLoaded;

	/**
	 * @returns {Client}
	 */
	this.parent;

	/**
	 * @constructor
	 */
	{
		/* Initialize image data list */
		this._imageDataList = [];

		/* Initialize images loaded */
		this._imagesLoaded = 0;

		/* Initialize sound data list */
		this._soundDataList = [];

		/* Initialize sounds loaded */
		this._soundsLoaded = 0;

		/* Initialize parent */
		this.parent = parent;
	};
};

/**
 * @method _loadImage
 * @syntax Loader._loadImage(imageData)
 * @param {Object} imageData
 * @returns {Loaded}
 * @private
 */
Loader.prototype._loadImage = function(imageData)
{
	/* Initialize self */
	var self = this;

	/* Create image */
	var image = jQuery('<img>');

	/* Set source */
	image.attr('src', imageData.path + imageData.name + '.' + imageData.extension);

	/* Set data path */
	image.attr('data-path', imageData.path);

	/* Set data name */
	image.attr('data-name', imageData.name);

	/* Set data extension */
	image.attr('data-extension', imageData.extension);

	/* Add event listener */
	image.one('load', function()
	{
		/* Increase images loaded */
		self._imagesLoaded++;

		/* Add asset */
		self.parent.assets.addImage(jQuery(this));
	});

	/* Return this */
	return this;
};

/**
 * @method _loadSound
 * @syntax Loader._loadSound(soundData)
 * @param {Object} soundData
 * @returns {Loaded}
 * @private
 */
Loader.prototype._loadSound = function(soundData)
{
	/* Initialize self */
	var self = this;

	/* Create sound */
	var sound = jQuery('<audio>');

	/* Loop trough list of extensions */
	for (var i = soundData.extensions.length - 1; i >= 0; i--)
	{
		/* Create source */
		var source = jQuery('<source>');

		/* Set source */
		source.attr('src', soundData.path + soundData.name + '.' + soundData.extensions[i]);

		/* Set data extension */
		source.attr('data-extension', soundData.extensions[i]);

		/* Append source to sound */
		sound.append(source);
	}

	/* Set data path */
	sound.attr('data-path', soundData.path);

	/* Set data name */
	sound.attr('data-name', soundData.name);

	/* Add event listener */
	sound.one('canplaythrough', function()
	{
		/* Increase sounds loaded */
		self._soundsLoaded++;

		/* Add asset */
		self.parent.assets.addSound(jQuery(this));
	});

	/* Return this */
	return this;
};

/**
 * @method _loadImages
 * @syntax Loader._loadImages()
 * @returns {Loader}
 * @private
 */
Loader.prototype._loadImages = function()
{
	/* Loop trough image data list */
	for (var i = this._imageDataList.length - 1; i >= 0; i--)
	{
		/* Load image */
		this._loadImage(this._imageDataList[i]);
	}

	/* Return this */
	return this;
};

/**
 * @method _loadSounds
 * @syntax Loader._loadSounds()
 * @returns {Loader}
 * @private
 */
Loader.prototype._loadSounds = function()
{
	/* Loop trough sound data list */
	for (var i = this._soundDataList.length - 1; i >= 0; i--)
	{
		/* Load sound */
		this._loadSound(this._soundDataList[i]);
	}

	/* Return this */
	return this;
};

/**
 * @method addImage
 * @syntax Loader.addImage(path, name, extension)
 * @param {String} path
 * @param {String} name
 * @param {String} extension
 * @returns {Loaded}
 * @public
 */
Loader.prototype.addImage = function(path, name, extension)
{
	/* Add image data to image data list */
	this._imageDataList.push(
	{
		path: path,
		name: name,
		extension: extension
	});

	/* Return this */
	return this;
};

/**
 * @method addSound
 * @syntax Loader.addSound(path, name, extension)
 * @param {String} path
 * @param {String} name
 * @param {Array} extensions
 * @returns {Loaded}
 * @public
 */
Loader.prototype.addSound = function(path, name, extensions)
{
	/* Add sound data to sound data list */
	this._soundDataList.push(
	{
		path: path,
		name: name,
		extensions: extensions
	});

	/* Return this */
	return this;
};

/**
 * @method progress
 * @syntax Loader.progress()
 * @returns {Uint}
 * @public
 */
Loader.prototype.progress = function()
{
	/* Calculate total */
	var total = (this._imageDataList.length + this._soundDataList.length);

	/* Calculate total loaded */
	var totalLoaded = this._imagesLoaded + this._soundsLoaded;

	/* Return progress */
	return ((100 / total) * totalLoaded).toFixed(2);
};

/**
 * @method run
 * @syntax Loader.run()
 * @returns {Loader}
 * @public
 */
Loader.prototype.run = function()
{
	/* Load images */
	this._loadImages();

	/* Load sounds */
	this._loadSounds();

	/* Return this */
	return this;
};
Geen idee hoe je het oplost, maar ik kan me wel voorstellen dat een browser crasht als er 648 geluidsbestanden moeten worden ingeladen. Kun je ze niet in "gedeeltes" inladen? Bijv. afhankelijk van het leven waar je in zit? En heb je echt 648 geluiden nodig op 1 pagina?
Ik heb het nodig voor een Habbo fansite, Habbo had vroeger een trax player waarbij je met verschillende stukjes muziek, zelf een lied in elkaar kon zetten. Dit wil ik dus proberen te maken.

En ik heb nog eens goed gekeken en ik denk inderdaad dat de browser crasht omdat er in 1 keer 648 requests worden gedaan. Zou het helpen als ik een queue maak en de bestanden 1 voor 1 laadt? Dan wordt het volgende bestand pas geladen als het vorige bestand het event 'load' fired.
Ze zijn (precies) rond de 1 en 6 seconden volgens mij. Als ik hier 1 bestand van maak, laadt deze dan sneller dan als ik ze apart laad?

Edit:
Het werkt in Chrome, maar Firefox stopt al met laden na 2 bestanden, ook als ik maar 10 bestanden wil downloaden. Ik download ze 1 voor 1 (de volgende wordt geladen bij sound.one('canplaythrough', function() { // download nieuwe });

Weet iemand nog een andere manier die wél in alle browsers werkt?
Waarom laad je ze niet pas in wanneer mensen ze selecteren? Kan me niet voorstellen dat er een enorme vertraging plaatsvindt wanneer de duur van de fragmenten 1 tot 6 seconden is.
Dat zou kunnen, maar ik heb ook nog afbeeldingen die ik wél van te voren moet laden. Dit zijn er ook nogal wat en Firefox crasht of wordt heel traag wanneer ik afbeeldingen preload. Doe ik misschien iets verkeerd? Heeft iemand een tutorial / voorbeeld / plugin die ik kan gebruiken?
Afbeeldingen gewoon inladen met CSS geprobeerd? Moeten we heel veel zijn wil dat voor grote vertraging zorgen.
Ik zou zeggen probeer mijn idee gewoon eens. Je hoeft enkel even ergens een wat groter geluidsbestand te downloaden en dit dan opnemen in je webpagina en dan een fragment ervan laten afspelen.

Reageren