aotrautils 0.0.1068 → 0.0.1069

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:15)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (19/02/2025-23:41:19)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -1551,6 +1551,13 @@ aotest.profile=function(rootObject,methodName,visited=[]){
 
 
 
+//================================================================
+//================= Tjread control utility methods =================
+//================================================================
+
+
+window.sleep = (millis) => new Promise( resolve => setTimeout(resolve, millis) );
+
 
 
 //================================================================
@@ -1988,6 +1995,15 @@ window.compare=function(value1,value2){
 	if(value1==value2)	return 0;
 }
 
+window.pushInArrayAsQueue=function(array, maxSize, item){
+	if(maxSize<=getArraySize(array)){
+		array.shift();
+	}
+	array.push(item);
+	return item;
+}
+
+
 
 /*KNOWN LIMITATIONS : You will have an incomplete browsing loop if there are the string values "break" or "continue" in your array or associative array !*/
 // CAUTION : Only use «return foreach» syntax in client code loops with SINGLE-LEVEL nested loops ONLY !
@@ -1998,7 +2014,7 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 //  -1: if(a<b)
 //   1: if(a>b)
 	// for instance this is a valid javascript compare function : function(a, b){return a-b} so (100,20) returns positive result and (20,100) returns negative result !
-	/*OPTIONAL*/compareFunction=null){
+	/*OPTIONAL*/compareFunction=null, sortKeys=false){
 	
 	// TODO : FIXME : Add the possibility to iterate over a string characters ?
 	
@@ -2054,7 +2070,8 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 	
 	// Else : associative array
 	
-	var associativeArray=arrayOfValues;
+	let keysToIterateOn=[];
+	const associativeArray=arrayOfValues;
 	if(compareFunction){
 		
 //	if(!associativeArray.hasOwnProperty){
@@ -2075,24 +2092,26 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 		}
 		sortedKeysAndValues.sort(compareFunction);
 		
-		associativeArray={};
+		// OLD : associativeArray={};
 		for(var i=0;i<sortedKeysAndValues.length;i++){
 			var item=sortedKeysAndValues[i];
-			associativeArray[item.key]=item.value;
+			// OLD : associativeArray[item.key]=item.value;
+			keysToIterateOn.push(item.key);
 		}
 		
+	}else{
+		keysToIterateOn=Object.keys(associativeArray);
 	}
 
-//if(!associativeArray.hasOwnProperty){
-//	// TRACE
-//	console.log("WARN : Object of type «"+(typeof(associativeArray))+"» has no method hasOwnProperty() method, cannot perform foreach ! ",associativeArray);
-//	return null;
-//}
-	
+	if(!compareFunction && sortKeys){
+		keysToIterateOn=keysToIterateOn.sort();
+	}
+		
 	var cnt=0;
