added ovo 1 & 2 w/ mods

config.jsonc

@@ -478,6 +478,16 @@
             "aliases": [],
             "categories": []
         },
+        "OvO": {
+            "path": "ovo/1.4.4",
+            "aliases": [],
+            "categories": []
+        },
+        "OvO 2": {
+            "path": "ovo/2.0.2alpha",
+            "aliases": [],
+            "categories": []
+        },
         "Papas Pizzeria": {
             "path": "flash/?game=papas-pizzaria",
             "aliases": [],

games/ovo/1.4.4/Tween.js

@@ -0,0 +1,814 @@
+/**
+ * Tween.js - Licensed under the MIT license
+ * https://github.com/tweenjs/tween.js
+ * ----------------------------------------------
+ *
+ * See https://github.com/tweenjs/tween.js/graphs/contributors for the full list of contributors.
+ * Thank you all, you're awesome!
+ */
+
+var TWEEN = TWEEN || (function () {
+
+	var _tweens = [];
+
+	return {
+
+		getAll: function () {
+
+			return _tweens;
+
+		},
+
+		removeAll: function () {
+
+			_tweens = [];
+
+		},
+
+		add: function (tween) {
+
+			_tweens.push(tween);
+
+		},
+
+		remove: function (tween) {
+
+			var i = _tweens.indexOf(tween);
+
+			if (i !== -1) {
+				_tweens.splice(i, 1);
+			}
+
+		},
+
+		update: function (time, preserve) {
+
+			if (_tweens.length === 0) {
+				return false;
+			}
+
+			var i = 0;
+
+			time = time !== undefined ? time : TWEEN.now();
+
+			while (i < _tweens.length) {
+
+				if (_tweens[i].update(time) || preserve) {
+					i++;
+				} else {
+					_tweens.splice(i, 1);
+				}
+
+			}
+
+			return true;
+
+		}
+	};
+
+})();
+
+
+// Include a performance.now polyfill.
+// In node.js, use process.hrtime.
+if (typeof (window) === 'undefined' && typeof (process) !== 'undefined') {
+	TWEEN.now = function () {
+		var time = process.hrtime();
+
+		// Convert [seconds, nanoseconds] to milliseconds.
+		return time[0] * 1000 + time[1] / 1000000;
+	};
+}
+// In a browser, use window.performance.now if it is available.
+else if (typeof (window) !== 'undefined' &&
+         window.performance !== undefined &&
+		 window.performance.now !== undefined) {
+	// This must be bound, because directly assigning this function
+	// leads to an invocation exception in Chrome.
+	TWEEN.now = window.performance.now.bind(window.performance);
+}
+// Use Date.now if it is available.
+else if (Date.now !== undefined) {
+	TWEEN.now = Date.now;
+}
+// Otherwise, use 'new Date().getTime()'.
+else {
+	TWEEN.now = function () {
+		return new Date().getTime();
+	};
+}
+
+
+TWEEN.Tween = function (object) {
+
+	var _object = null;
+	if(object) _object = object;
+
+
+	var _duration = 1000;
+	var _time = 0;
+	var _startTime = null;
+
+	var _reversed = false;
+	this.isPlaying = false;
+
+	
+	var _easingFunction = TWEEN.Easing.Linear.None;
+	var _interpolationFunction = TWEEN.Interpolation.Linear;
+
+
+	var _valuesStartOrigin = null;
+	var _valuesEndOrigin = null;
+	var _valuesStart = {};
+	var _valuesEnd = {};
+
+	
+
+	var _isReset = true;
+
+
+
+	var _deltas = {};
+	var _deltas_init = {};
+
+	var _onCompleteCallback = null;
+	var _onCompleteCallbackScope = null;
+	var _onReverseCompleteCallback = null;
+	var _onReverseCompleteCallbackScope = null;
+
+	
+	this.setObject = function (object) {
+		if(object)
+			_object = object;
+	};
+
+	//Computes new deltas to tween to
+	this.to = function (properties, duration) {
+		_isReset = true;
+		if (duration !== undefined) {
+			_duration = duration;
+		}
+
+		var property, start=0, end=0;
+		for (property in properties)
+		{
+			if (_object[property] === undefined) {
+				continue;
+			}
+
+			start = _object[property];
+			end = properties[property];
+			_deltas[property] = end - start;
+			_deltas_init[property] = _deltas[property];
+		}
+
+		return this;
+	};
+
+
+	this.reverse = function () {
+
+		var property;
+		
+		if(this.isPlaying){
+			this.isPlaying = false;
+			for (property in _deltas) {
+				if(_reversed){
+					_deltas[property] = (1-_value)*_deltas[property];
+				}else{
+					_deltas[property] = _deltas_init[property]-(1-_value)*_deltas[property];
+				}
+			}
+
+			if(_reversed){
+				//console.log("start reverse, currently playing, reverse");
+			}else{
+				//console.log("start reverse, currently playing, no reverse");
+			}
+		}else{
+			//console.log("start reverse, currently not playing; ");
+			for (property in _deltas)
+			{
+				_deltas[property] = _deltas_init[property];
+			}
+		}
+
+		_isReset = false;
+		_prevValue = 0;
+		_reversed = true;
+		_time = TWEEN.now();
+		_startTime = TWEEN.now();
+		this.isPlaying = true;
+
+
+		return this;
+	};
+
+	this.start = function (time) {
+		var property;
+		
+		
+		if(this.isPlaying){
+			this.isPlaying = false;
+			
+			if(!_isReset){
+				for (property in _deltas) {
+					if(_reversed){
+						_deltas[property] = _deltas_init[property]-(1-_value)*_deltas[property];
+					}else{
+						_deltas[property] = (1-_value)*_deltas[property];
+					}
+				}
+			}
+
+
+			if(_reversed){
+				//console.log("start, currently playing, reverse");
+			}else{
+				//console.log("start, currently playing, no reverse");
+			}
+		}else{
+			//console.log("start, currently not playing; ");
+			for (property in _deltas)
+			{
+				_deltas[property] = _deltas_init[property];
+			}
+		}
+
+
+		
+		_isReset = false;
+		_reversed = false;
+		_prevValue = 0;
+		_time = TWEEN.now();
+		_startTime = _time;
+		this.isPlaying = true;
+
+		
+		return this;
+	};
+
+
+	
+	
+	var _value = 0; //from 0 to 1 ; output of the tween function
+	var _dvalue = 0; //delta _value and the one of the previous dt
+	var _prevValue = 0; //_value of the previous dt
+
+	this.update = function (dt) {
+
+		var property;
+		var elapsed; //% of the duration; from 0 to 1;
+
+		_time = _time + dt;
+		if (_time < _startTime) {
+			return true;
+		}
+		elapsed = (_time - _startTime) / _duration;
+		elapsed = elapsed > 1 ? 1 : elapsed;
+
+
+		_value = _easingFunction(elapsed);
+		_dvalue = _value - _prevValue;
+		_prevValue = _value;
+		
+		var dv = 0;
+
+		for (property in _deltas) {
+			if(_reversed){
+				_object[property] += -_dvalue*_deltas[property];
+			}else{
+				_object[property] += _dvalue*_deltas[property];	
+			}
+			
+
+			/*_object[property] = start + dValues[property] * value;
+			dv = (start + (end - start) * value) - _object[property];*/
+		}
+
+
+
+		if (elapsed === 1) {
+			if (_onCompleteCallback !== null && !_reversed) {
+				if(_onCompleteCallbackScope!=null){
+					_onCompleteCallback.call(_onCompleteCallbackScope);
+				}else{
+					_onCompleteCallback.call(_object, _object);	
+				}
+				
+			}
+
+			if ((_onReverseCompleteCallback !== null) && _reversed) {
+				if(_onReverseCompleteCallbackScope!=null){
+					_onReverseCompleteCallback.call(_onReverseCompleteCallbackScope);
+				}else{
+					_onReverseCompleteCallback.call(_object, _object);
+				}
+			}
+
+			this.isPlaying = false;
+			return false;
+		}
+
+		return true;
+
+	};
+
+
+
+
+
+
+	this.onComplete = function (callback,scope) {
+		_onCompleteCallback = callback;
+		_onCompleteCallbackScope = scope;
+		return this;
+	};
+
+	this.onReverseComplete = function (callback,scope) {
+
+		_onReverseCompleteCallback = callback;
+		_onReverseCompleteCallbackScope = scope;
+		return this;
+
+	};
+
+
+	this.easing = function (easing) {
+
+		_easingFunction = easing;
+		return this;
+
+	};
+
+	this.interpolation = function (interpolation) {
+
+		_interpolationFunction = interpolation;
+		return this;
+
+	};
+
+};
+
+TWEEN.Easing = {
+
+	Linear: {
+
+		None: function (k) {
+
+			return k;
+
+		}
+
+	},
+
+	Quadratic: {
+
+		In: function (k) {
+
+			return k * k;
+
+		},
+
+		Out: function (k) {
+
+			return k * (2 - k);
+
+		},
+
+		InOut: function (k) {
+
+			if ((k *= 2) < 1) {
+				return 0.5 * k * k;
+			}
+
+			return - 0.5 * (--k * (k - 2) - 1);
+
+		}
+
+	},
+
+	Cubic: {
+
+		In: function (k) {
+
+			return k * k * k;
+
+		},
+
+		Out: function (k) {
+
+			return --k * k * k + 1;
+
+		},
+
+		InOut: function (k) {
+
+			if ((k *= 2) < 1) {
+				return 0.5 * k * k * k;
+			}
+
+			return 0.5 * ((k -= 2) * k * k + 2);
+
+		}
+
+	},
+
+	Quartic: {
+
+		In: function (k) {
+
+			return k * k * k * k;
+
+		},
+
+		Out: function (k) {
+
+			return 1 - (--k * k * k * k);
+
+		},
+
+		InOut: function (k) {
+
+			if ((k *= 2) < 1) {
+				return 0.5 * k * k * k * k;
+			}
+
+			return - 0.5 * ((k -= 2) * k * k * k - 2);
+
+		}
+
+	},
+
+	Quintic: {
+
+		In: function (k) {
+
+			return k * k * k * k * k;
+
+		},
+
+		Out: function (k) {
+
+			return --k * k * k * k * k + 1;
+
+		},
+
+		InOut: function (k) {
+
+			if ((k *= 2) < 1) {
+				return 0.5 * k * k * k * k * k;
+			}
+
+			return 0.5 * ((k -= 2) * k * k * k * k + 2);
+
+		}
+
+	},
+
+	Sinusoidal: {
+
+		In: function (k) {
+
+			return 1 - Math.cos(k * Math.PI / 2);
+
+		},
+
+		Out: function (k) {
+
+			return Math.sin(k * Math.PI / 2);
+
+		},
+
+		InOut: function (k) {
+
+			return 0.5 * (1 - Math.cos(Math.PI * k));
+
+		}
+
+	},
+
+	Exponential: {
+
+		In: function (k) {
+
+			return k === 0 ? 0 : Math.pow(1024, k - 1);
+
+		},
+
+		Out: function (k) {
+
+			return k === 1 ? 1 : 1 - Math.pow(2, - 10 * k);
+
+		},
+
+		InOut: function (k) {
+
+			if (k === 0) {
+				return 0;
+			}
+
+			if (k === 1) {
+				return 1;
+			}
+
+			if ((k *= 2) < 1) {
+				return 0.5 * Math.pow(1024, k - 1);
+			}
+
+			return 0.5 * (- Math.pow(2, - 10 * (k - 1)) + 2);
+
+		}
+
+	},
+
+	Circular: {
+
+		In: function (k) {
+
+			return 1 - Math.sqrt(1 - k * k);
+
+		},
+
+		Out: function (k) {
+
+			return Math.sqrt(1 - (--k * k));
+
+		},
+
+		InOut: function (k) {
+
+			if ((k *= 2) < 1) {
+				return - 0.5 * (Math.sqrt(1 - k * k) - 1);
+			}
+
+			return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+
+		}
+
+	},
+
+	Elastic: {
+
+		In: function (k) {
+
+			if (k === 0) {
+				return 0;
+			}
+
+			if (k === 1) {
+				return 1;
+			}
+
+			return -Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
+
+		},
+
+		Out: function (k) {
+
+			if (k === 0) {
+				return 0;
+			}
+
+			if (k === 1) {
+				return 1;
+			}
+
+			return Math.pow(2, -10 * k) * Math.sin((k - 0.1) * 5 * Math.PI) + 1;
+
+		},
+
+		InOut: function (k) {
+
+			if (k === 0) {
+				return 0;
+			}
+
+			if (k === 1) {
+				return 1;
+			}
+
+			k *= 2;
+
+			if (k < 1) {
+				return -0.5 * Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
+			}
+
+			return 0.5 * Math.pow(2, -10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI) + 1;
+
+		}
+
+	},
+
+	Back: {
+
+		In: function (k) {
+
+			var s = 1.70158;
+
+			return k * k * ((s + 1) * k - s);
+
+		},
+
+		Out: function (k) {
+
+			var s = 1.70158;
+
+			return --k * k * ((s + 1) * k + s) + 1;
+
+		},
+
+		InOut: function (k) {
+
+			var s = 1.70158 * 1.525;
+
+			if ((k *= 2) < 1) {
+				return 0.5 * (k * k * ((s + 1) * k - s));
+			}
+
+			return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+
+		}
+
+	},
+
+	Bounce: {
+
+		In: function (k) {
+
+			return 1 - TWEEN.Easing.Bounce.Out(1 - k);
+
+		},
+
+		Out: function (k) {
+
+			if (k < (1 / 2.75)) {
+				return 7.5625 * k * k;
+			} else if (k < (2 / 2.75)) {
+				return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75;
+			} else if (k < (2.5 / 2.75)) {
+				return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375;
+			} else {
+				return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375;
+			}
+
+		},
+
+		InOut: function (k) {
+
+			if (k < 0.5) {
+				return TWEEN.Easing.Bounce.In(k * 2) * 0.5;
+			}
+
+			return TWEEN.Easing.Bounce.Out(k * 2 - 1) * 0.5 + 0.5;
+
+		}
+
+	}
+
+};
+
+TWEEN.Interpolation = {
+
+	Linear: function (v, k) {
+
+		var m = v.length - 1;
+		var f = m * k;
+		var i = Math.floor(f);
+		var fn = TWEEN.Interpolation.Utils.Linear;
+
+		if (k < 0) {
+			return fn(v[0], v[1], f);
+		}
+
+		if (k > 1) {
+			return fn(v[m], v[m - 1], m - f);
+		}
+
+		return fn(v[i], v[i + 1 > m ? m : i + 1], f - i);
+
+	},
+
+	Bezier: function (v, k) {
+
+		var b = 0;
+		var n = v.length - 1;
+		var pw = Math.pow;
+		var bn = TWEEN.Interpolation.Utils.Bernstein;
+
+		for (var i = 0; i <= n; i++) {
+			b += pw(1 - k, n - i) * pw(k, i) * v[i] * bn(n, i);
+		}
+
+		return b;
+
+	},
+
+	CatmullRom: function (v, k) {
+
+		var m = v.length - 1;
+		var f = m * k;
+		var i = Math.floor(f);
+		var fn = TWEEN.Interpolation.Utils.CatmullRom;
+
+		if (v[0] === v[m]) {
+
+			if (k < 0) {
+				i = Math.floor(f = m * (1 + k));
+			}
+
+			return fn(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
+
+		} else {
+
+			if (k < 0) {
+				return v[0] - (fn(v[0], v[0], v[1], v[1], -f) - v[0]);
+			}
+
+			if (k > 1) {
+				return v[m] - (fn(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
+			}
+
+			return fn(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
+
+		}
+
+	},
+
+	Utils: {
+
+		Linear: function (p0, p1, t) {
+
+			return (p1 - p0) * t + p0;
+
+		},
+
+		Bernstein: function (n, i) {
+
+			var fc = TWEEN.Interpolation.Utils.Factorial;
+
+			return fc(n) / fc(i) / fc(n - i);
+
+		},
+
+		Factorial: (function () {
+
+			var a = [1];
+
+			return function (n) {
+
+				var s = 1;
+
+				if (a[n]) {
+					return a[n];
+				}
+
+				for (var i = n; i > 1; i--) {
+					s *= i;
+				}
+
+				a[n] = s;
+				return s;
+
+			};
+
+		})(),
+
+		CatmullRom: function (p0, p1, p2, p3, t) {
+
+			var v0 = (p2 - p0) * 0.5;
+			var v1 = (p3 - p1) * 0.5;
+			var t2 = t * t;
+			var t3 = t * t2;
+
+			return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (- 3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+
+		}
+
+	}
+
+};
+
+// UMD (Universal Module Definition)
+(function (root) {
+
+	if (typeof define === 'function' && define.amd) {
+
+		// AMD
+		define([], function () {
+			return TWEEN;
+		});
+
+	} else if (typeof module !== 'undefined' && typeof exports === 'object') {
+
+		// Node.js
+		module.exports = TWEEN;
+
+	} else if (root !== undefined) {
+
+		// Global variable
+		root.TWEEN = TWEEN;
+
+	}
+
+})(this);

games/ovo/1.4.4/achievements.json

@@ -0,0 +1,222 @@
+[
+  {
+    "name": "OvO",
+    "description": "What's this?",
+    "hidden": false,
+    "icon": "ovo.png",
+    "callback": "Skins > Gold",
+    "params": "5,achievements,0",
+    "divider": ",",
+    "type": "n,s,n"
+  },
+  {
+    "name": "Hittin da head",
+    "description": "Stop it please",
+    "hidden": true,
+    "icon": "ovo2.png",
+    "callback": "Skins > Gold",
+    "params": "10,achievements,1",
+    "divider": ",",
+    "type": "n,s,n"
+  },
+  {
+    "name": "Hurtin da head",
+    "description": ":(",
+    "hidden": true,
+    "icon": "ovo3.png",
+    "callback": "Skins > Gold",
+    "params": "20,achievements,2",
+    "divider": ",",
+    "type": "n,s,n"
+  },
+  {
+    "name": "Tutorials",
+    "description": "Finish the tutorial section",
+    "hidden": false,
+    "icon": "tutorials.png",
+    "callback": "Skins > Gold",
+    "params": "5,achievements,3",
+    "divider": ",",
+    "type": "n,s,n"
+  },
+  {
+    "name": "Getting Serious",
+    "description": "Finish the getting serious section",
+    "hidden": false,
+    "icon": "gettingserious.png",
+    "callback": "Skins > Gold",
+    "params": "5,achievements,3",
+    "divider": ",",
+    "type": "n,s,n"
+  },
+  {
+    "name": "Higher Order",
+    "description": "Finish the higher order section",
+    "hidden": false,
+    "icon": "higherorder.png",
+    "callback": "Skins > Unlock",
+    "params": "4",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Mechanics",
+    "description": "Finish the mechanics section",
+    "hidden": false,
+    "icon": "mechanics.png",
+    "callback": "Skins > Unlock",
+    "params": "1",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "OvO Space Program",
+    "description": "Finish the OvO Space Program section",
+    "hidden": false,
+    "icon": "ovospaceprogram.png",
+    "callback": "Skins > Unlock",
+    "params": "8",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "A mystical journey",
+    "description": "Finish the Journey through the portal section",
+    "hidden": false,
+    "icon": "jttp.png",
+    "callback": "Skins > Unlock",
+    "params": "14",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Community Work",
+    "description": "Finish the Community levels",
+    "hidden": false,
+    "icon": "community.png",
+    "callback": "Skins > Unlock",
+    "params": "15",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Purified",
+    "description": "Finish every level",
+    "hidden": false,
+    "icon": "purified.png",
+    "callback": "Skins > Unlock",
+    "params": "11",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Coins!",
+    "description": "Collect a coin",
+    "hidden": false,
+    "icon": "coin.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": ""
+  },
+  {
+    "name": "Coin enthusiast",
+    "description": "Collect 5 coins",
+    "hidden": false,
+    "icon": "coin5.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": ""
+  },
+  {
+    "name": "Coin connoisseur",
+    "description": "Collect 10 coins",
+    "hidden": false,
+    "icon": "coin10.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": ""
+  },
+  {
+    "name": "Coin hunter",
+    "description": "Collect 30 coins",
+    "hidden": false,
+    "icon": "coin30.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Coin god",
+    "description": "Collect 40 coins",
+    "hidden": false,
+    "icon": "coin40.png",
+    "callback": "Skins > Unlock",
+    "params": "7",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Secret Coin",
+    "description": "Collect the secret coin",
+    "hidden": true,
+    "icon": "coinsecret.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Runner",
+    "description": "Finish OvO in less than 30mn",
+    "hidden": false,
+    "icon": "runner.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Speedrunner",
+    "description": "Finish OvO in less than 20mn",
+    "hidden": false,
+    "icon": "speedrunner.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Velocity master",
+    "description": "Finish OvO in less than 15mn",
+    "hidden": false,
+    "icon": "velocity.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Top charts",
+    "description": "Finish OvO in less than 12mn",
+    "hidden": false,
+    "icon": "topcharts.png",
+    "callback": "Skins > Unlock",
+    "params": "13",
+    "divider": ",",
+    "type": "n"
+  },
+  {
+    "name": "Light speed",
+    "description": "Finish OvO in less than 10mn",
+    "hidden": false,
+    "icon": "lightspeed.png",
+    "callback": "",
+    "params": "",
+    "divider": ",",
+    "type": "n"
+  }
+]

games/ovo/1.4.4/fonts.css

@@ -0,0 +1,9 @@
+/* @font-face {
+  font-family: Silver;
+  src: url(./silver.ttf);
+} */
+
+@font-face {
+  font-family: Retron2000;
+  src: url(./retron2000.ttf);
+}

games/ovo/1.4.4/hmmg_layoutTransition.css

@@ -0,0 +1,57 @@
+#c2canvasdiv.prepared
+{
+	position:absolute !important;
+	margin:0px !important;
+	z-index:49;
+}
+
+#fakeBody
+{
+	position:absolute;
+	z-index:999999999;	
+	overflow:hidden !important;
+}
+
+ 
+#fakeBody #fakeCanvas
+{
+	position:absolute;
+	top:0px;
+	z-index:50;
+	overflow:hidden !important;
+	height:100%;
+	width:100%;
+}
+
+
+#fakeCanvas div
+{
+	position:absolute;
+	width:100%;
+	height:100%;
+	top:0px;
+	left:0px;
+}
+#fakeCanvas div.darker
+{
+    -webkit-transition: background-color 100ms linear ;
+    -moz-transition: background-color 100ms linear ;
+    -o-transition: background-color 100ms linear ;
+    -ms-transition: background-color 100ms linear ;
+    transition: background-color 100ms linear ;
+	background-color:rgba(0,0,0,0.3);
+}
+
+#c2canvasdiv.animated
+{
+	z-index:51;
+}
+#fakeCanvas.animated
+{
+	z-index:49;
+}
+
+.hidden
+{
+	display:none;
+}