-	for(var key in associativeArray){
+	for(var key of keysToIterateOn){
 		if(associativeArray.hasOwnProperty && !associativeArray.hasOwnProperty(key))	continue;
 		var item=associativeArray[key];
+		
 		if(!compareFunction){ // If we have a compare function, then array is already filtered !
 			if(filterFunction && !filterFunction(item,key))	continue;
 		}
@@ -2108,6 +2127,8 @@ window.foreach=function(arrayOfValues,doOnEachFunction,
 		}// else continue looping...
 		cnt++;
 	}
+		
+	
 	
 	//
 	return null;
@@ -2124,7 +2145,7 @@ window.getAt=function(associativeOrNormalArray,index,returnKey=false){
 	return foreach(associativeOrNormalArray,(item, key)=>{
 		if(index<=i)	return returnKey?key:item;
 		i++;
-	});
+	},null,null,returnKey);
 }
 
 window.getFirst=function(associativeOrNormalArray){
@@ -2856,24 +2877,46 @@ Math.averageInArray=function(arrayOfValues){
 	return Math.sumInArray(arrayOfValues) / arrayOfValues.length;
 };
 
-Math.maxInArray=function(arrayOfValues){
+Math.maxInArray=function(arrayOfValues, returnKey=false){
 	if(empty(arrayOfValues))
 		return null;
-	var max=arrayOfValues[0];
-	for (var i=0; i<arrayOfValues.length; i++)
-		if(max<arrayOfValues[i])
-			max=arrayOfValues[i];
-	return max;
+		
+//	var max=arrayOfValues[0];
+//	for (var i=0; i<arrayOfValues.length; i++)
+//		if(max<arrayOfValues[i])
+//			max=arrayOfValues[i];
+	
+	let returnedKey=getKeyAt(arrayOfValues,0);
+	let max=getAt(arrayOfValues,0);
+	foreach(arrayOfValues,(item, key)=>{
+		if(max<item){
+			returnedKey=key;
+			max=item;
+		}
+	},null,null,true);
+	
+	return (returnKey?returnedKey:max);
 };
 
-Math.minInArray=function(arrayOfValues){
+Math.minInArray=function(arrayOfValues, returnKey=false){
 	if(empty(arrayOfValues))
 		return null;
-	var min=arrayOfValues[0];
-	for (var i=0; i<arrayOfValues.length; i++)
-		if(arrayOfValues[i]<min)
-			min=arrayOfValues[i];
-	return min;
+		
+//	var min=arrayOfValues[0];
+//	for (var i=0; i<arrayOfValues.length; i++)
+//		if(arrayOfValues[i]<min)
+//			min=arrayOfValues[i];
+	
+	let returnedKey=getKeyAt(arrayOfValues,0);
+	let min=getAt(arrayOfValues,0);
+	foreach(arrayOfValues,(item, key)=>{
+		if(item<min){
+			returnedKey=key;
+			min=item;
+		}
+	},null,null,true);
+	
+	return (returnKey?returnedKey:min);
 };
 
 
@@ -5248,6 +5291,25 @@ window.stringifyObject=function(objectToStringify){
 }
 
 
+window.splitURL=(urlOrigin)=>{
+	let protocol=null;
+	let hostAndPort=urlOrigin;
+	if(contains(urlOrigin,"://")){
+		const hostAndPortSplits=urlOrigin.split("://");
+		protocol=hostAndPortSplits[0];
+		hostAndPort=hostAndPortSplits[1];
+	}
+	let host=null, port=null;
+	if(contains(hostAndPort,":")){
+		const splits=hostAndPort.split(":");
+		host=splits[0];
+		port=splits[1];
+	}else{
+		host=hostAndPort;
+	}
+	const isSecure=(protocol && contains(protocol,"s"));
+	return {protocol:protocol, host:host, port:port, isSecure:isSecure};
+};
 
 
 
@@ -5259,7 +5321,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils CLIENT library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:15)»*/
+/*utils CLIENT library associated with aotra version : «1_29072022-2359 (19/02/2025-23:41:19)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -8868,7 +8930,7 @@ getColorFingersPointer=(mediaHandler,colorsPattern="rgb")=>{
 
 
 
-//Sound handling :
+// ====================================================== Sound handling ======================================================
 
 
 function playAudioData(audioData,audioCtxParam=null,audioBufferSizeParam=null,numberOfAudioChannelsParam=null,sampleRateParam=null,
@@ -8947,335 +9009,340 @@ function playAudioData(audioData,audioCtxParam=null,audioBufferSizeParam=null,nu
 }
 
 
+class SoundsLoop{
+	constructor(doOnEnded=null){
 
-
-function loadSoundsLoop(filesPaths,doOnLoaded=null,doOnEnded=null){
+		this.doOnEnded=doOnEnded;
+		
+		this.audios=null;
+		this.currentAudio=null;
+		this.hasAbortedLooping=false;
+		this.hasLoopStarted=false;
+		this.volume=1;
+		this.mainLoopSound=null;
+		this.started=false;
 	
-	let self={
-			
-			audios:null,
-			currentAudio:null,
-			hasAbortedLooping:false,
-			hasLoopStarted:false,
-			volume:1,
-			mainLoopSound:null,
-			started:false,
-			setVolume:function(newVolume=null){
-				if(newVolume)	self.volume=newVolume;
-				return self;
-			},
-			loop:function(pauseMillis=null,fadeInMillis=null,fadeOutMillis=null){
-				
-				self.currentAudio=Math.getRandomInArray(self.audios);
-				self.currentAudio.setVolume(self.volume);
-
-				
-				let startChainedLoop=function(){
-					
-					if(!self.started)	return;
-					
-					if(fadeInMillis && fadeOutMillis){
-						if(fadeInMillis){
-							self.currentAudio.fadeIn(fadeInMillis);
-						}
-						if(fadeOutMillis){
-							self.currentAudio.fadeOut(fadeOutMillis,function(){
-								
-								// The next one to loop :
-								if(self.started)	self.loop(pauseMillis,fadeInMillis,fadeOutMillis);
-								if(doOnEnded)	doOnEnded(self);
-								
+	}
 
-							});
-						}
-						
-						
-					}else{
-						if(!fadeInMillis){
-							self.currentAudio.jumpIn();
-						}
-						if(!fadeOutMillis){
-							self.currentAudio.jumpOut(function(){
-										
-									// The next one to loop : (the same, loop on itself)
-									if(self.started)	self.loop(pauseMillis,fadeInMillis,fadeOutMillis);
-									if(doOnEnded)	doOnEnded(self);
+	setVolume(newVolume=null){
+		if(newVolume)	this.volume=newVolume;
+		return this;
+	}
+	loop(pauseMillis=null,fadeInMillis=null,fadeOutMillis=null){
+		
+		this.currentAudio=Math.getRandomInArray(this.audios);
+		this.currentAudio.setVolume(this.volume);
 
-								}
-							);
-						}
-						
+		this.pauseMillis=pauseMillis;
+		this.fadeInMillis=fadeInMillis;
+		this.fadeOutMillis=fadeOutMillis;
+		
+		// If it is the first time of the loop then there is no delay at the start:
+		// or if we have no pause between loopings :
+		this.started=true;
+		if(!this.hasLoopStarted || !this.pauseMillis){
+			this.startChainedLoop();
+		}else{
+			this.mainLoopSound=getTimer(this.startChainedLoop,this.pauseMillis);
+		}
+		
+		return this;
+	}
+	
+	/*private*/startChainedLoop(){
+		if(!this.started)	return;
+		
+		const self=this;
+		if(this.fadeInMillis && this.fadeOutMillis){
+			if(this.fadeInMillis){
+				this.currentAudio.fadeIn(this.fadeInMillis);
+			}
+			if(this.fadeOutMillis){
+				this.currentAudio.fadeOut(this.fadeOutMillis,()=>{
+					// The next one to loop :
+					if(self.started)		self.loop(self.pauseMillis,self.fadeInMillis,self.fadeOutMillis);
+					if(self.doOnEnded)	self.doOnEnded(self);
+				});
+			}
+			
+		}else{
+			if(!this.fadeInMillis){
+				this.currentAudio.jumpIn();
+			}
+			if(!this.fadeOutMillis){
+				this.currentAudio.jumpOut(()=>{
+						// The next one to loop : (the same, loop on itself)
+						if(self.started)		self.loop(self.pauseMillis,self.fadeInMillis,self.fadeOutMillis);
+						if(self.doOnEnded)	self.doOnEnded(self);
 					}
+				);
+			}
+		}
 
-					self.hasLoopStarted=true;
-				};
-				
-				// If it is the first time of the loop then there is no delay at the start:
-				// or if we have no pause between loopings :
-				self.started=true;
-				if(!self.hasLoopStarted || !pauseMillis){
-					startChainedLoop();
-				}else{
-					self.mainLoopSound=getTimer(startChainedLoop,pauseMillis);
-				}
-				
-				return self;
-			},
-			stopPlaying:function(){
-				// To prevent starting treatments after the loading has occurred after the loop has been stopped !
-				// (rare case when the loading is so long that the user has aborted the loop before all loop files has been loaded !)
-				if(!self.audios)	self.hasAbortedLooping=true;
-				// (It is necessarily a loop !)
-				self.started=false;
-				if(self.mainLoopSound)	self.mainLoopSound.clear();
-				if(self.currentAudio)	self.currentAudio.stopPlaying();
-				return self;
-			},
-			
-			
-	};
+		this.hasLoopStarted=true;
+	}
+	
+	
+	stopPlaying(){
+		// To prevent starting treatments after the loading has occurred after the loop has been stopped !
+		// (rare case when the loading is so long that the user has aborted the loop before all loop files has been loaded !)
+		if(!this.audios)	this.hasAbortedLooping=true;
+		// (It is necessarily a loop !)
+		this.started=false;
+		if(this.mainLoopSound)	this.mainLoopSound.clear();
+		if(this.currentAudio)	this.currentAudio.stopPlaying();
+		return this;
+	}
+	
+}
+
+function loadSoundsLoop(filesPaths,doOnLoaded=null,doOnEnded=null){
 	
+	const selfSoundsLoop=new SoundsLoop(doOnEnded);
 	
 	let audios=[];
 	let numberLoaded=0;
 	foreach(filesPaths,(filePath)=>{
-		audios.push( loadSound(filePath,function(){
+		audios.push( loadSound(filePath,function(selfParam/*UNUSED*/){
 			
 			numberLoaded++
 			if(doOnLoaded && numberLoaded==filesPaths.length){
 				
 				// Once all have been loaded :
-				self.audios=audios;
+				selfSoundsLoop.audios=audios;
 
 				// To prevent starting treatments after the loading has occurred after the loop has been stopped !
 				// (rare case when the loading is so long that the user has aborted the loop before all loop files has been loaded !)
-				if(!self.hasAbortedLooping)		doOnLoaded(self);
+				if(!selfSoundsLoop.hasAbortedLooping)		doOnLoaded(selfSoundsLoop);
 				
 			}
 			
 		}) );
 	});
 	
-	
-	return self;
+	return selfSoundsLoop;
 }
 
 
 
+const FADE_REFRESH_MILLIS=500;
 
-function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
+class Sound{
+	constructor(filePath,doOnEnded=null){
+
+		this.doOnEnded=doOnEnded;
 	
-	const FADE_REFRESH_MILLIS=500;
+		this.nativeAudioElement=new Audio(filePath);
+		this.isLoop=false;
+		this.hasLoopStarted=false;
+		this.isReady=false;
+		this.speed=1;
+		this.volume=1;
+		this.isPlaying=false;
+		this.mainLoopSound=null;
+		
+	}
 	
 	
-	let self={
-		nativeAudioElement:new Audio(filePath),
-		isLoop:false,
-		hasLoopStarted:false,
-		isReady:false,
-		speed:1,
-		volume:1,
-		isPlaying:false,
-		mainLoopSound:null,
-		setVolume:function(newVolume=null){
-			if(newVolume)	self.volume=newVolume;
-			self.nativeAudioElement.volume=self.volume;
-			return self;
-		},
-		setSpeed:function(newSpeed=null){
-			if(newSpeed)	self.speed=newSpeed;
-			self.nativeAudioElement.playbackRate=self.speed;
-			return self;
-		},
-		play:function(){
-			if(!self.nativeAudioElement.paused)	return self;
-			self.nativeAudioElement.play().then(()=>{
-				self.isPlaying=true;
-			});
-			return self;
-		},
-		pause:function(){
-			if(self.nativeAudioElement.paused || !self.isPlaying)	return self;
-			self.nativeAudioElement.pause();
-			self.isPlaying=false;
-			return self;
-		},
-		resumeLoop:function(){
-			if(!self.isLoop || !self.mainLoopSound)	return self;
-			self.mainLoopSound.resume();
-			self.play();
-			return self;
-		},
-		pauseLoop:function(){
-			if(!self.isLoop || !self.mainLoopSound || !self.isPlaying)	return self;
-			self.mainLoopSound.pause();
-			self.pause();
-			return self;
-		},
+	setVolume(newVolume=null){
+		if(newVolume)	this.volume=newVolume;
+		this.nativeAudioElement.volume=this.volume;
+		return this;
+	}
+	setSpeed(newSpeed=null){
+		if(newSpeed)	this.speed=newSpeed;
+		this.nativeAudioElement.playbackRate=this.speed;
+		return this;
+	}
+	play(){
+		if(!this.nativeAudioElement.paused)	return this;
+		this.nativeAudioElement.play().then(()=>{
+			this.isPlaying=true;
+		});
+		return this;
+	}
+	pause(){
+		if(this.nativeAudioElement.paused || !this.isPlaying)	return this;
+		this.nativeAudioElement.pause();
+		this.isPlaying=false;
+		return this;
+	}
+	resumeLoop(){
+		if(!this.isLoop || !this.mainLoopSound)	return this;
+		this.mainLoopSound.resume();
+		this.play();
+		return this;
+	}
+	pauseLoop(){
+		if(!this.isLoop || !this.mainLoopSound || !this.isPlaying)	return this;
+		this.mainLoopSound.pause();
+		this.pause();
+		return this;
+	}
+	
+	startPlaying(){
+		if(this.isLoop){
+			this.loop();
+		}else{
+			this.play();
+		}
+	}
+	
+	setIsLoop(isLoop){
+		this.isLoop=isLoop;
+		return this;
+	}
+	
+	stopPlaying(){
+		// NO : We have to stop the audio file even if it's looping :
+		// TODO : FIXME : FIND A BETTER WAY !!
+		this.pause();
+		this.nativeAudioElement.currentTime=0;
+		if(this.isLoop && this.mainLoopSound){
+			this.hasLoopStarted=false;
+			this.mainLoopSound.clear();
+		}
+		return this;
+	}
+	
+	loop(pauseMillis=null,fadeInMillis=null,fadeOutMillis=null){
+
+		if(!this.isLoop)	return this;
 		
-		startPlaying:function(){
-			if(self.isLoop){
-				self.loop();
-			}else{
-				self.play();
-			}
-		},
+		// At this point, this.isLoop is necessarily true
+
+		// Some of the more commonly used properties of the audio element include : 
+		// src, currentTime, duration, paused, muted, and volume
+		this.pauseMillis=pauseMillis;
+		this.fadeInMillis=fadeInMillis;
+		this.fadeOutMillis=fadeOutMillis;
 		
-		setIsLoop:function(isLoop){
-			self.isLoop=isLoop;
-			return self;
-		},
+		// If it is the first time of the loop then there is no delay at the start:
+		if(!this.hasLoopStarted || !this.pauseMillis){
+			this.startChainedLoop();
+		}else{
+			this.mainLoopSound=getTimer(this.startChainedLoop, this.pauseMillis);
+		}
 		
-		stopPlaying:function(){
-			// NO : We have to stop the audio file even if it's looping :
-			// TODO : FIXME : FIND A BETTER WAY !!
-			self.pause();
-			self.nativeAudioElement.currentTime=0;
-			if(self.isLoop && self.mainLoopSound){
-				self.hasLoopStarted=false;
-				self.mainLoopSound.clear();
-			}
-			return self;
-		},
+		return this;
+	}
+	
+	/*private*/startChainedLoop(){
 		
-		loop:function(pauseMillis=null,fadeInMillis=null,fadeOutMillis=null){
-
-			if(!self.isLoop)	return self;
-			
-			// At this point, self.isLoop is necessarily true
+		const self=this;
+		if(this.fadeInMillis && this.fadeOutMillis){
+			if(this.fadeInMillis){
+				this.fadeIn(this.fadeInMillis);
+			}
+			if(this.fadeOutMillis){
+				this.fadeOut(this.fadeOutMillis,()=>{
+					// The next one to loop : (the same, loop on itself)
+					self.loop(self.pauseMillis,self.fadeInMillis,self.fadeOutMillis);
+					if(self.doOnEnded)	self.doOnEnded(self);
+				});
+			}
+		}else{
+			if(!this.fadeInMillis){
+				this.jumpIn();
+			}
+			if(!this.fadeOutMillis){
+				this.jumpOut(()=>{
+						// The next one to loop : (the same, loop on itself)
+						self.loop(self.pauseMillis,self.fadeInMillis,self.fadeOutMillis);
+						if(self.doOnEnded)	self.doOnEnded(self);
+					}
+				);
+			}
+		}
 
-			// Some of the more commonly used properties of the audio element include : 
-			// src, currentTime, duration, paused, muted, and volume
+		this.hasLoopStarted=true;
+	}
+	
+	jumpIn(){
+		this.nativeAudioElement.currentTime=0;
+		this.play();
+	}
+	fadeIn(durationMillis){
 
-			let startChainedLoop=function(){
-				
-				if(fadeInMillis && fadeOutMillis){
-					if(fadeInMillis){
-						self.fadeIn(fadeInMillis);
-					}
-					if(fadeOutMillis){
-						self.fadeOut(fadeOutMillis,function(){
-							
-							// The next one to loop : (the same, loop on itself)
-							self.loop(pauseMillis,fadeInMillis,fadeOutMillis);
-							if(doOnEnded)	doOnEnded(self);
+		this.nativeAudioElement.currentTime=0;
+		// We have to bypass the setVolume method here !
+		this.nativeAudioElement.volume=0;
+		
+		let timeRatio=FADE_REFRESH_MILLIS/durationMillis;
+		let volumeStep=timeRatio;
+		
+		const self=this;
+		this.fadeRoutine=setInterval(()=>{
+			// We have to bypass the setVolume method here !
+			self.nativeAudioElement.volume=Math.min(self.volume,
+					// and here too :
+					self.nativeAudioElement.volume+volumeStep);
+		},FADE_REFRESH_MILLIS);
+		
+		setTimeout(()=>{ clearInterval(self.fadeRoutine); },durationMillis);
+		
+		this.play();
+		
+		return this;
+	}
+	
+	jumpOut(doOnEndJump=null){
 
-						});
-					}
-				}else{
-					if(!fadeInMillis){
-						self.jumpIn();
-					}
-					if(!fadeOutMillis){
-						self.jumpOut(function(){
-								// The next one to loop : (the same, loop on itself)
-								self.loop(pauseMillis,fadeInMillis,fadeOutMillis);
-								if(doOnEnded)	doOnEnded(self);
-							}
-						);
-					}
-					
-				}
+		const self=this;		
+		this.mainLoopSound=getTimer(()=>{
+			self.pause();
+			if(doOnEndJump)	doOnEndJump(self);
+		},this.nativeAudioElement.duration*1000);
+		
+		return this;
+	}
+	
+	fadeOut(durationMillis,doOnEndFade=null){
 
-				self.hasLoopStarted=true;
-			};
-			
-			// If it is the first time of the loop then there is no delay at the start:
-			if(!self.hasLoopStarted || !pauseMillis){
-				startChainedLoop();
-			}else{
-				self.mainLoopSound=getTimer(startChainedLoop, pauseMillis);
-			}
-				
+		const self=this;
+		setTimeout(()=>{
 			
-			return self;
-		},
-		jumpIn:function(){
-			self.nativeAudioElement.currentTime=0;
-			self.play();
-		},
-		fadeIn:function(durationMillis){
-
-			self.nativeAudioElement.currentTime=0;
 			// We have to bypass the setVolume method here !
-			self.nativeAudioElement.volume=0;
+			self.nativeAudioElement.volume=self.volume;
 			
 			let timeRatio=FADE_REFRESH_MILLIS/durationMillis;
 			let volumeStep=timeRatio;
 			
 			self.fadeRoutine=setInterval(()=>{
 				// We have to bypass the setVolume method here !
-				self.nativeAudioElement.volume=Math.min(self.volume,
+				self.nativeAudioElement.volume=Math.max(0,
 						// and here too :
-						self.nativeAudioElement.volume+volumeStep);
+						self.nativeAudioElement.volume-volumeStep);
 			},FADE_REFRESH_MILLIS);
 			
-			setTimeout(()=>{
-				clearInterval(self.fadeRoutine);
-			},durationMillis);
-			
-			self.play();
-			
-			return self;
-		},
+		},(this.nativeAudioElement.duration*1000-durationMillis));
 		
+		this.mainLoopSound=getTimer(()=>{
+			clearInterval(self.fadeRoutine);
+			self.pause();
+			if(doOnEndFade)	doOnEndFade(self);
+		},this.nativeAudioElement.duration*1000);
 		
-		jumpOut:function(doOnEndJump=null){
-			
-			self.mainLoopSound=getTimer(()=>{
-				
-				self.pause();
-				
-				if(doOnEndJump)	doOnEndJump(self);
-				
-			},self.nativeAudioElement.duration*1000);
-			
-			return self;
-		},
-		
-		fadeOut:function(durationMillis,doOnEndFade=null){
+		return this;
+	}
+	
+	isFinished(){
+		return (this.nativeAudioElement.currentTime===this.nativeAudioElement.duration);
+	}
+	
+}
 
-			setTimeout(()=>{
-				
-				// We have to bypass the setVolume method here !
-				self.nativeAudioElement.volume=self.volume;
-				
-				let timeRatio=FADE_REFRESH_MILLIS/durationMillis;
-				let volumeStep=timeRatio;
-				
-				self.fadeRoutine=setInterval(()=>{
-					// We have to bypass the setVolume method here !
-					self.nativeAudioElement.volume=Math.max(0,
-							// and here too :
-							self.nativeAudioElement.volume-volumeStep);
-				},FADE_REFRESH_MILLIS);
-				
-			},(self.nativeAudioElement.duration*1000-durationMillis));
-			
-			self.mainLoopSound=getTimer(()=>{
-				clearInterval(self.fadeRoutine);
-				
-				self.pause();
-				
-				if(doOnEndFade)	doOnEndFade(self);
-				
-			},self.nativeAudioElement.duration*1000);
-			
-			
-			return self;
-		},
-		
-		isFinished:function(){
-			return (self.nativeAudioElement.currentTime===self.nativeAudioElement.duration);
-		}
-	};
+
+function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
 	
-		self.nativeAudioElement.addEventListener("loadeddata", () => {
-			// Some of the more commonly used properties of the audio element include : 
-			// src, currentTime, duration, paused, muted, and volume
-			self.isReady=true;
-			if(doOnLoaded)		doOnLoaded(self);
-		});
+	let self=new Sound(filePath,doOnEnded);
+
+	self.nativeAudioElement.addEventListener("loadeddata", () => {
+		// Some of the more commonly used properties of the audio element include : 
+		// src, currentTime, duration, paused, muted, and volume
+		self.isReady=true;
+		if(doOnLoaded)		doOnLoaded(self);
+	});
 	
 	if(!self.isLoop && doOnEnded){
 		self.nativeAudioElement.addEventListener("onended", () => {
@@ -9285,7 +9352,6 @@ function loadSound(filePath,doOnLoaded=null,doOnEnded=null){
 		});
 	}
 	
-	
 	return self;
 }
 
@@ -9405,427 +9471,388 @@ function drawImageAndCenterWithZooms(ctx,image,xParam=0,yParam=0,zooms={zx:1,zy:
 
 
 
+// ====================================================== SPRITES ======================================================
 
 
-
-
-function getSpriteMonoThreaded(imagesPool,/*OPTIONAL*/refreshMillis=null,
+class SpriteMonoThreaded{
+	
+	constructor(imagesPool,/*OPTIONAL*/refreshMillis=null,
 		clipSize={w:100,h:100},scaleFactorW=1,scaleFactorH=1,
 		orientation="horizontal",xOffset=0,yOffset=0,isLoop=true,isRandom=false,
 		center={x:"left",y:"top"},
 		zoomsParam={zx:1,zy:1}){
-
-	
-	// Two-states : started, stopped.
-	
-	const isClip=!!clipSize;
-
-	
-	let self= {
-	
-		center:center,
-		imagesPool:imagesPool,
-		scaleFactorW:scaleFactorW,
-		scaleFactorH:scaleFactorH,
-		xOffset:xOffset,
-		yOffset:yOffset,
-		zooms:nonull(zoomsParam,{zx:1,zy:1}),
+		
+		this.center=center;
+		this.imagesPool=imagesPool;
+		this.scaleFactorW=scaleFactorW;
+		this.scaleFactorH=scaleFactorH;
+		this.xOffset=xOffset;
+		this.yOffset=yOffset;
+		this.isLoop=isLoop;
+		this.zooms=nonull(zoomsParam,{zx:1,zy:1});
 		
 		// Clip only attributes:
-		clipSize:(isClip?clipSize:null),
+		this.isClip=(!!clipSize);
+		this.clipSize=(this.isClip?clipSize:null);
 //		width:imagesPool.width,
 //		height:imagesPool.height,
-		index:0,
-		framesNumber:( isClip?(orientation==="horizontal" ? Math.trunc(imagesPool.width/clipSize.w) : Math.trunc(imagesPool.height/clipSize.h)) : null ),
-		isRandom:isRandom,
+		this.index=0;
+		this.orientation=orientation;
+		this.framesNumber=( this.isClip?(this.orientation==="horizontal" ? Math.trunc(imagesPool.width/clipSize.w) : Math.trunc(imagesPool.height/clipSize.h)) : null );
+		this.isRandom=isRandom;
 		
 		// Time measurement :
-		time:getNow(),
-		refreshMillis:refreshMillis,
-		durationTimeFactorHolder:{durationTimeFactor:1},
-		setDurationTimeFactorHolder:function(durationTimeFactorHolder){
-			self.durationTimeFactorHolder=durationTimeFactorHolder;
-			return self;
-		},
+		this.time=getNow();
+		this.refreshMillis=refreshMillis;
+		this.durationTimeFactorHolder={durationTimeFactor:1};
 		
-		// Draw :
-		drawOnEachStepZoomedIfNeeded:function(ctx,xParam,yParam,angle=null,opacity=1){
-			
-			let drawingWidth, drawingHeight;
-			let img=null;
-			
-			if(isClip){
-				
-				// We only draw a frame : (to avoid blinking)
+		// Two-states : started, stopped.
+		
+	}
 	
-				drawingWidth=Math.trunc(self.clipSize.w*self.scaleFactorW);
-				drawingHeight=Math.trunc(self.clipSize.h*self.scaleFactorH);
+	setDurationTimeFactorHolder(durationTimeFactorHolder){
+		this.durationTimeFactorHolder=durationTimeFactorHolder;
+		return this;
+	}
 	
-				var clipX=0;
-				var clipY=0;
-				if(orientation==="horizontal"){
-					clipX=self.index*self.clipSize.w;
-					clipY=self.yOffset;
-				}else{
-					clipX=self.xOffset;
-					clipY=self.index*self.clipSize.h;
-				}
-				
-			}else{
-				
-				img=Math.getRandomInArray(self.imagesPool);
-				
-				self.clipSize={w:img.width,h:img.height};
-				
-				
-				drawingWidth=Math.trunc(img.width*self.scaleFactorW);
-				drawingHeight=Math.trunc(img.height*self.scaleFactorH);
-				
-				
+	// Draw :
+	drawOnEachStepZoomedIfNeeded(ctx,xParam,yParam,angle=null,opacity=1){
+		
+		let drawingWidth, drawingHeight;
+		let img=null;
+		let clipX=0;
+		let clipY=0;
+		if(this.isClip){
+			// We only draw a frame : (to avoid blinking)
+			drawingWidth=Math.trunc(this.clipSize.w*this.scaleFactorW);
+			drawingHeight=Math.trunc(this.clipSize.h*this.scaleFactorH);
 
+			if(this.orientation==="horizontal"){
+				clipX=this.index*this.clipSize.w;
+				clipY=this.yOffset;
+			}else{
+				clipX=this.xOffset;
+				clipY=this.index*this.clipSize.h;
 			}
 			
-
-			const xImage=xParam+self.xOffset;
-			const yImage=yParam+self.yOffset;
-			
-			const zooms=self.zooms;
-			
-			drawImageAndCenterWithZooms(ctx, nonull(img,self.imagesPool),
-				xImage, yImage, 
-				zooms,
-				self.center, 
-				(self.scaleFactorW),
-				(self.scaleFactorH),
-				(!isClip?(drawingWidth):null),
-				(!isClip?(drawingHeight):null),
-				opacity,
-				false,
-				(isClip?{x:clipX,y:clipY, w:self.clipSize.w, h:self.clipSize.h}:{x:0,y:0, w:self.clipSize.w, h:self.clipSize.h}),
-				angle);
-			
-					
+		}else{
+			img=Math.getRandomInArray(this.imagesPool);
+			this.clipSize={w:img.width,h:img.height};
 			
+			drawingWidth=Math.trunc(img.width*this.scaleFactorW);
+			drawingHeight=Math.trunc(img.height*this.scaleFactorH);
+		}
 
-			// Looping index with a delay :
-			var delayHasPassed= (!self.time || hasDelayPassed(self.time, self.refreshMillis*self.durationTimeFactorHolder.getDurationTimeFactor()));
-			if(!self.refreshMillis || delayHasPassed){
-				if(self.refreshMillis && delayHasPassed){
-					self.time=getNow();
-				}
-				
-				
-				if(isClip){
-					// We perform the step forward (if the loop is not finished):
-					if(isLoop || index!==self.framesNumber){
-						if(self.isRandom){
-							self.index=Math.getRandomInt(self.framesNumber-1, 0);
-						}else{
-							self.index=((self.index+1)%(self.framesNumber/*if max is reached, then index is looped to 0*/));
-						}
+		const xImage=xParam+this.xOffset;
+		const yImage=yParam+this.yOffset;
+		const zooms=this.zooms;
+		
+		drawImageAndCenterWithZooms(ctx, nonull(img,this.imagesPool),
+			xImage, yImage, 
+			zooms,
+			this.center,
+			(this.scaleFactorW),
+			(this.scaleFactorH),
+			(!this.isClip?(drawingWidth):null),
+			(!this.isClip?(drawingHeight):null),
+			opacity,
+			false,
+			(this.isClip?{x:clipX,y:clipY, w:this.clipSize.w, h:this.clipSize.h}:{x:0,y:0, w:this.clipSize.w, h:this.clipSize.h}),
+			angle);
+
+		// Looping index with a delay :
+		if(!this.refreshMillis || this.hasDelayPassed()){
+			if(this.refreshMillis && this.hasDelayPassed()){
+				this.time=getNow();
+			}
+			
+			if(this.isClip){
+				// We perform the step forward (if the loop is not finished):
+				if(this.isLoop || index!==this.framesNumber){
+					if(this.isRandom){
+						this.index=Math.getRandomInt(this.framesNumber-1, 0);
+					}else{
+						this.index=((this.index+1)%(this.framesNumber/*if max is reached, then index is looped to 0*/));
 					}
 				}
-
 			}
-		},
-		
-	};
+
+		}
+	}
 	
-	return self;
+	hasDelayPassed(){
+		return (!this.time || hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor()));
+	}
 	
 }
 
 
+function getSpriteMonoThreaded(imagesPool,/*OPTIONAL*/refreshMillis=null,
+		clipSize={w:100,h:100},scaleFactorW=1,scaleFactorH=1,
+		orientation="horizontal",xOffset=0,yOffset=0,isLoop=true,isRandom=false,
+		center={x:"left",y:"top"},
+		zoomsParam={zx:1,zy:1}){
 
-
-
-//Routines
-function getMonoThreadedTimeout(doOnStop=null, delayMillis=null){
-	
-	let self={
-		started:true,
-		time:getNow(),
-		delayMillis:delayMillis,
-		doOnStop:doOnStop,
-		isStarted:function(){
-			return self.started;
-		},
-		start:function(callingObject=null, args=null, doOnStop=null){
-			if(callingObject)	self.callingObject=callingObject;
-			if(doOnStop)			self.doOnStop=doOnStop;
-			if(hasDelayPassed(self.time, self.delayMillis)){
-				if(self.doOnStop)		self.doOnStop.apply(callingObject, args);
-				return;
-			}
-			self.started=true;
-			return self;
-		},
-		doStep:function(args=null){
-			if(!self.started)
-				return;
-			if(!hasDelayPassed(self.time, self.delayMillis))
-				return;
-			if(self.doOnStop)		self.doOnStop.apply(self.callingObject, args);
-			self.started=false;
-			return self;
-		},
-		stop:function(args=null){
-			if(!self.isStarted())	return;
-			self.started=false;
-			if(self.doOnStop)	self.doOnStop.apply(self.callingObject, args);
-			return self;
-		},
-		reset:function(){
-			this.time=getNow();
-			return self;
-		},
-	};
-	return self;
+	return new SpriteMonoThreaded(imagesPool,refreshMillis,
+		clipSize,scaleFactorW,scaleFactorH,
+		orientation,xOffset,yOffset,isLoop,isRandom,
+		center,
+		zoomsParam);
 }
 
+// ====================================================== ROUTINES ======================================================
 
 
+// ======================== Timeout ========================
 
+// CAUTION : This is not a routine, but a single-use timeout !
+class MonoThreadedTimeout{
+	constructor(actuator, delayMillis){
+		this.actuator=actuator;
+	}
+	start(delayMillis=null){
+		this.started=true;
+		this.time=getNow();
+		this.delayMillis=delayMillis;
+	}
+	doStep(args=null){
+		if(!this.started)	return;
+		if(!hasDelayPassed(this.time, this.delayMillis))	return;
+		return this.stop(args);
+	}
+	stop(args=null){
+		if(!this.started)	return;
+		this.started=false;
+		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+		return this;
+	}
+}
 
+function getMonoThreadedTimeout(actuator=null){
+	return new MonoThreadedTimeout(actuator);
+}
 
-function getMonoThreadedRoutine(doOnEachStepCallback,terminateFunction=null,doOnStop=null,refreshMillis=null,startDependsOnParentOnly=false,doOnSuspend=null,doOnResume=null){
-	
-	// Three-states : started, paused, stopped.
-	
-	let self={
-			
-		startDependsOnParentOnly:startDependsOnParentOnly,
-		started:false,
-		paused:false,
-		time:getNow(),
-		refreshMillis:refreshMillis,
-		doOnEachStepCallback:doOnEachStepCallback,
-		terminateFunction:terminateFunction,
-		doOnStop:doOnStop,
-		doOnSuspend:doOnSuspend,
-		doOnResume:doOnResume,
-		durationTimeFactorHolder:{durationTimeFactor:1},
-		setDurationTimeFactorHolder:function(durationTimeFactorHolder){
-			self.durationTimeFactorHolder=durationTimeFactorHolder;
-			return self;
-		},
-		isStarted:function(){
-			return self.started || self.startDependsOnParentOnly;
-		},
-		start:function(callingObject=null,args=null){
-			
-			// if(self.isStarted()) return;
-			if(self.terminateFunction && self.terminateFunction(callingObject,args)){
-				
-				// CAUTION : Even if the routine is «pre-terminated» before even starting 
-				// (ie. its stop conditions are fullfilled even before it has started)
-				// we all the same have to trigger its stop treatments :
-				if(self.doOnStop)	self.doOnStop(callingObject,args);
-
-				return;
-			}
-			
-			self.started=true;
-			
-			self.paused=false;
-
-			return self;
-		},
-		stop:function(callingObject=null,args=null){
-			
-			if(!self.isStarted())	return;
-			self.started=false;
 
-			if(self.doOnStop)	self.doOnStop(callingObject,args);
-			
-		},
-		pause:function(callingObject=null,args=null){
-			self.paused=true;
-			
-			if(self.doOnSuspend)	self.doOnSuspend(callingObject,args);
-		},
-		resume:function(callingObject=null,args=null){
-			self.paused=false;
-			
-			if(self.doOnResume)	self.doOnResume(callingObject,args);
-		},
-		isPaused:function(){
-			return self.paused;
-		},
-		doStep:function(callingObject=null,args=null){
-			
+// ======================== Routine ========================
 
-			if(!self.isStarted() || self.paused)	return;
+class MonoThreadedRoutine{
+	constructor(actuator,refreshMillis=null,startDependsOnParentOnly=false){
 
-			// Looping index with a delay :
-			
-			let delayHasPassed=hasDelayPassed(self.time, self.refreshMillis*self.durationTimeFactorHolder.getDurationTimeFactor());
-			if(!self.refreshMillis || delayHasPassed){
-				if(self.refreshMillis && delayHasPassed){
-					self.time=getNow();
-				}
-				
-				// We perform the step :
-				if(self.terminateFunction && self.terminateFunction(callingObject,args)){
-					self.stop(callingObject,args);
-					return;
-				}
-				
+		this.actuator=actuator;
+		this.startDependsOnParentOnly=startDependsOnParentOnly;
+		this.started=false;
+		this.paused=false;
+		this.time=getNow();
+		this.refreshMillis=refreshMillis;
+		
+		this.durationTimeFactorHolder={durationTimeFactor:1};
+		// Three-states : started, paused, stopped.
 
-				if(self.doOnEachStepCallback)	self.doOnEachStepCallback(callingObject,args);
+	}
+	
+	setDurationTimeFactorHolder(durationTimeFactorHolder){
+		this.durationTimeFactorHolder=durationTimeFactorHolder;
+		return this;
+	}
+	isStarted(){
+		return this.started || this.startDependsOnParentOnly;
+	}
+	start(args=null){
+		// if(this.isStarted()) return;
+		if(this.actuator.terminateFunction && this.actuator.terminateFunction(args)){
+			// CAUTION : Even if the routine is «pre-terminated» before even starting 
+			// (ie. its stop conditions are fullfilled even before it has started)
+			// we all the same have to trigger its stop treatments :
+			if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+			return;
+		}
+		this.started=true;
+		this.paused=false;
+		return this;
+	}
+	stop(args=null){
+		if(!this.isStarted())	return;
+		this.started=false;
+		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+	}
+	pause(args=null){
+		this.paused=true;
+		if(this.actuator.doOnSuspend)	this.actuator.doOnSuspend(args);
+	}
+	resume(args=null){
+		this.paused=false;
+		if(this.actuator.doOnResume)	this.actuator.doOnResume(args);
+	}
+	isPaused(){
+		return this.paused;
+	}
+	doStep(args=null){
+		if(!this.isStarted() || this.paused)	return;
+		// Looping index with a delay :
+		
+		const delayHasPassed=hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor());
+		if(!this.refreshMillis || delayHasPassed){
+			if(this.refreshMillis && delayHasPassed){
+				this.time=getNow();
 			}
-			
+			// We perform the step :
+			if(this.actuator.terminateFunction && this.actuator.terminateFunction(args)){
+				this.stop(args);
+				return;
+			}
+			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
 		}
-	};
-
-	
+		
+	}
 	
-	return self;
 }
 
 
+function getMonoThreadedRoutine(actuator, refreshMillis=null, startDependsOnParentOnly=false){
+	return new MonoThreadedRoutine(actuator, refreshMillis, startDependsOnParentOnly);
+}
 
 
-
-function getMonoThreadedGoToGoal(actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear",doOnEachStepCallback=null,doOnStop=null){
-	
-//	const STEP_PRECISION=4;
-	// Three-states : started, paused, stopped.
+class MonoThreadedGoToGoal{
+	constructor(actuator,actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear"){
+		
+		this.actuator=actuator;
+		
+		this.actualValue=actualValue;
+		this.mode=mode;
+		this.totalTimeMillis=totalTimeMillis;
+		this.stepValue=((refreshMillis*(goalValue-actualValue))/totalTimeMillis);
+		this.value=actualValue;
+		this.goalValue=goalValue;
+		this.started=false;
+		this.paused=false;
+		this.time=getNow();
+		this.refreshMillis=refreshMillis;
+		
+		this.durationTimeFactorHolder={durationTimeFactor:1};
 	
-	let self={
-			
-		mode:mode,
-		totalTimeMillis:totalTimeMillis,
-		stepValue:((refreshMillis*(goalValue-actualValue))/totalTimeMillis),
-		value:actualValue,
-		goalValue:goalValue,
-		started:false,
-		paused:false,
-		time:getNow(),
-		refreshMillis:refreshMillis,
-		doOnEachStepCallback:doOnEachStepCallback,
-		doOnStop:doOnStop,
-		durationTimeFactorHolder:{durationTimeFactor:1},
-		setDurationTimeFactorHolder:function(durationTimeFactorHolder){
-			self.durationTimeFactorHolder=durationTimeFactorHolder;
-			
-			// We recalculate total time-dependent values :
-			self.totalTimeMillis=totalTimeMillis*self.durationTimeFactorHolder.getDurationTimeFactor();
-			self.stepValue=((refreshMillis*(goalValue-actualValue))/self.totalTimeMillis);
+		// Three-states : started, paused, stopped.
+	}
+	setDurationTimeFactorHolder(durationTimeFactorHolder){
+		this.durationTimeFactorHolder=durationTimeFactorHolder;
+		
+		// We recalculate total time-dependent values :
+		this.totalTimeMillis=this.totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
+		this.stepValue=((this.refreshMillis*(this.goalValue-this.actualValue))/this.totalTimeMillis);
 
-			return self;
-		},
-		isStarted:function(){
-			return self.started || self.startDependsOnParentOnly;
-		},
-		resetValueAndGoalTo:function(resetValue){
-			self.value=resetValue;
-			self.goalValue=resetValue;
-			return self;
-		},
-		setNewGoal:function(goalValue, refreshMillisParam=null, totalTimeMillis=null){
-			if(Math.round(self.value)===Math.round(goalValue))	return;
-			if(refreshMillisParam)	self.refreshMillis=refreshMillisParam;
-			if(totalTimeMillis)			self.totalTimeMillis=totalTimeMillis*self.durationTimeFactorHolder.getDurationTimeFactor();
+		return this;
+	}
+	isStarted(){
+		return this.started || this.startDependsOnParentOnly;
+	}
+	resetValueAndGoalTo(resetValue){
+		this.value=resetValue;
+		this.goalValue=resetValue;
+		return this;
+	}
+	setNewGoal(goalValue, refreshMillisParam=null, totalTimeMillis=null){
+		if(Math.round(this.value)===Math.round(goalValue))	return;
+		if(refreshMillisParam)	this.refreshMillis=refreshMillisParam;
+		if(totalTimeMillis)			this.totalTimeMillis=totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
 
-			self.stepValue=((self.refreshMillis*(goalValue-self.value))/self.totalTimeMillis),
-			self.goalValue=goalValue;
-			
-			if(!self.isStarted())
-				self.start();
-				
-			return self;
-		},
-		start:function(callingObject=null,args=null){
+		this.goalValue=goalValue;
+		this.stepValue=((this.refreshMillis*(this.goalValue-this.value))/this.totalTimeMillis);
+		
+		if(!this.isStarted())	this.start();
 			
-			if(    self.value===self.goalValue
-			//  || self.isStarted();
-					|| self.terminateFunction(callingObject,args)){
+		return this;
+	}
+	start(args=null){
+		
+		if(    this.value===this.goalValue
+		//  || this.isStarted();
+				|| (this.actuator.terminateFunction && this.actuator.terminateFunction())
+				|| this.hasReachedGoal()){
 
-				// CAUTION : Even if the routine is «pre-terminated» before even starting 
-				// (ie. its stop conditions are fullfilled even before it has started)
-				// we all the same have to trigger its stop treatments :
-				if(self.doOnStop)	self.doOnStop(callingObject,args);
+			// CAUTION : Even if the routine is «pre-terminated» before even starting 
+			// (ie. its stop conditions are fullfilled even before it has started)
+			// we all the same have to trigger its stop treatments :
+			if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
 
-				return;
-			}
-			
-			self.started=true;
-			
-			self.paused=false;
-			
-			return self;
-		},
-		stop:function(callingObject=null,args=null){
-			
-			if(!self.isStarted())	return;
-			self.started=false;
+			return;
+		}
+		this.started=true;
+		this.paused=false;
+		
+		return this;
+	}
+	stop(args=null){
+		if(!this.isStarted())	return;
+		this.started=false;
+		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+	}
+	pause(){
+		this.paused=true;
+	}
+	resume(){
+		this.paused=false;
+	}
+	hasReachedGoal(){
+		if(this.stepValue<0){
+			if(this.value<=this.goalValue)	return true;
+		}else{
+			if(this.goalValue<=this.value)	return true;
+		}
+		return false;
+	}
+	
+	doStep(args=null){
+		if(!this.isStarted() || this.paused)	return this.value;
 
-			if(self.doOnStop)	self.doOnStop(callingObject,args);
-			
-		},
-		pause:function(){
-			self.paused=true;
-		},
-		resume:function(){
-			self.paused=false;
-		},
-		terminateFunction:function(){
+		// Looping index with a delay :
+		
+		if(!this.refreshMillis || this.hasDelayPassed()){
+			if(this.refreshMillis && this.hasDelayPassed()){
+				this.time=getNow();
+			}
 			
-			if(self.stepValue<0){
-				if(self.value<=self.goalValue){
-					return true;
+			// We check if we must stop :
+			if(this.actuator.terminateFunction){
+				if(this.actuator.terminateFunction()){
+					this.stop();
+					this.value=this.goalValue;
+					return this.value;
 				}
 			}else{
-				if(self.goalValue<=self.value){
-					return true;
+				if(this.hasReachedGoal()){
+					this.stop();
+					this.value=this.goalValue;
+					return this.value;
 				}
 			}
 			
-			return false;
-			
-		},
-		
-		doStep:function(callingObject=null,args=null){
-			
-			if(!self.isStarted() || self.paused)	return self.value;
-
-			// Looping index with a delay :
-			
-			var delayHasPassed=(!self.time || hasDelayPassed(self.time, self.refreshMillis*self.durationTimeFactorHolder.getDurationTimeFactor()));
-			if(!self.refreshMillis || delayHasPassed){
-				if(self.refreshMillis && delayHasPassed){
-					self.time=getNow();
-				}
-				
-				// We perform the step :
-				if(self.terminateFunction(callingObject)){
-					self.stop(callingObject);
-					
-					self.value=self.goalValue;
-					
-					return self.value;
-				}
-				
-				
-				if(self.mode==="exponential"){
-					self.value+=Math.pow(self.stepValue,2);
-				}else{ // default is "linear"
-					self.value+=self.stepValue;
-				}
-				
-				if(self.doOnEachStepCallback)	self.doOnEachStepCallback(callingObject,args);
+			// We perform the step :
+			if(this.mode==="exponential"){
+				this.value+=Math.pow(this.stepValue,2);
+			}else{ // default is "linear"
+				this.value+=this.stepValue;
 			}
 			
-			return self.value;
-			
+			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
 		}
-	};
+		
+		return this.value;
+	}
 	
-	return self;
+	hasDelayPassed(){
+		return (!this.time || hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor()));
+	}
+
+	
+}
+
+
+function getMonoThreadedGoToGoal(actuator,actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear"){
+	return new MonoThreadedGoToGoal(actuator,actualValue,goalValue,refreshMillis,totalTimeMillis,mode);
 }
 
 
+// =====================================================================================================================
 
 
 //if signed :
@@ -12047,10 +12074,7 @@ class VNCFrame2D{
 				"sound":(soundDataStr)=>{
 					const soundData=getDecodedArrayFromSoundDataString(soundDataStr);
 					playAudioData(soundData,self.audioCtx,self.screenAndAudioConfig.audioBufferSize,1,self.screenAndAudioConfig.sampleRate,()=>{
-						// doOnEndedPlaying
-						
 						self.fusrodaClient.client.socketToServer.send("soundSampleRequest", {});
-
 					});
 				}
 		}, this.url, this.port, this.isSecure);
@@ -12332,7 +12356,6 @@ window.createOritaMainClient=function(
 			microClientInfos.lastTime=getNow();
 			mainClient.inputsGPIO=inputsGPIO;
 			
-			
 			doOnInputsCreated(mainClient, microClientId, mainClient.inputsGPIO);
 		},
 	});
@@ -12628,6 +12651,10 @@ window.createOritaMainClient=function(
 
 // SEE http://codefoster.com/pi-basicgpio/
 
+// INSTALL ON TARGET PLATFORM : https://ma2shita.medium.com/how-to-use-raspi-gpio-instead-of-gpio-of-wriring-pi-af2ab00eda57
+
+// ON 10/2024 GPIO IS UTTERLY BROKEN ON THE "BOOKWORM" RASPBIAN DISTRIBUTION WITH NO SOLUTION !!! 
+
 const GPIO_BASE_PATH = "/sys/class/gpio";
 window.gpioUtils = {
 	open: (gpioNumber, mode, doOnSuccess = null) => {
@@ -12649,6 +12676,7 @@ window.gpioUtils = {
 				if (doOnSuccess) doOnSuccess();
 			});
 		};
+
 		fs.access(gpioFilePath, fs.constants.F_OK, (error) => {
 			if (error) {
 				// Case export file does not exists 
@@ -12772,34 +12800,34 @@ window.gpioUtils = {
 
 
 
-	// const REFRESHING_RATE_MILLIS_AUDIO:100,
+// const REFRESHING_RATE_MILLIS_AUDIO:100,
 
 
-	//	const MICRO_CLIENT_MESS_WITH_ALPHA=true;
-	//	const MICRO_CLIENT_MESS_WITH_ALPHA=false;
+//	const MICRO_CLIENT_MESS_WITH_ALPHA=true;
+//	const MICRO_CLIENT_MESS_WITH_ALPHA=false;
 
 
-	const REFRESHING_RATE_MILLIS_DEFAULT = 1000;
+const REFRESHING_RATE_MILLIS_DEFAULT = 1000;
 
 
-	// Output constants :	
-	const STEPPER_DELAY_MILLIS = 1;
-	const DEFAULT_STEPPER_SEQUENCE = [
-		[1, 0, 0, 0],
-		[0, 1, 0, 0],
-		[0, 0, 1, 0],
-		[0, 0, 0, 1],
-	];
-	const HALF_STEP_STEPPER_SEQUENCE = [
-		[0, 1, 0, 0],
-		[0, 1, 0, 1],
-		[0, 0, 0, 1],
-		[1, 0, 0, 1],
-		[1, 0, 0, 0],
-		[1, 0, 1, 0],
-		[0, 0, 1, 0],
-		[0, 1, 1, 0],
-	];
+// Output constants :	
+const STEPPER_DELAY_MILLIS = 1;
+const DEFAULT_STEPPER_SEQUENCE = [
+	[1, 0, 0, 0],
+	[0, 1, 0, 0],
+	[0, 0, 1, 0],
+	[0, 0, 0, 1],
+];
+const HALF_STEP_STEPPER_SEQUENCE = [
+	[0, 1, 0, 0],
+	[0, 1, 0, 1],
+	[0, 0, 0, 1],
+	[1, 0, 0, 1],
+	[1, 0, 0, 0],
+	[1, 0, 1, 0],
+	[0, 0, 1, 0],
+	[0, 1, 1, 0],
+];
 
 
 
@@ -12880,7 +12908,6 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 
 				// TODO : FIXME : Utiliser initClient(...) au lieu de directement getStatic(...) avec le paramètre isNode transmis dans l'appel)
 				//oritaClient=initClient(isNode,false,doOnServerConnection=null, url, port);
-
 				oritaClient.client={};
 				oritaClient.client.socketToServer = WebsocketImplementation.getStatic(isNode).connectToServer(url, port);
 				oritaClient.client.socketToServer.onConnectionToServer(() => {
@@ -13620,18 +13647,256 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 
 
 
+//*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
 
 
 
 
+class AORTACClient{
+	
+		constructor(clientId, serverNodeOrigin, model, view, isNodeContext=true, sslConfig={/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
+			this.clientId=clientId;
+			this.serverNodeOrigin=serverNodeOrigin;
+			this.isNodeContext=isNodeContext;
+			this.sslConfig=sslConfig;
+			
+			this.model=model;						// must implement functions
+			this.view=view; 						// Must implement functions
+			this.view.setClient(this);
+			
+			this.clientInstanceToReferenceServerNode=null;
+			this.currentServersNodes={};
+			
+			
+			// TRACE
+			lognow(`AORTAC client created with id ${this.clientId}.`);
+			
+		}
+		
+		start(){
+		
+			const self=this;
+			
+			const splits=splitURL(this.serverNodeOrigin);
+			let protocol=nonull(splits.protocol,"ws"), host=nonull(splits.host,"localhost"), port=nonull(splits.port,"30000");
+			
+			
+			// THIS IS ON THE REFERENCE SERER NODE ONLY :
+			const clientInstanceToReferenceServerNode=initClient(this.isNodeContext, false, (socketToServer)=>{
+				
+				
+				// First client needs to register to its main reference serer node : 
+				// TRACE
+				lognow(`		(client ${self.clientId}) Sending client registering request to server node...`);
+				
+				const helloClientRequest={
+					clientId:self.clientId,
+					type:"request.register.client",
+					isReferenceNode:true,
+				};
+				socketToServer.send("protocol", helloClientRequest);
+				
+				// We place a listener from server on this client instance :
+				socketToServer.receive("protocol",(message)=>{
+					
+					
+					// Adding listeners :
+					if(message.type==="response.register.client"){
+						
+						// TRACE
+						lognow(`		(${self.clientId}) Receving registering response from reference server...`);
+						
+						// Case reference node:
+							
+						// Second, once client is registered at its refernce server, then it needs to know to which servers it needs to connect to : 
+						// TRACE
+						lognow("(client "+self.clientId+") Sending client interrogation request to server node...");
+						
+						const boundaries=self.view.getBoundaries();
+						const interrogationRequest={
+							clientId:self.clientId,
+							type:"request.interrogation.client",
+							boundaries:boundaries
+						};
+						socketToServer.send("protocol", interrogationRequest);
+					
+
+					}
+				});
+				
+				// We place a listener from server on this client instance :
+				socketToServer.receive("protocol",(message)=>{
+					if(message.type==="response.unregister.client"){
+						
+						// TRACE
+						lognow(`		(${self.clientId}) Receving unregistering response from reference server...`);
+						
+						// DO NOTHING
+						
+					}
+				});
+			 		
+				
+				// We place a listener from server on this client instance :
+				socketToServer.receive("protocol",(message)=>{
+					if(message.type==="response.interrogation.client"){
+						
+						// TRACE
+						lognow("!!!!!! ("+self.clientId+") Receving interrogation response from requested server...",message);
+						
+						// Now the client needs to know to which other nodes it needs to connect in order to get all its model objects :
+						const serversNodesIdsForModelObjectsForClient=message.serversNodesIdsForModelObjectsForClient;
+
+						// Now the client needs to know to which other nodes it needs to connect in order to get all its model objects :
+						
+						
+						// We connect (only) to the relevant servers directly :
+						foreach(serversNodesIdsForModelObjectsForClient,(nodeInfoAndObjectsIds, serverNodeId)=>{
+							
+							const splitsServerInfo=splitURL(nodeInfoAndObjectsIds.nodeServerInfo);
+							const clientInstanceToAuthorityServerNode=initClient(this.isNodeContext, false, (socketToServer)=>{
+							
+								// Then we register to them :
+								// TRACE
+								lognow(`			(client ${self.clientId}) Sending client registering request to authority server node...`);
+								
+								const helloToAuthorityClientRequest={
+									clientId:self.clientId,
+									type:"request.register.client",
+									isReferenceNode:false,
+								};
+								socketToServer.send("protocol", helloToAuthorityClientRequest);
+							
+							
+							}, splitsServerInfo.protocol+"://"+splitsServerInfo.host, splitsServerInfo.port, false);
+							self.currentServersNodes[serverNodeId]={clientInstance:clientInstanceToAuthorityServerNode};
+							clientInstanceToAuthorityServerNode.client.start();
+							
+							
+							clientInstanceToAuthorityServerNode.client.socketToServer.receive("protocol", (message)=>{
+								
+								// Adding listeners :
+								if(message.type==="response.register.client"){
+									// We place a listener from server on this client instance :
+									// Adding listeners :
+									
+									// Case non-reference authority node servers :
+									
+									// TRACE
+									lognow(`		(${self.clientId}) Receving registering response from reference server...`);
+									
+									// We merge our client's model with the partial model sent from the server it just registered to :
+									const partialModelString=message.partialModelString;
+									const partialModel=JSON.parseRecycle(partialModelString);
+									
+									// Merging means that all objects in partialModel not being in model must be added to model :
+									self.model.clientMergeWith(partialModel);
+									
+									// TRACE
+									lognow("(client "+self.clientId+") Client model has been merged with a partial model from a server node...",self.model);
+			
+								}
+								
+								
+							});
+							
+							
+							
+							clientInstanceToAuthorityServerNode.client.socketToServer.receive("inputs", (message)=>{
+								
+								// Adding listeners :
+								if(message.type==="response.objectsModifiedOrAdded.client"){
+									const modifiedOrAddedObjects=JSON.parseRecycle(message.objectsString);
+									
+									if(!message.isAddingObjects){
+										self.model.clientUpdateObjects(modifiedOrAddedObjects);
+									}else{
+										self.model.clientAddObjects(modifiedOrAddedObjects);
+									}
+									
+									// TRACE
+									lognow(`			(client ${self.clientId}) Receving modified or added objects after the inputs...modifiedOrAddedObjects=`,modifiedOrAddedObjects);
+									
+
+								}
+								
+								
+							});
+											
+							
+						});
+						
+					}
+				});
+				
+				
+				//self.addListeners();
+
+
+				
+			}, protocol+"://"+host, port, false);
+			clientInstanceToReferenceServerNode.client.start();
+			this.clientInstanceToReferenceServerNode={clientInstance:clientInstanceToReferenceServerNode};
+			
+			
+			return this;
+		}
+		
+
+		/*public*/sendInputs(inputs, subBoundaries=null){
+			
+			const self=this;
+
+
+			if(subBoundaries){
+				// We send client's inputs to ALL its currently connected servers :
+				const self=this;
+				foreach(this.currentServersNodes,(serversNode,serverNodeId)=>{
+					self.sendInputsToServer(serversNode, inputs, subBoundaries);
+				});
+			}else{
+				// If we have no boundaries set for these inputs, then we only send them to one server node at random :
+				const serversNode=Math.getRandomInArray(this.currentServersNodes);
+				this.sendInputsToServer(serversNode, inputs, subBoundaries);
+			}
+			
+			
+		}
+
+		/*private*/sendInputsToServer(serversNode, inputs, subBoundaries=null){
+			const clientInstance=serversNode.clientInstance;
+			
+			const inputsMessage={
+				clientId:this.clientId,
+				type:"request.inputs.client",
+				inputs:inputs,
+				subBoundaries:subBoundaries,
+			};
+				
+			clientInstance.client.socketToServer.send("inputs", inputsMessage);
+		}
+
+
+
+
+
+		
+}
+
+
+getAORTACClient=function(clientId=getUUID(), serverNodeOrigin="ws://127.0.0.1:40000", model, view, isNodeContext=true){
+	return new AORTACClient(clientId, serverNodeOrigin, model, view, isNodeContext);
+}
+
+
+
+
+
+
+/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (19/02/2025-23:41:19)»*/
+/*-----------------------------------------------------------------------------*/
 
 
-
-
-/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:15)»*/
-/*-----------------------------------------------------------------------------*/
-
-
 /* ## Utility global methods in a javascript, at least console (nodejs) server, or vanilla javascript with no browser environment.
  *
  * This set of methods gathers utility generic-purpose methods usable in any JS project.
@@ -14867,7 +15132,7 @@ function rayVsUnitSphereClosestPoint(p, r) {
 // MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
 AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
-/*utils AI library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:15)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (19/02/2025-23:41:19)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -15011,7 +15276,7 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils SERVER library associated with aotra version : «1_29072022-2359 (13/10/2024-22:46:15)»*/
+/*utils SERVER library associated with aotra version : «1_29072022-2359 (19/02/2025-23:41:19)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -15189,12 +15454,12 @@ getServerParams=function(portParam=null, certPathParam=null, keyPathParam=null,
 	// https=require("https");
 	// fs=require("fs");
 	
-	if(!https){
+	if(typeof(https)==="undefined"){
 		// TRACE
 		console.log("WARN : Could not find the nodejs dependency «https», aborting SSL setup.");
 		return null;
 	}
-	if(!fs){
+	if(typeof(fs)==="undefined"){
 		// TRACE
 		console.log("WARN : Could not find the nodejs dependency «fs», aborting SSL setup.");
 		return null;
@@ -15237,7 +15502,17 @@ getServerParams=function(portParam=null, certPathParam=null, keyPathParam=null,
 	return result;
 }
 
-
+getConsoleParam(index=0, argsOffset=0){
+	let result=null;
+	if(!process){
+		throw new Error("ERROR : Cannot extract console parameter in this context !");
+	}	
+	process.argv.forEach((val, i)=>{
+		if(i<=argsOffset+1)	return;
+		else if(i==argsOffset+index+1)	result=val;
+	});
+	return result;
+}
 
 
 
@@ -15305,6 +15580,7 @@ WebsocketImplementation={
 					if(typeof(WebSocket)==="undefined"){
 						// TRACE
 						console.log("«ws» SERVER library not called yet, calling it now.");
+						
 						WebSocket=require("ws");
 						if(typeof(WebSocket)==="undefined"){
 							// TRACE
@@ -15406,7 +15682,7 @@ WebsocketImplementation={
 					receive:(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null)=>{
 						
 						// DBG
-						lognow("(SERVER) Registering receive for «"+channelNameParam+"»...",doOnIncomingMessage);
+						lognow("(SERVER) Registering receive for «"+channelNameParam+"»...");
 						
 						
 						
@@ -15444,10 +15720,11 @@ WebsocketImplementation={
 								
 								if(!isClientInRoom) return;
 
-								// DBG
-								lognow("(SERVER) doOnIncomingMessage:",doOnIncomingMessage);
-								if(doOnIncomingMessage)	doOnIncomingMessage(dataWrapped.data, clientSocketParam);
-
+								if(doOnIncomingMessage){
+									// DBG
+									lognow("(SERVER) doOnIncomingMessage:");
+									doOnIncomingMessage(dataWrapped.data, clientSocketParam);
+								}
 								
 							},
 						};
@@ -15705,7 +15982,7 @@ WebsocketImplementation={
 			return nodeServerInstance;
 		},
 		
-		
+		// DO NOT USE DIRECTLY, USE INSTEAD initClient(...) (this function uses connectToServer(...)) !
 		// NODE / BROWSER CLIENT CONNECTS TO SERVER MAIN ENTRYPOINT:
 		connectToServer:(serverURL, port, isSecure=false, timeout)=>{
 
@@ -16333,7 +16610,7 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 	server.onFinalize((serverParam)=>{
 		
 		// DBG
-		lognow("onFinalize!!!!!");
+		lognow("onFinalize() server");
 		
 		if(doOnFinalizeServer)	doOnFinalizeServer(serverParam);
 	});
@@ -16471,7 +16748,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 		// Eventual encryption options : 
 		let sslOptions=null; 
 		if(!isForceUnsecure){
-			if(!fs){
+			if(typeof(fs)==="undefined"){
 				// TRACE
 				lognow("ERROR : «fs» node subsystem not present, cannot access files. Aborting SSL configuration of server.");
 			}else{
@@ -16522,7 +16799,7 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 //	
 //	const server=initNodeServerInfrastructureWrapper(
 //		// On each client connection :
-////	(serverParam, clientSocketParam)=>{},
+// //	(serverParam, clientSocketParam)=>{},
 //		null,
 //		// On server finalization :
 //		(serverParam)=>{
@@ -16555,15 +16832,15 @@ initNodeServerInfrastructureWrapper=function(doOnClientConnection=null, doOnFina
 //		},portParam,certPathParam,keyPathParam);
 //
 //
-////	const doOnConnect=(serverParam, clientSocketParam)=>{
-////	};
-////	const doOnFinalizeServer=(serverParam)=>{
-////		/*DO NOTHING*/
-////	};
-////	const server={};
-////	server.start=(port=6080)=>{
-////		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
-////	};
+// //	const doOnConnect=(serverParam, clientSocketParam)=>{
+// //	};
+// //	const doOnFinalizeServer=(serverParam)=>{
+// //		/*DO NOTHING*/
+// //	};
+// //	const server={};
+// //	server.start=(port=6080)=>{
+// //		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
+// //	};
 //
 //	return server;
 //}
@@ -16907,23 +17184,47 @@ appendGetParameters=function(apiURL, namedArgs){
 
 //*********************************** AUTO-ORGANIZING REAL-TIME AORTAC CLUSTERIZATION (AORTAC) *********************************** */
 
+AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT=30000;
+REQUESTS_IDS_HISTORY_SIZE=10;
+
 class AORTACNode{
-	constructor(selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[], model, controller, sslConfig={/*OPTIONAL*/port:null,/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
+	
+	constructor(nodeId, selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[], model, controller, allowAnonymousNodes=true, sslConfig={/*OPTIONAL*/certPath:null,/*OPTIONAL*/keyPath:null}){
+		
+		this.nodeId=nodeId;
 		this.selfOrigin=selfOrigin;
+		this.sslConfig=sslConfig;
 		this.outcomingNodesOrigins=outcomingNodesOrigins;
+		this.allowAnonymousNodes=allowAnonymousNodes;
 		
-		this.model=model;						// must implement function
-		this.controller=controller; // Must implement function
-		this.serverId=getUUID();
+		this.model=model;						// must implement functions
+		this.controller=controller; // Must implement functions
 		
 		this.server=null;
 		this.clients={};
 		this.incomingServers={};
 		this.outcomingServers={};
+		this.authorizedNodesIds=[this.nodeId];
+		
+		this.listeners={"protocol":[],"cluster":[],"neighbors":[],"inputs":[]};
+	
+		this.executedRequestIdsHistory=[];
 		
+		this.isConnectedToCluster=false;
+		
+		this.modelObjectsDirectory={};
+		this.objectsIndexesForClients={};
+
+		this.addProtocolListeners();
+
+		// TRACE
+		lognow(`AORTAC node created with id ${this.nodeId}.`);
 	}
 	
 	start(){
+
+		const splits=splitURL(this.selfOrigin);
+		let port=nonull(splits.port,"40000");
 		
 		const self=this;
 		this.server = initNodeServerInfrastructureWrapper(
@@ -16931,62 +17232,819 @@ class AORTACNode{
 			null,
 			// On client finalization :
 			function(server){
-				
 				self.server=server;
 				
-				server.receive("protocol", (message, clientSocket)=>{
-					
-					// TRACE
-					console.log("INFO : SERVER : Client has sent a protocol message: ", message);
-		
-					// ============== OTHER SERVER / CLIENT REGISTRATION PHASE ==============
-		
-					if(message.type==="registerOtherServer"){
-						const incomingServerId=message.serverId;
-						
-						self.incomingServers[incomingServerId]={clientSocket:clientSocket};
+				// Listeners handling ;
+				foreach(Object.keys(self.listeners), channelName=>{
+					self.server.receive(channelName, (message, clientSocket)=>{
 						
-					}else if(message.type==="registerClient"){
-						const clientId=message.clientId;
+						// INCOMING NODES LISTENERS HOOK :
+						// TRACE
+						console.log("INFO : SERVER : Client or incoming node has sent a "+channelName+" message: ", message);
+						foreach(self.listeners[channelName], listener => {
+							listener.execute(self, message, self.server, clientSocket);
+						},(listener)=>(message.type===listener.messageType));
 						
-						self.clients[incomingServerId]={clientSocket:clientSocket};
-					}
-					
+					});
 				});
+				
+				// OLD : self.connectToOutcomingServers(self, server).then((server)=>{	self.doOnConnectedToCluster();	});
+				
+				
+		}, port, this.sslConfig.certPath, this.sslConfig.keyPath);
+		
+		this.server.serverManager.start();
+		
+		// TRACE
+		lognow(`AORTAC node started with id ${this.nodeId}.`);
+
+
+		return this;
+	}
+	
+	
+	connect(){
+		
+		const self=this;
+		self.connectToOutcomingServers(self).then((server)=>{	self.doOnConnectedToCluster();	});
+
+		return this;		
+	}
+	
+	
+	
+	
+	/*private*/addProtocolListeners(){
+		
+		const self=this;
+		// ============== OTHER SERVER / CLIENT REGISTRATION PHASE ==============
+		// - OTHER SERVER REGISTRATION PHASE :
+		this.listeners["protocol"].push({
+			messageType:"request.register.server.incoming",
+			execute:(self, message, server, clientSocket)=>{
+				const incomingServerNodeId=message.nodeId;
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving registering request from node ${incomingServerNodeId}...`);
+				
+				if(!self.allowAnonymousNodes && self.isInAuthorizedNodes(incomingServerNodeId)){
+					// TRACE
+					lognow("WARN : Cannot accept incoming server with node id «"+incomingServerNodeId+"» because it's not in the authorized nodes list.");
+					return;
+				}
+				if(!contains(self.authorizedNodesIds,incomingServerNodeId))	self.authorizedNodesIds.push(incomingServerNodeId);
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Adding registering node ${incomingServerNodeId} to incoming servers...`);
+				
+				self.incomingServers[incomingServerNodeId]={clientSocket:clientSocket};
+				
+				const welcomeResponse={
+					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
+					type:"response.register.server.incoming",
+					authorizedNodesIds:self.authorizedNodesIds
+				};
+				server.send("protocol", welcomeResponse, null, clientSocket);
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Sent registering response to node ${incomingServerNodeId}.`);
+			}
+		});
+		
+		// - CLIENT REGISTRATION PHASE : (for clients to the server, NOT INCOMING NODES !)
+		this.handleClients();
+		
+	}
+	
+	/*private*/handleClients(){
+		const self=this;
+		
+		// --------- PROTOCOL HANDLING ---------
+		 
+		this.listeners["protocol"].push({
+			messageType:"request.register.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				self.clients[clientId]={clientSocket:clientSocket};
+
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client registration request from client ${clientId}.`);
+				
+				const welcomeClientResponse={
+					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
+					type:"response.register.client",
+					// If necessary we also send them our model part :
+					partialModelString:(message.isReferenceNode?null:JSON.stringifyDecycle(self.model)),
+					isReferenceNode:(!!message.isReferenceNode),
+				};
+				server.send("protocol", welcomeClientResponse, null, clientSocket);
+			}
+		});
+		
+		this.listeners["protocol"].push({
+			messageType:"request.unregister.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				delete self.clients[clientId];
+
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client unregistration request from client ${clientId}.`);
+				
+				const unwelcomeClientResponse={
+					nodeId:self.nodeId, // MUST BE SELF ! ELSE THE REGISTERING CLIENT WON'T KNOW WHICH ID IT HAS BEEN REGISTERED TO !
+					type:"response.unregister.client",
+				};
+				server.send("protocol", unwelcomeClientResponse, null, clientSocket);
+			}
+		});
+		
+		
+		this.listeners["protocol"].push({
+			messageType:"request.interrogation.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client interrogation request from client ${clientId}.`);
+				
+				const clientBoundaries=message.boundaries;
+				
+				// We ask the whole cluster to find the requested objects :
+				const modelSeekObjectsRequest={
+					type:"request.model.seekObjects",
+					originatingClientId:clientId,
+					clientBoundaries:clientBoundaries,
+				};
+				this.propagateToCluster(modelSeekObjectsRequest);
+
+				self.objectsIndexesForClients[clientId]={};
+				
+			}
+		});
+		
+		// --------- INPUTS HANDLING --------- 
+		
+		this.listeners["inputs"].push({
+			messageType:"request.inputs.client",
+			execute:(self, message, server, clientSocket)=>{
+				const clientId=message.clientId;
+				
+				// TRACE
+				lognow(`	(${self.nodeId}) Receiving non-cluster client inputs request from client ${clientId}.`);
+				
+				const clientInputs=message.inputs;
+				const clientSubBoundaries=message.subBoundaries;
+
+				
+				// We let the controller interpret these inputs :
+				const modifiedObjects=self.controller.interpretInputs(clientInputs, clientSubBoundaries);
+				
+
+			}
+		});
+		
+	}
+
 
+	/*private*/addPropagationForClientsListeners(){
+		
+		const self=this;
+		
+		// ------------------------------------- CLIENTS PROTOCOL HANDLING -------------------------------------
+		// Adding propagation listener :
+		this.setPropagation("cluster","request.model.seekObjects",(self, message, server, clientSocket)=>{
+			
+			// If we receive this request from cluster, then we try to find the requested objects
+			const relayNodeid=message.nodeId;
+			const originatingClientId=message.originatingClientId;
+			const clientBoundaries=message.clientBoundaries
+			const objectsIds=self.model.getObjectsIdsWithinBoundaries(clientBoundaries);
+
+			// If server has not the seeked objects, it answers with an empty array.			
+			
+			// TRACE
+			lognow(`(${self.nodeId}) Node receiving a seek objects request from relay node ${message.nodeId}...objectsIds=`,objectsIds);
 
+			// TRACE
+			lognow(`(${self.nodeId}) Sending objects ids to relay node ${relayNodeid}...`);
+			
+			const modelObjectsSeekResponse={
+				type:"response.model.seekObject",
+				originatingClientId:originatingClientId,
+				clientBoundaries:clientBoundaries,
+				objectsIds:objectsIds,
+				nodeServerInfo:self.selfOrigin
+			};
+			this.propagateToCluster(modelObjectsSeekResponse, relayNodeid/*destination node*/);
+
+		});
+		
+		// Adding propagation listener :
+		this.setPropagation("cluster","response.model.seekObject",(self, message, server, clientSocket)=>{
+			
+			// Here the relay server gathers the information from the other nodes, and sends it back to client ; 
+			
+			const referenceNodeId=self.nodeId;
+			const originatingClientId=message.originatingClientId;
+			const originatingNodeId=message.nodeId;
+			const clientBoundaries=message.clientBoundaries;
+			const objectsIds=message.objectsIds;
+			const nodeServerInfo=message.nodeServerInfo;
+			
+			// TRACE
+			lognow(`(${self.nodeId}) Node receiving a seek objects request from relay node ${message.nodeId}...objectsIds=`,objectsIds);
+			
+			// Here the currently answering node fills its information :
+			const objectsIndexForClient=self.objectsIndexesForClients[originatingClientId];
+			objectsIndexForClient[originatingNodeId]={nodeServerInfo:nodeServerInfo, objectsIds:objectsIds};
+			
+			
+			// We check if all known nodes have answered :
+			if(getArraySize(self.authorizedNodesIds)-1/*Because we exclude the reference node*/<=getArraySize(objectsIndexForClient)){
+
+				// The reference node also answers to the request to its direct client :
+				const objectsIdsFromReferenceNode=self.model.getObjectsIdsWithinBoundaries(clientBoundaries);
+				const referenceNodeServerInfo=self.selfOrigin;
+				objectsIndexForClient[referenceNodeId]={nodeServerInfo:referenceNodeServerInfo, objectsIds:objectsIdsFromReferenceNode};
+				
+				const client=self.clients[originatingClientId];
+				const clientSocket=client.clientSocket;
+
+				// TRACE
+				lognow(`(${self.nodeId}) Sending objects ids to the client ${originatingClientId}...objectsIndexForClient=`,objectsIndexForClient);
+				
+				// We filter all the index entries with an empty objetcs ids array :
+				const objectsIndexForClientWithoutEmptyObjects={};
+				foreach(objectsIndexForClient,(nodeInfoAndObjectsIds, serverNodeId)=>{
+					objectsIndexForClientWithoutEmptyObjects[serverNodeId]=nodeInfoAndObjectsIds;
+				},(nodeInfoAndObjectsIds,serverNodeId)=>(!empty(nodeInfoAndObjectsIds.objectsIds)));
+				
+				// We send the final result information (objects ids) to client :
+				const interrogationClientResponse={
+					nodeId:self.nodeId,
+					type:"response.interrogation.client",
+					serversNodesIdsForModelObjectsForClient:objectsIndexForClientWithoutEmptyObjects
+				};
+				self.server.send("protocol", interrogationClientResponse, null, clientSocket);
+			}
+			
+		});
+		
+		
+		// ------------------------------------- CLIENTS INPUTS HANDLING -------------------------------------
+		// Adding propagation listener :
+
+		
+		
+		// DBG
+		lognow(">>>>>>>>FOR CLIENTS this.listeners",this.listeners);
+		
+	}
+
+//	/*private*/getServersNodesIdsForModelObjectsForClient(clientObjectsIds){
+//		const serversNodesIdsForModelObjectsForClient={};
+//		const self=this;
+//		// TODO : FIXME : INEFFICIENT !!!
+//		foreach(clientObjectsIds,(objectId)=>{
+//			foreach(self.modelObjectsDirectory,(objectsInNode, nodeId)=>{
+//				if(contains(objectsInNode,objectId))
+//					serversNodesIdsForModelObjectsForClient[objectId]=nodeId;
+//			});
+//		});
+//		
+//		return serversNodesIdsForModelObjectsForClient;
+//	}
+
+	/*private*/connectToOutcomingServers(self){
+		
+		const server=self.server;
+	
+		const theoreticNumberOfOutcomingServers=getArraySize(self.outcomingNodesOrigins);
+		
+		return new Promise((resolve,error)=>{
+			
+			// In case we timeout :
+			setTimeout(()=>{
+				if(self.isConnectedToCluster)	return;
+				self.isConnectedToCluster=true;
+				resolve(server);
+			},AORTAC_OUTCOMING_SERVERS_CONNECTION_GLOBAL_TIMEOUT);
+		
 			// We try to connect to all the other outcoming servers :
+			
+			// Special case : if node has no outcoming serves, (it's the seed node), then 
+			// it should be considered as connected to cluster nonetheless :
+			if(empty(self.outcomingNodesOrigins)){
+				self.finalizeClusterConnection(self.nodeId);
+				resolve(server);
+				return;
+			}
+			
+			// We try to connect to all outcoming nodes : 
 			foreach(self.outcomingNodesOrigins, outcomingNodeOrigin=>{
-				let outcomingNodeHost;
-				let outcomingNodePort;
-				if(contains(outcomingNodeOrigin,":")){
-					const splits=outcomingNodeOrigin.split(":");
-					outcomingNodeHost=splits[0];
-					outcomingNodePort=splits[1];
-				}
-				const isSecure=(contains(outcomingNodeOrigin,"wss"));
-				const clientInstance=connectToServer(outcomingNodeHost,outcomingNodePort, isSecure, 5000);
 				
-				//self.outcomingServers[]={clientInstanceToServer:clientInstance};
+				// TRACE
+				lognow(`	(${self.nodeId}) Sending registering response to node ${outcomingNodeOrigin}...`);
+				
+				const splits=splitURL(outcomingNodeOrigin);
+				const outcomingNodeProtocol=nonull(splits.protocol,"ws");
+				const outcomingNodeHost=nonull(splits.host,"localhost");
+				const outcomingNodePort=nonull(splits.port,"40000");
+				//const isSecure=splits.isSecure; // UNUSED
+				
+				const clientInstance=initClient(true, false, (socketToServer)=>{
+					
+					// TODO : FIXME : IF CONNECTION TO SERVER FAILS, IT MUST BE ABLE TO TRY AGAIN LATER !
+					
+					// TRACE
+					lognow(`		(${self.nodeId}) Sending registering request to outcoming node...`);
+					
+					const helloRequest={
+						nodeId:self.nodeId,
+						type:"request.register.server.incoming"
+					};
+					socketToServer.send("protocol", helloRequest);
+					
+					
+					// We place a listener from outcoming node on this client instance to this outcoming node :
+					socketToServer.receive("protocol",(message)=>{
+						if(message.type==="response.register.server.incoming"){
+							
+							// TRACE
+							lognow(`		(${self.nodeId}) Receving registering response from requested outcoming node...`);
+							
+							const welcomeNodeId=message.nodeId;
+							const duplicatesFreeAuthorizedNodesIds=[...new Set([...self.authorizedNodesIds, ...message.authorizedNodesIds, welcomeNodeId ])];
+							self.authorizedNodesIds=duplicatesFreeAuthorizedNodesIds;
+							
+							self.outcomingServers[welcomeNodeId]={clientInstance:clientInstance};
+							
+							// Once we have registered to all the outcoming nodes :
+							const currentNumberOfOutcomingServers=getArraySize(self.outcomingServers);
+							if(!self.isConnectedToCluster && theoreticNumberOfOutcomingServers<=currentNumberOfOutcomingServers){
+								//self.finalizeClusterConnection(welcomeNodeId);
+								self.finalizeClusterConnection(self.nodeId);
+								resolve(server);
+							}
+						}
+					});
+					
+					// Listeners handling ;
+					foreach(Object.keys(self.listeners), channelName=>{
+						socketToServer.receive(channelName, (message, clientSocket)=>{
+							
+							// OUTCOMING NODES LISTENERS HOOK :
+							// TRACE
+							console.log("INFO : SERVER : Outcoming node has sent a "+channelName+" message: ", message);
+							foreach(self.listeners[channelName], listener => {
+								listener.execute(self, message, self.server, clientSocket);
+							},(listener)=>(message.type===listener.messageType));
+							
+						});
+					});
+					
+					
+				}, outcomingNodeProtocol+"://"+outcomingNodeHost, outcomingNodePort, false);
+				clientInstance.client.start();
 				
 			});
 			
+		});
+	
+	}
+	
+	/*private*/finalizeClusterConnection(welcomeNodeId){
+		// TRACE
+		lognow(`		(${this.nodeId}) Propagating this new node to the whole cluster...`);
+		
+		// We propagate the new node id to the whole cluster :
+		const newNodeRequest={
+			nodeId:welcomeNodeId,
+			type:"request.node.new"
+		};
+		this.propagateToCluster(newNodeRequest);
+		
+		this.isConnectedToCluster=true;
+		
+		this.addPropagationListeners();
+		this.addPropagationForClientsListeners();
+	}
+								
+	
+
+	
+	/*public*/doOnConnectedToCluster(){
+			
+		// TRACE
+		lognow(`(${this.nodeId}) Node is connected to cluster...`);
+		
+		// The node asks the cluster for its model partition :
+		
+		// At this point, the new node does not know the state of the model in the cluster, only cluster nodes know.
+		
+		// TRACE
+		lognow(`(${this.nodeId}) Node is asking to its model partition...`);
+		
+		// New node asks for its model partition :
+		
+		// - First we need to know which server has the biggest model :
+		const modelSizeRequest={
+			type:"request.model.getSize",
+		};
+		this.propagateToCluster(modelSizeRequest);
+			
+	}
+	
+	
+	/*private*/addPropagationListeners(){
+		
+		// Adding propagation listener for acknowledging new node added to cluster :
+		this.setPropagation("cluster","request.node.new", (self, message, server, clientSocket)=>{
+			const newNodeId=message.nodeId;
+			// TRACE
+			lognow(`		(${self.nodeId}) Acknowledging new node ${newNodeId} added to cluster...`);
+			if(!contains(self.authorizedNodesIds,newNodeId))	self.authorizedNodesIds.push(newNodeId);
+		});
+
+		// Adding propagation listener if a node receives a model size request :
+		this.setPropagation("cluster","request.model.getSize",(self, message, server, clientSocket)=>{
+			const modelSize=self.model.getModelSize();
+			// TRACE
+			lognow(`(${self.nodeId}) Node gives its model size to node ${message.nodeId}, modelSize=${modelSize}...`);
+			return modelSize;
+		},"response.model.getSize");
+		
+		// Adding propagation listener :
+		this.modelSizes={};
+		this.setPropagation("cluster","response.model.getSize",(self, message, server, clientSocket)=>{
+			
+			const modelSizes=self.modelSizes;
+			const currentClusterSize=getArraySize(self.authorizedNodesIds);
+			
+			const concernedNodeId=message.nodeId;
+			const modelSize=message.result;
+			
+			let currentNumberOfAnswers=getArraySize(modelSizes);
+
+			if(currentNumberOfAnswers<=currentClusterSize-1){// -1 because we want to exclude this node also !
+				modelSizes[concernedNodeId]=modelSize;
+			}
+
+			currentNumberOfAnswers=getArraySize(modelSizes);
+			// TRACE
+			lognow(`(${self.nodeId}) Node receiving a model size from node ${message.nodeId}...currentClusterSize=${currentClusterSize} ; modelSizes:`,modelSizes);
+			if(currentClusterSize-1<=currentNumberOfAnswers){
+				const nodeIdWithBiggestModel=Math.maxInArray(modelSizes, true);
+				// TRACE
+				lognow(`(${self.nodeId}) Node with biggest model is nodeIdWithBiggestModel=${nodeIdWithBiggestModel}...`);
+				
+				const modelPartitionRequest={
+					type:"request.model.partition",
+				};
+				this.propagateToCluster(modelPartitionRequest, nodeIdWithBiggestModel);
+			}
+		});
+		
+		// Adding propagation listener :
+		// If a node receives a model partition request :
+		this.setPropagation("cluster","request.model.partition",(self, message, server, clientSocket)=>{
+			// Each node will give a little portion of its model, according to its size :					
+			// TRACE
+			lognow(`(${self.nodeId}) Node splits its model for node ${message.nodeId}...`);
+			
+			const ownModel=self.model;
+			const splittedModel=ownModel.split();
+			
+			// Node shares also its model objects directory with the newcomer node :
+			const ownModelObjectsIds=ownModel.getAllObjectsIds();
+			self.modelObjectsDirectory[self.nodeId]=ownModelObjectsIds;
+			
+			const modelString=JSON.stringifyDecycle(splittedModel);
+			const modelPartitionResponse={
+				type:"response.model.partition",
+				modelString:modelString,
+				modelObjectsDirectory:self.modelObjectsDirectory
+			};
+			this.propagateToCluster(modelPartitionResponse, message.nodeId);
+			
+			// This node also advertises that its model has changed to all other nodes (not the newcomer, because it's unnecessary) :
+			const updatemodelObjectsDirectoryRequest={
+				type:"request.update.modelObjectsDirectory",
+				ownModelObjectsIds:ownModelObjectsIds
+			};
+			this.propagateToCluster(updatemodelObjectsDirectoryRequest, null, [message.nodeId]);
+			
+		});
+
+		// Adding propagation listener :
+		this.setPropagation("cluster","response.model.partition",(self, message, server, clientSocket)=>{
+			// TRACE
+			lognow(`(${self.nodeId}) Node receives a model partition from node ${message.nodeId}...`,message);
+			
+			const newModel=JSON.parseRecycle(message.modelString);
+			self.model.replaceBy(newModel);
 			
+			// We initialize this node's model objects directory from the one froom the node tha provided it its model partition :
+			self.modelObjectsDirectory=message.modelObjectsDirectory;
 			
+			// Once this node has received its model partition, it updates its model objects directory
+			const ownModelObjectsIds=newModel.getAllObjectsIds();
+			self.modelObjectsDirectory[self.nodeId]=ownModelObjectsIds;
 			
-			////
-			// CURRENT AORTAC
+			// TRACE
+			lognow(`(${self.nodeId}) Node sends a model objects directory update request...ownModelObjectsIds=${ownModelObjectsIds}`);
 			
+			// And notifies the other nodes of the change :
+			const updatemodelObjectsDirectoryRequest={
+				type:"request.update.modelObjectsDirectory",
+				ownModelObjectsIds:ownModelObjectsIds
+			};
+			this.propagateToCluster(updatemodelObjectsDirectoryRequest);
+
+		});
+		
+		this.addModelObjectsDirectoryListeners();
+		
+		
+		// DBG
+		lognow(">>>>>>>>FOR OTHER NODES this.listeners",this.listeners);
+		
+	}
+	
+	
+	
+	/*private*/addModelObjectsDirectoryListeners(){
+		
+		const self=this;
+		
+		// Adding propagation listener :
+		// If a node receives a model objects directory update request :
+		this.setPropagation("cluster","request.update.modelObjectsDirectory",(self, message, server, clientSocket)=>{
+			
+			// TRACE
+			lognow(`(${self.nodeId}) !!!!!! Node receives a model objects directory update request from node ${message.nodeId}...`,message);
+			
+			const modelObjectsIds=message.ownModelObjectsIds;
+			self.modelObjectsDirectory[message.nodeId]=modelObjectsIds;
+
+		});
+		
+				
+		// Adding propagation listener :
+		// If a node receives a model objects directory update request :
+		this.setPropagation("cluster","request.add.modelObjectsDirectory",(self, message, server, clientSocket)=>{
+			
+			// TRACE
+			lognow(`(${self.nodeId}) !!!!!! Node receives a model objects directory add request from node ${message.nodeId}...`,message);
 			
-		},this.sslConfig.port, this.sslConfig.certPath, this.sslConfig.keyPath);
+			const newObjectsIds=message.newObjectsIds;
+			self.modelObjectsDirectory[message.nodeId].push(...newObjectsIds);
+
+		});
+		
+	}
+	
+	
+	/*public*/sendUpdatedObjects(modifiedObjects, modifiedObjectsIds){
+				
+		if(empty(modifiedObjects))	return modifiedObjects;
+
+		// Then we send back the modified objects to all the concerned clients : (which are all clients connected to this node)
+		return this.sendObjectsUpdatesToClients(modifiedObjects);
+	}
+	
+	/*public*/sendNewObjects(newObjects, newObjectsIds){
+		
+		if(empty(newObjects))	return newObjects;
+
+		// At this point, node controller has already added the objects to its model.
+		// We just want to update the objects directories of all the nodes in the cluster:
+		
+		// !!! CAUTION : NOTE THAT THE EMITTER NODE IS ALWAYS INCLUDED IN THE THE VISITED NODES !!!
+		// So this is why ir needs to update its mode objects directory itself, before sending the add request to the cluster :
+		this.modelObjectsDirectory[this.nodeId].push(...newObjectsIds);
+
+		// This node also advertises that its model has changed to all other nodes (not the newcomer, because it's unnecessary) :
+		const updatemodelObjectsDirectoryRequest={
+			type:"request.add.modelObjectsDirectory",
+			newObjectsIds:newObjectsIds
+		};
+		this.propagateToCluster(updatemodelObjectsDirectoryRequest);
+		
+		
+		// But we also want all the concerned clients to update their local models : (which are all clients connected to this node)
+		return this.sendObjectsUpdatesToClients(newObjects, true);
+	}
+	
+	/*private*/sendObjectsUpdatesToClients(modifiedOrAddedObjects, isAddingObjects=false){
+		
+		const self=this;
+		foreach(this.clients, client=>{
+			const clientSocket=client.clientSocket;
+			const objectsModifiedOrAddedClientResponse={
+				nodeId:self.nodeId,
+				type:"response.objectsModifiedOrAdded.client",
+				objectsString:JSON.stringifyDecycle(modifiedOrAddedObjects),
+				isAddingObjects:isAddingObjects,
+			};
+			self.server.send("inputs", objectsModifiedOrAddedClientResponse, null, clientSocket);
+		});
+
+		return modifiedOrAddedObjects;
+	}
+	
+	
+	
+	
+	/*private*/getNeighborsNodesIds(){
+		const neighborsNodesIds=[];
+		foreach(this.incomingServers,(incomingServer,nodeId)=>{
+			neighborsNodesIds.push(nodeId);
+		});
+		foreach(this.outcomingServers,(outcomingServer,nodeId)=>{
+			neighborsNodesIds.push(nodeId);
+		});
+		return neighborsNodesIds;
+	}
+	
+	/*private*/getLeastOccupiedNeighborNodeId(){
+		const self=this;
+	
+		// We send the new objects to the neighbor node with the least amount of objects :
+		let leastOccupiedNodeId=null;
+		foreach(this.getNeighborsNodesIds(), (nodeId)=>{
+			const entry=self.modelObjectsDirectory[nodeId];
+			const numberOfObjects=getArraySize(entry);
+			if(!leastOccupiedNodeId || numberOfObjects<getArraySize(self.modelObjectsDirectory[leastOccupiedNodeId]))
+				leastOccupiedNodeId=nodeId;
+		});
 		
+		if(!leastOccupiedNodeId){
+			// TRACE
+			lognow("WARN : Cannot find the least occupied node. Aborting.");
+		}
+		return leastOccupiedNodeId;
+	}
+
+
+	// ****************************************************************************************************
+	/*private*/setPropagation(channelName, requestType, doOnReception=null, responseRequestType=null, propagateToAllCluster=true){
+		const self=this;
+		this.setUniqueReceptionPoint(channelName, requestType, (self, message, server, clientSocket)=>{
 			
+			const requestId=message.requestId;
+			if(contains(self.executedRequestIdsHistory, requestId)){
+				// TRACE
+				lognow(`WARN : Request of type ${message.type} already answered. Aborting.`);
+				return;
+			}
+			if(message.visitedNodeIds){
+				if(contains(message.visitedNodeIds, self.nodeId)){
+					return;
+				}
+				message.visitedNodeIds.push(self.nodeId);
+			}
+			
+			const hasNoExclusionsOrExclusionDoesNotApplyOnThisNode=(!message.excludedNodesIds || !contains(message.excludedNodesIds,self.nodeId));
+			let response=null;
+			if(!message.destinationNodeId && hasNoExclusionsOrExclusionDoesNotApplyOnThisNode){
+				// Case broadcast message :
+				if(doOnReception)
+					response=doOnReception(self, message, server, clientSocket);
+				pushInArrayAsQueue(self.executedRequestIdsHistory, REQUESTS_IDS_HISTORY_SIZE, requestId);
+				if(propagateToAllCluster)	self.sendToOtherNodes(channelName, message);		
+			}else{
+				if(message.destinationNodeId===self.nodeId && hasNoExclusionsOrExclusionDoesNotApplyOnThisNode){
+					if(doOnReception)
+						response=doOnReception(self, message, server, clientSocket);
+					pushInArrayAsQueue(self.executedRequestIdsHistory, REQUESTS_IDS_HISTORY_SIZE, requestId);
+				}else{
+					if(propagateToAllCluster)	self.sendToOtherNodes(channelName, message);		
+				}
+			}
+			
+			// We send back the answer to the originating node :
+			if(response!=null && responseRequestType){
+				// TRACE
+				lognow(`(${self.nodeId}) Node sending back a response of type ${responseRequestType}...`);				
+
+				const clusterResponse={
+					type:responseRequestType,
+					result:response
+				};
+				const originNodeId=message.nodeId;
+				if(propagateToAllCluster)	self.propagateToCluster(clusterResponse, originNodeId);
+				else											self.propagateToSingleNeighbor(clusterResponse, originNodeId);
+			}
+			
+		});
+	}
+	// ****************************************************************************************************
+		
+	/*private*/propagateToCluster(request, destinationNodeId=null, excludedNodesIds=null){
+		request.requestId=getUUID();
+		const originNodeId=this.nodeId;
+		request.nodeId=originNodeId;
+		if(destinationNodeId)	request.destinationNodeId=destinationNodeId;
+		if(excludedNodesIds)	request.excludedNodesIds=excludedNodesIds;
+		request.visitedNodeIds=[originNodeId];
+		this.sendToOtherNodes("cluster",request);
+	}
+	
+	/*private*/propagateToNeighbors(request){
+		request.requestId=getUUID();
+		const originNodeId=this.nodeId;
+		request.nodeId=originNodeId;
+		this.sendToOtherNodes("neightbors", request);
+	}
+	/*private*/propagateToSingleNeighbor(request, destinationNodeId){
+		request.requestId=getUUID();
+		const originNodeId=this.nodeId;
+		request.nodeId=originNodeId;
+		request.destinationNodeId=destinationNodeId;
+		this.sendToOtherSingleNode("neightbors", request, destinationNodeId);
 	}
 	
+	// ****************************************************************************************************
+
+	/*private*/sendToOtherNodes(channelName, message){
+		let hasBeenSentIncoming=this.sendToIncomingServers(channelName, message);
+		let hasBeenSentOutcoming=this.sendToOutcomingServers(channelName, message);
+		return (hasBeenSentIncoming || hasBeenSentOutcoming);
+	}
+	/*private*/sendToIncomingServers(channelName, message){
+		const self=this;
+		let hasBeenSent=false;
+		foreach(this.incomingServers, (client)=>{
+			const clientSocket=client.clientSocket;
+			self.server.send(channelName, message, null, clientSocket);
+			hasBeenSent=true;
+		});
+		return hasBeenSent;
+	}
+	/*private*/sendToOutcomingServers(channelName, message){
+		let hasBeenSent=false;
+		foreach(this.outcomingServers, (client)=>{
+			const clientInstanceToOtherServer=client.clientInstance;
+			clientInstanceToOtherServer.client.socketToServer.send(channelName, message);
+			hasBeenSent=true;
+		});
+		return hasBeenSent;
+	}
+	/*private*/sendToOtherSingleNode(channelName, request, destinationNodeId){
+		const self=this;
+		let hasBeenSent=false;
+		foreach(this.incomingServers, (client)=>{
+			const clientSocket=client.clientSocket;
+			self.server.send(channelName, message, null, clientSocket);
+			hasBeenSent=true;
+		},(c, nodeId)=>(nodeId===destinationNodeId));
+		if(!hasBeenSent){
+			foreach(this.outcomingServers, (client)=>{
+				const clientInstanceToOtherServer=client.clientInstance;
+				clientInstanceToOtherServer.client.socketToServer.send(channelName, message);
+				hasBeenSent=true;
+			},(c, nodeId)=>(nodeId===destinationNodeId));
+		}
+		return hasBeenSent;
+	}
+
+	/*private*/setUniqueReceptionPoint(channelName, messageType, doOnReception){
+		const self=this;
+		const listeners=this.listeners[channelName];
+		if(foreach(listeners,listener=>{
+			if(listener.messageType===messageType)	return true;
+		}))	return;
+		listeners.push({
+			messageType:messageType,
+			execute:(self, message, server, clientSocket)=>{
+				doOnReception(self, message, server, clientSocket);
+			}
+		});
+	}
+	
+	// ****************************************************************************************************
+
+	/*private*/isInAuthorizedNodes(incomingServerNodeId){
+		return contains(this.authorizedNodesIds,incomingServerNodeId);
+	}
+	
+	/*public*/traceNode(){
+		// TRACE
+		lognow("-------------------------------------------------------------");
+		lognow(`(${this.nodeId}) :`,this);
+		lognow("-------------------------------------------------------------");
+	}
+	
+	
+	
 }
 
-getAORTACNode=function(selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[]){
-	return new AORTACNode(selfOrigin,outcomingNodesOrigins);
+
+getAORTACNode=function(nodeId=getUUID(), selfOrigin="ws://127.0.0.1:40000", outcomingNodesOrigins=[], model, controller){
+	return new AORTACNode(nodeId, selfOrigin, outcomingNodesOrigins, model, controller);
 }
 
 
@@ -16996,6 +18054,7 @@ getAORTACNode=function(selfOrigin="127.0.0.1:40000",outcomingNodesOrigins=[]){
 
 
 
+
 /* INCLUDED EXTERNAL LIBRAIRIES
 */
 "use strict";var sjcl={cipher:{},hash:{},keyexchange:{},mode:{},misc:{},codec:{},exception:{corrupt:function(a){this.toString=function(){return"CORRUPT: "+this.message};this.message=a},invalid:function(a){this.toString=function(){return"INVALID: "+this.message};this.message=a},bug:function(a){this.toString=function(){return"BUG: "+this.message};this.message=a},notReady:function(a){this.toString=function(){return"NOT READY: "+this.message};this.message=a}}};