diff --git a/js/battle-beta.js b/js/battle-beta.js
new file mode 100644
index 000000000..39e529603
--- /dev/null
+++ b/js/battle-beta.js
@@ -0,0 +1,5361 @@
+/*
+
+License: GPLv2
+  <http://www.gnu.org/licenses/gpl-2.0.html>
+
+*/
+
+// par: -webkit-filter:  sepia(100%) hue-rotate(373deg) saturate(592%);
+//      -webkit-filter:  sepia(100%) hue-rotate(22deg) saturate(820%) brightness(29%);
+// psn: -webkit-filter:  sepia(100%) hue-rotate(618deg) saturate(285%);
+// brn: -webkit-filter:  sepia(100%) hue-rotate(311deg) saturate(469%);
+// slp: -webkit-filter:  grayscale(100%);
+// frz: -webkit-filter:  sepia(100%) hue-rotate(154deg) saturate(759%) brightness(23%);
+
+$.extend($.easing, {
+	ballisticUp: function (x, t, b, c, d) {
+		return -3 * x * x + 4 * x;
+	},
+	ballisticDown: function (x, t, b, c, d) {
+		x = 1 - x;
+		return 1 - (-3 * x * x + 4 * x);
+	},
+	quadUp: function (x, t, b, c, d) {
+		x = 1 - x;
+		return 1 - (x * x);
+	},
+	quadDown: function (x, t, b, c, d) {
+		return x * x;
+	}
+});
+
+function BattleSoundLibrary() {
+	// options
+	this.effectVolume = 50;
+	this.bgmVolume = 50;
+	this.muted = false;
+
+	// effects
+	this.effectCache = {};
+	this.loadEffect = function(url) {
+		if (this.effectCache[url] && this.effectCache[url] !== this.soundPlaceholder) {
+			return this.effectCache[url];
+		}
+		try {
+			this.effectCache[url] = soundManager.createSound({
+				id: url,
+				url: Tools.resourcePrefix + url,
+				volume: this.effectVolume
+			});
+		} catch (e) {}
+		if (!this.effectCache[url]) {
+			this.effectCache[url] = this.soundPlaceholder;
+		}
+		return this.effectCache[url];
+	};
+	this.playEffect = function(url) {
+		if (!this.muted) this.loadEffect(url).setVolume(this.effectVolume).play();
+	};
+
+	// bgm
+	this.bgmCache = {};
+	this.bgm = null;
+	this.loadBgm = function(url, loopstart, loopend) {
+		if (this.bgmCache[url]) {
+			if (this.bgmCache[url] !== this.soundPlaceholder || loopstart === undefined) {
+				return this.bgmCache[url];
+			}
+		}
+		try {
+			this.bgmCache[url] = soundManager.createSound({
+				id: url,
+				url: Tools.resourcePrefix + url,
+				volume: this.bgmVolume
+			});
+		} catch (e) {}
+		if (!this.bgmCache[url]) {
+			// couldn't load
+			// suppress crash
+			return this.bgmCache[url] = this.soundPlaceholder;
+		}
+		this.bgmCache[url].onposition(loopend, function() {
+			this.setPosition(loopstart);
+		});
+		return this.bgmCache[url];
+	};
+	this.playBgm = function(url, loopstart, loopstop) {
+		if (this.bgm === this.loadBgm(url, loopstart, loopstop)) {
+			if (!this.bgm.paused && this.bgm.playState) {
+				return;
+			}
+		} else {
+			this.stopBgm();
+		}
+		try {
+			this.bgm = this.loadBgm(url, loopstart, loopstop).setVolume(this.bgmVolume);
+			if (!this.muted) {
+				if (this.bgm.paused) {
+					this.bgm.resume();
+				} else {
+					this.bgm.play();
+				}
+			}
+		} catch(e) {}
+	};
+	this.pauseBgm = function() {
+		if (this.bgm) {
+			this.bgm.pause();
+		}
+	};
+	this.stopBgm = function() {
+		if (this.bgm) {
+			this.bgm.stop();
+			this.bgm = null;
+		}
+	};
+
+	// setting
+	this.setMute = function(muted) {
+		muted = !!muted;
+		if (this.muted == muted) return;
+		this.muted = muted;
+		if (muted) {
+			if (this.bgm) this.bgm.pause();
+		} else {
+			if (this.bgm) this.bgm.play();
+		}
+	};
+	this.setBgmVolume = function(bgmVolume) {
+		this.bgmVolume = bgmVolume;
+		if (this.bgm) {
+			try {
+				this.bgm.setVolume(bgmVolume);
+			} catch (e) {}
+		}
+	};
+	this.setEffectVolume = function(effectVolume) {
+		this.effectVolume = effectVolume;
+	};
+
+	// misc
+	this.soundPlaceholder = {
+		play: function(){ return this; },
+		pause: function(){ return this; },
+		stop: function(){ return this; },
+		resume: function(){ return this; },
+		setVolume: function(){ return this; }
+	};
+}
+var BattleSound = new BattleSoundLibrary();
+
+function Pokemon(species) {
+	var selfP = this;
+
+	this.atk = 0;
+	this.def = 0;
+	this.spa = 0;
+	this.spd = 0;
+	this.spe = 0;
+
+	this.atkStat = 0;
+	this.defStat = 0;
+	this.spaStat = 0;
+	this.spdStat = 0;
+	this.speStat = 0;
+
+	this.boosts = {};
+
+	this.hp = 0;
+	this.maxhp = 0;
+	this.hpcolor = '';
+	this.moves = [];
+	this.ability = '';
+	this.item = '';
+	this.species = species;
+	this.side = null;
+	this.fainted = false;
+	this.zerohp = false;
+
+	this.status = '';
+	this.statusStage = 0;
+	this.volatiles = {};
+	this.turnstatuses = {};
+	this.movestatuses = {};
+	this.lastmove = '';
+
+	this.name = '';
+	this.species = '';
+	this.id = '';
+	this.statbarElem = null;
+
+	this.getHPColor = function () {
+		if (selfP.hpcolor) return selfP.hpcolor;
+		var ratio = selfP.hp / selfP.maxhp;
+		if (ratio > 0.5) return 'g';
+		if (ratio > 0.2) return 'y';
+		return 'r';
+	};
+	this.getHPColorClass = function () {
+		switch (selfP.getHPColor()) {
+			case 'y': return ' hpbar-yellow';
+			case 'r': return ' hpbar-red';
+		}
+		return '';
+	};
+	var epsilon = 0.5/714;
+	this.getPixelRange = function (pixels, color) {
+		if (pixels === 0) {
+			return [0, 0];
+		} else if (pixels === 1) {
+			return [0 + epsilon, 2/48 - epsilon];
+		} else if (pixels === 9) {
+			if (color === 'y') { // ratio is > 0.2
+				return [0.2 + epsilon, 10/48 - epsilon];
+			} else { // ratio is <= 0.2
+				return [9/48, 0.2];
+			}
+		} else if (pixels === 24) {
+			if (color === 'g') { // ratio is > 0.5
+				return [0.5 + epsilon, 25/48 - epsilon];
+			} else { // ratio is exactly 0.5
+				return [0.5, 0.5];
+			}
+		} else if (pixels === 48) {
+			return [1, 1];
+		} else {
+			return [pixels/48, (pixels + 1)/48 - epsilon];
+		}
+	};
+	this.getFormattedRange = function (range, precision, separator) {
+		if (range[0] === range[1]) {
+			var percentage = Math.abs(range[0] * 100);
+			if (Math.floor(percentage) === percentage) {
+				return percentage + '%';
+			}
+			return percentage.toFixed(precision) + '%';
+		}
+		var lower, upper;
+		if (precision === 0) {
+			lower = Math.floor(range[0] * 100);
+			upper = Math.ceil(range[1] * 100);
+		} else {
+			lower = (range[0] * 100).toFixed(precision);
+			upper = (range[1] * 100).toFixed(precision);
+		}
+		return lower + separator + upper + '%';
+	};
+	this.getDamageRange = function (damage) {
+		if (damage[1] !== 48) {
+			var ratio = damage[0] / damage[1];
+			return [ratio, ratio];
+		} else if (damage[3] === undefined) {
+			// wrong pixel damage.
+			// this case exists for backward compatibility only.
+			return [damage[2] / 100, damage[2] / 100];
+		}
+		// pixel damage
+		var oldrange = selfP.getPixelRange(damage[3], damage[4]);
+		var newrange = selfP.getPixelRange(damage[3] + damage[0], selfP.hpcolor);
+		if (damage[0] === 0) {
+			// no change in displayed pixel width
+			return [0, newrange[1] - newrange[0]];
+		}
+		if (oldrange[0] < newrange[0]) { // swap order
+			var r = oldrange;
+			oldrange = newrange;
+			newrange = r;
+		}
+		return [oldrange[0] - newrange[1], oldrange[1] - newrange[0]];
+	};
+	// returns [delta, denominator, percent(, oldnum, oldcolor)] or false
+	this.healthParse = function (hpstring, parsedamage, heal) {
+		if (!hpstring || !hpstring.length) return false;
+		var parenIndex = hpstring.lastIndexOf('(');
+		if (parenIndex >= 0) {
+			// old style damage and health reporting
+			if (parsedamage) {
+				var damage = parseFloat(hpstring);
+				// unusual check preseved for backward compatbility
+				if (isNaN(damage)) damage = 50;
+				if (heal) {
+					selfP.hp += selfP.maxhp * damage / 100;
+					if (selfP.hp > selfP.maxhp) selfP.hp = selfP.maxhp;
+				} else {
+					selfP.hp -= selfP.maxhp * damage / 100;
+				}
+				// parse the absolute health information
+				var ret = this.healthParse(hpstring);
+				if (ret && (ret[1] === 100)) {
+					// support for old replays with nearest-100th damage and health
+					return [damage, 100, damage];
+				}
+				// complicated expressions preserved for backward compatibility
+				var percent = Math.round(Math.ceil(damage * 48 / 100) / 48 * 100);
+				var pixels = Math.ceil(damage * 48 / 100);
+				return [pixels, 48, percent];
+			}
+			if (hpstring.substr(hpstring.length-1) !== ')') {
+				return false;
+			}
+			hpstring = hpstring.substr(parenIndex+1, hpstring.length-parenIndex-2);
+		}
+
+		var hp = hpstring.split(' ');
+		var status = hp[1];
+		hp = hp[0];
+		var oldhp = (selfP.zerohp || selfP.fainted) ? 0 : (selfP.hp || 1);
+		var oldmaxhp = selfP.maxhp;
+		var oldwidth = selfP.hpWidth(100);
+		var oldcolor = selfP.hpcolor;
+
+		// hp parse
+		selfP.hpcolor = '';
+		if (hp === '0' || hp === '0.0') {
+			selfP.hp = 0;
+			selfP.zerohp = true;
+		} else if (hp.indexOf('/') > 0) {
+			var hp = hp.split('/');
+			if (isNaN(parseFloat(hp[0])) || isNaN(parseFloat(hp[1]))) {
+				return false;
+			}
+			selfP.hp = parseFloat(hp[0]);
+			selfP.maxhp = parseFloat(hp[1]);
+			if (oldmaxhp === 0) { // max hp not known before parsing this message
+				oldmaxhp = oldhp = selfP.maxhp;
+			}
+			if (selfP.hp > selfP.maxhp) selfP.hp = selfP.maxhp;
+			var colorchar = hp[1].substr(hp[1].length - 1);
+			if ((colorchar === 'y') || (colorchar === 'g')) {
+				selfP.hpcolor = colorchar;
+			}
+			if (!selfP.hp) {
+				selfP.zerohp = true;
+			}
+		} else if (!isNaN(parseFloat(hp))) {
+			selfP.hp = selfP.maxhp * parseFloat(hp) / 100;
+		}
+
+		// status parse
+		if (!status) {
+			selfP.status = '';
+		} else if (status === 'par' || status === 'brn' || status === 'slp' || status === 'frz' || status === 'tox') {
+			selfP.status = status;
+		} else if (status === 'psn' && selfP.status !== 'tox') {
+			selfP.status = status;
+		} else if (status === 'fnt') {
+			selfP.hp = 0;
+			selfP.zerohp = true;
+			selfP.fainted = true;
+		}
+
+		var oldnum = oldhp ? (Math.floor(oldhp / oldmaxhp * selfP.maxhp) || 1) : 0;
+		var delta = selfP.hp - oldnum;
+		var deltawidth = selfP.hpWidth(100) - oldwidth;
+		return [delta, selfP.maxhp, deltawidth, oldnum, oldcolor];
+	};
+	this.checkDetails = function(details, ident) {
+		if (details === selfP.details) return true;
+		if (selfP.details.indexOf('-*') >= 0) {
+			selfP.needsReplace = true;
+			details = details.replace(/-[A-Za-z0-9]+(, |$)/, '$1');
+			return (details === selfP.details.replace(/-[A-Za-z0-9*]+(, |$)/, '$1'));
+		}
+		return false;
+	};
+	this.getIdent = function() {
+		if (selfP.side.active.length === 1) return selfP.ident;
+		var slots = ['a','b','c','d','e','f'];
+		return selfP.ident.substr(0,2) + slots[selfP.slot] + selfP.ident.substr(2);
+	};
+	this.removeVolatile = function (volatile) {
+		if (!selfP.hasVolatile(volatile)) return;
+		if (volatile === 'formechange') {
+			selfP.sprite.removeTransform();
+		}
+		if (selfP.volatiles[volatile][1]) selfP.volatiles[volatile][1].remove();
+		delete selfP.volatiles[volatile];
+	};
+	this.addVolatile = function (volatile) {
+		var self = selfP.side.battle;
+		if (selfP.hasVolatile(volatile)) return;
+		selfP.volatiles[volatile] = [volatile, null];
+		if (volatile === 'leechseed') {
+			selfP.side.battle.spriteElemsFront[selfP.side.n].append('<img src="' + Tools.resourcePrefix + 'fx/energyball.png" style="display:none;position:absolute" />');
+			var curelem = selfP.side.battle.spriteElemsFront[selfP.side.n].children().last();
+			curelem.css(self.pos({
+				display: 'block',
+				x: selfP.sprite.x - 30,
+				y: selfP.sprite.y - 40,
+				z: selfP.sprite.z,
+				scale: .2,
+				opacity: .6
+			}, BattleEffects.energyball));
+			var elem = curelem;
+
+			selfP.side.battle.spriteElemsFront[selfP.side.n].append('<img src="' + Tools.resourcePrefix + 'fx/energyball.png" style="display:none;position:absolute" />');
+			curelem = selfP.side.battle.spriteElemsFront[selfP.side.n].children().last();
+			curelem.css(self.pos({
+				display: 'block',
+				x: selfP.sprite.x + 40,
+				y: selfP.sprite.y - 35,
+				z: selfP.sprite.z,
+				scale: .2,
+				opacity: .6
+			}, BattleEffects.energyball));
+			elem = elem.add(curelem);
+
+			selfP.side.battle.spriteElemsFront[selfP.side.n].append('<img src="' + Tools.resourcePrefix + 'fx/energyball.png" style="display:none;position:absolute" />');
+			curelem = selfP.side.battle.spriteElemsFront[selfP.side.n].children().last();
+			curelem.css(self.pos({
+				display: 'block',
+				x: selfP.sprite.x + 20,
+				y: selfP.sprite.y - 25,
+				z: selfP.sprite.z,
+				scale: .2,
+				opacity: .6
+			}, BattleEffects.energyball));
+			elem = elem.add(curelem);
+			selfP.volatiles[volatile][1] = elem;
+		}
+	};
+	this.hasVolatile = function (volatile) {
+		return !!selfP.volatiles[volatile];
+	};
+	this.removeTurnstatus = function (volatile) {
+		if (!selfP.hasTurnstatus(volatile)) return;
+		if (selfP.turnstatuses[volatile][1]) selfP.turnstatuses[volatile][1].remove();
+		delete selfP.turnstatuses[volatile];
+	};
+	this.addTurnstatus = function (volatile) {
+		volatile = toId(volatile);
+		var self = selfP.side.battle;
+		if (selfP.hasTurnstatus(volatile)) {
+			if (volatile === 'protect' || volatile === 'magiccoat') {
+				selfP.turnstatuses[volatile][1].css(self.pos({
+					x: selfP.sprite.x,
+					y: selfP.sprite.y,
+					z: selfP.sprite.behind(-15),
+					xscale: 1 * 1.2,
+					yscale: .7 * 1.2,
+					opacity: 1
+				}, BattleEffects.none), 300).animate(self.pos({
+					x: selfP.sprite.x,
+					y: selfP.sprite.y,
+					z: selfP.sprite.behind(-15),
+					xscale: 1,
+					yscale: .7,
+					opacity: .4
+				}, BattleEffects.none), 300);
+			}
+			return;
+		}
+		selfP.turnstatuses[volatile] = [volatile, null];
+		if (volatile === 'protect' || volatile === 'magiccoat') {
+			selfP.side.battle.spriteElemsFront[selfP.side.n].append('<div class="turnstatus-protect" style="display:none;position:absolute" />');
+			var elem = selfP.side.battle.spriteElemsFront[selfP.side.n].children().last();
+			elem.css(self.pos({
+				display: 'block',
+				x: selfP.sprite.x,
+				y: selfP.sprite.y,
+				z: selfP.sprite.behind(-15),
+				xscale: 1,
+				yscale: 0,
+				opacity: .1
+			}, BattleEffects.none)).animate(self.pos({
+				x: selfP.sprite.x,
+				y: selfP.sprite.y,
+				z: selfP.sprite.behind(-15),
+				xscale: 1,
+				yscale: .7,
+				opacity: .9
+			}, BattleEffects.none), 300).animate({
+				opacity: .4
+			}, 300);
+			selfP.turnstatuses[volatile][1] = elem;
+		}
+	};
+	this.hasTurnstatus = function (volatile) {
+		return !!selfP.turnstatuses[volatile];
+	};
+	this.clearTurnstatuses = function () {
+		for (i in selfP.turnstatuses) {
+			selfP.removeTurnstatus(i);
+		}
+		selfP.turnstatuses = {};
+	};
+	this.removeMovestatus = function (volatile) {
+		if (!selfP.hasMovestatus(volatile)) return;
+		if (selfP.movestatuses[volatile][1]) selfP.movestatuses[volatile][1].remove();
+		delete selfP.movestatuses[volatile];
+	};
+	this.addMovestatus = function (volatile) {
+		volatile = toId(volatile);
+		var self = selfP.side.battle;
+		if (selfP.hasMovestatus(volatile)) {
+			return;
+		}
+		selfP.movestatuses[volatile] = [volatile, null];
+	};
+	this.hasMovestatus = function (volatile) {
+		return !!selfP.movestatuses[volatile];
+	};
+	this.clearMovestatuses = function () {
+		for (i in selfP.movestatuses) {
+			selfP.removeMovestatus(i);
+		}
+		selfP.movestatuses = {};
+	};
+	this.clearVolatiles = function () {
+		for (i in selfP.volatiles) {
+			selfP.removeVolatile(i);
+		}
+		selfP.volatiles = {};
+		selfP.clearTurnstatuses();
+		selfP.clearMovestatuses();
+	};
+	this.getName = function () {
+		if (selfP.side.n === 0) {
+			return Tools.escapeHTML(selfP.name);
+		} else {
+			return "The opposing " + Tools.escapeHTML(selfP.name);
+		}
+	};
+	this.getLowerName = function () {
+		if (selfP.side.n === 0) {
+			return Tools.escapeHTML(selfP.name);
+		} else {
+			return "the opposing " + Tools.escapeHTML(selfP.name);
+		}
+	};
+	this.getTitle = function () {
+		titlestring = '(' + selfP.ability + ') ';
+
+		for (var i = 0; i < selfP.moves.length; i++) {
+			if (i != 0) titlestring += ' / ';
+			titlestring += Tools.getMove(selfP.moves[i]).name;
+		}
+		return titlestring;
+	};
+	this.getFullName = function (plaintext) {
+		var name = Tools.escapeHTML(selfP.name);
+		if (selfP.name !== selfP.species) {
+			if (plaintext) {
+				name += ' (' + selfP.species + ')';
+			} else name += ' <small>(' + selfP.species + ')</small>';
+		}
+		if (plaintext) {
+			if (selfP === selfP.side.active[0]) {
+				name += ' (active)';
+			} else if (selfP.fainted) {
+				name += ' (fainted)';
+			} else {
+				var statustext = '';
+				if (selfP.hp !== selfP.maxhp) {
+					statustext += selfP.hpDisplay();
+				}
+				if (selfP.status) {
+					if (statustext) statustext += '|';
+					statustext += selfP.status;
+				}
+				if (statustext) {
+					name += ' (' + statustext + ')';
+				}
+			}
+		}
+		return name;
+	}
+	this.getBoost = function (boostStat) {
+		var boostStatTable = {
+			atk: 'Atk',
+			def: 'Def',
+			spa: 'SpA',
+			spd: 'SpD',
+			spe: 'Spe',
+			accuracy: 'Accuracy',
+			evasion: 'Evasion'
+		};
+		if (!selfP.boosts[boostStat]) {
+			return '1&times;&nbsp;' + boostStatTable[boostStat];
+		}
+		if (selfP.boosts[boostStat] > 6) selfP.boosts[boostStat] = 6;
+		if (selfP.boosts[boostStat] < -6) selfP.boosts[boostStat] = -6;
+		if (boostStat === 'accuracy' || boostStat === 'evasion') {
+			if (selfP.boosts[boostStat] > 0) {
+				var goodBoostTable = ['1&times;', '1.33&times;', '1.67&times;', '2&times;', '2.33&times;', '2.67&times;', '3&times;'];
+				//var goodBoostTable = ['Normal', '+1', '+2', '+3', '+4', '+5', '+6'];
+				return '' + goodBoostTable[selfP.boosts[boostStat]] + '&nbsp;' + boostStatTable[boostStat];
+			}
+			var badBoostTable = ['1&times;', '0.75&times;', '0.6&times;', '0.5&times;', '0.43&times;', '0.38&times;', '0.33&times;'];
+			//var badBoostTable = ['Normal', '&minus;1', '&minus;2', '&minus;3', '&minus;4', '&minus;5', '&minus;6'];
+			return '' + badBoostTable[-selfP.boosts[boostStat]] + '&nbsp;' + boostStatTable[boostStat];
+		}
+		if (selfP.boosts[boostStat] > 0) {
+			var goodBoostTable = ['1&times;', '1.5&times;', '2&times;', '2.5&times;', '3&times;', '3.5&times;', '4&times;'];
+			//var goodBoostTable = ['Normal', '+1', '+2', '+3', '+4', '+5', '+6'];
+			return '' + goodBoostTable[selfP.boosts[boostStat]] + '&nbsp;' + boostStatTable[boostStat];
+		}
+		var badBoostTable = ['1&times;', '0.67&times;', '0.5&times;', '0.4&times;', '0.33&times;', '0.29&times;', '0.25&times;'];
+		//var badBoostTable = ['Normal', '&minus;1', '&minus;2', '&minus;3', '&minus;4', '&minus;5', '&minus;6'];
+		return '' + badBoostTable[-selfP.boosts[boostStat]] + '&nbsp;' + boostStatTable[boostStat];
+	}
+	this.getBoostType = function (boostStat) {
+		if (!selfP.boosts[boostStat]) {
+			return 'neutral';
+		} else if (selfP.boosts[boostStat] > 0) {
+			return 'good';
+		}
+		return 'bad';
+	}
+
+	this.clearVolatile = function () {
+		selfP.atk = selfP.atkStat;
+		selfP.def = selfP.defStat;
+		selfP.spa = selfP.spaStat;
+		selfP.spd = selfP.spdStat;
+		selfP.spe = selfP.speStat;
+		selfP.boosts = {};
+		selfP.clearVolatiles();
+		//selfP.lastmove = '';
+		selfP.statusStage = 0;
+	};
+	this.copyVolatileFrom = function (pokemon, copyAll) {
+		selfP.boosts = pokemon.boosts;
+		selfP.volatiles = pokemon.volatiles;
+		//selfP.lastmove = pokemon.lastmove; // I think
+		if (!copyAll) {
+			selfP.removeVolatile('yawn');
+			selfP.removeVolatile('airballoon');
+			selfP.removeVolatile('typechange');
+		}
+		selfP.removeVolatile('transform');
+		selfP.removeVolatile('formechange');
+
+		pokemon.atk = pokemon.atkStat;
+		pokemon.def = pokemon.defStat;
+		pokemon.spa = pokemon.spaStat;
+		pokemon.spd = pokemon.spdStat;
+		pokemon.spe = pokemon.speStat;
+		pokemon.boosts = {};
+		pokemon.volatiles = {};
+		pokemon.sprite.removeTransform();
+		pokemon.statusStage = 0;
+	};
+	this.reset = function () {
+		selfP.clearVolatile();
+		selfP.hp = selfP.maxhp;
+		selfP.zerohp = false;
+		selfP.fainted = false;
+		selfP.status = '';
+		if (!selfP.name) {
+			selfP.name = selfP.species;
+		}
+	};
+	// This function is used for two things:
+	//   1) The percentage to display beside the HP bar.
+	//   2) The width to draw an HP bar.
+	//
+	// This function is NOT used in the calculation of any other displayed
+	// percentages or ranges, which have their own, more complex, formulae.
+	this.hpWidth = function (maxWidth) {
+		if (selfP.fainted || selfP.zerohp) {
+			return 0;
+		}
+		// special case for low health...
+		if (selfP.hp == 1 && selfP.maxhp > 10) return 1;
+		if (selfP.maxhp === 48) {
+			// Draw the health bar to the middle of the range.
+			// This affects the width of the visual health bar *only*; it
+			// does not affect the ranges displayed in any way.
+			var range = selfP.getPixelRange(selfP.hp, selfP.hpcolor);
+			var ratio = (range[0] + range[1]) / 2;
+			return Math.round(maxWidth * ratio) || 1;
+		}
+		var percentage = Math.ceil(selfP.hp / selfP.maxhp * 100);
+		if ((percentage === 100) && (selfP.hp < selfP.maxhp)) {
+			percentage = 99;
+		}
+		return percentage * maxWidth / 100;
+	};
+	this.hpDisplay = function (precision) {
+		if (precision === undefined) precision = 1;
+		if (selfP.maxhp === 100) {
+			return selfP.hp + '%';
+		} else if (selfP.maxhp !== 48) {
+			return (selfP.hp / selfP.maxhp * 100).toFixed(precision) + '%';
+		}
+		var range = selfP.getPixelRange(selfP.hp, selfP.hpcolor);
+		return selfP.getFormattedRange(range, precision, '–');
+	};
+};
+
+function Battle(frame, logFrame, noPreload) {
+	var self = this;
+
+	frame.addClass('battle');
+
+	this.turn = 0;
+	this.done = 0;
+	this.weather = '';
+	this.pseudoWeather = [];
+	this.weatherTimeLeft = 0;
+	this.weatherMinTimeLeft = 0;
+	this.mySide = null;
+	this.yourSide = null;
+	this.p1 = null;
+	this.p2 = null;
+	this.sides = [];
+	this.lastMove = '';
+	this.gen = 6;
+
+	this.frameElem = frame;
+	this.logFrameElem = logFrame;
+	this.logElem = null;
+	this.weatherElem = null;
+	this.bgEffectElem = null;
+	this.bgElem = null;
+	this.spriteElem = null;
+	this.spriteElems = [null, null];
+	this.spriteElemsFront = [null, null];
+	this.statElem = null;
+	this.fxElem = null;
+	this.leftbarElem = null;
+	this.rightbarElem = null;
+	this.turnElem = null;
+	this.messagebarElem = null;
+	this.delayElem = null;
+	this.hiddenMessageElem = null;
+
+	this.paused = true;
+	this.playbackState = 0;
+
+	self.backdropImage = BattleBackdrops[0];
+
+	self.backdropImage = BattleBackdrops[Math.floor(Math.random() * BattleBackdrops.length)];
+
+	// 0 = uninitialized
+	// 1 = ready
+	// 2 = playing
+	// 3 = paused
+	// 4 = finished
+	// 5 = seeking
+	this.removePseudoWeather = function (weather) {
+		for (var i = 0; i < self.pseudoWeather.length; i++) {
+			if (self.pseudoWeather[i][0] === weather) {
+				self.pseudoWeather.splice(i, 1);
+				self.updateWeather();
+				return;
+			}
+		}
+	};
+	this.addPseudoWeather = function (weather, poke) {
+		self.pseudoWeather.push([weather, 5]);
+		self.updateWeather();
+	};
+	this.hasPseudoWeather = function (weather) {
+		for (var i = 0; i < self.pseudoWeather.length; i++) {
+			if (self.pseudoWeather[i][0] === weather) {
+				return true;
+			}
+		}
+		return false;
+	};
+	this.init = function () {
+		self.reset();
+		self.mySide = new self.Side(0);
+		self.yourSide = new self.Side(1);
+		self.mySide.foe = self.yourSide;
+		self.yourSide.foe = self.mySide;
+		self.sides = [self.mySide, self.yourSide];
+		self.p1 = self.mySide;
+		self.p2 = self.yourSide;
+		self.gen = 6;
+	};
+	this.updateGen = function () {
+		if (this.gen < 4) self.backdropImage = '';
+		else if (this.gen < 6) self.backdropImage = 'bg.jpg';
+		if (self.bgElem) self.bgElem.css('background-image','url(' + Tools.resourcePrefix + 'fx/' + self.backdropImage + ')');
+	};
+	this.reset = function (dontResetSound) {
+		// battle state
+		self.turn = 0;
+		self.done = 0;
+		self.weather = '';
+		self.weatherTimeLeft = 0;
+		self.weatherMinTimeLeft = 0;
+		self.pseudoWeather = [];
+		self.lastMove = '';
+
+		// DOM state
+		self.frameElem.empty();
+		self.frameElem.html('<div class="innerbattle"></div>');
+		self.elem = self.frameElem.children();
+		logFrame.html('<div class="inner"></div>');
+		self.logElem = logFrame.children();
+		logFrame.append('<div class="inner-preempt"></div>');
+		self.logPreemptElem = logFrame.children().last();
+		logFrame.append('<div class="inner-after"></div>');
+
+		this.updateGen();
+		self.elem.append('<div class="backdrop" style="background-image:url(' + Tools.resourcePrefix + 'fx/' + self.backdropImage + ');display:block;opacity:0"></div>');
+		self.bgElem = self.elem.children().last();
+		self.bgElem.animate({
+			opacity: 0.6
+		});
+
+		self.elem.append('<div class="weather"></div>');
+		self.weatherElem = self.elem.children().last();
+
+		self.elem.append('<div></div>');
+		self.bgEffectElem = self.elem.children().last();
+
+		self.elem.append('<div></div>');
+		self.spriteElem = self.elem.children().last();
+
+		self.spriteElem.append('<div></div>');
+		self.spriteElems[1] = self.spriteElem.children().last();
+		self.spriteElem.append('<div></div>');
+		self.spriteElemsFront[1] = self.spriteElem.children().last();
+		self.spriteElem.append('<div></div>');
+		self.spriteElemsFront[0] = self.spriteElem.children().last();
+		self.spriteElem.append('<div></div>');
+		self.spriteElems[0] = self.spriteElem.children().last();
+
+		self.elem.append('<div></div>');
+		self.statElem = self.elem.children().last();
+
+		self.elem.append('<div></div>');
+		self.fxElem = self.elem.children().last();
+
+		self.elem.append('<div class="leftbar"></div>');
+		self.leftbarElem = self.elem.children().last();
+
+		self.elem.append('<div class="rightbar"></div>');
+		self.rightbarElem = self.elem.children().last();
+
+		self.elem.append('<div></div>');
+		self.turnElem = self.elem.children().last();
+
+		self.elem.append('<div class="messagebar message"></div>');
+		self.messagebarElem = self.elem.children().last();
+
+		self.elem.append('<div></div>');
+		self.delayElem = self.elem.children().last();
+
+		self.elem.append('<div class="message" style="position:absolute;display:block;visibility:hidden"></div>');
+		self.hiddenMessageElem = self.elem.children().last();
+
+		if (self.mySide) self.mySide.reset();
+		if (self.yourSide) self.yourSide.reset();
+
+		// activity queue state
+		self.animationDelay = 0;
+		self.multiHitMove = null;
+		self.activityStep = 0;
+		self.activityDelay = 0;
+		self.activityAfter = null;
+		self.activityAnimations = $();
+		self.activityQueueActive = false;
+		self.fastForwardOff();
+		$.fx.off = false;
+		self.minorQueue = [];
+		self.resultWaiting = false;
+		self.paused = true;
+		if (self.playbackState !== 5) {
+			self.playbackState = (self.activityQueue.length ? 1 : 0);
+			if (!dontResetSound) self.soundStop();
+		}
+	};
+	this.dealloc = function () {
+		self.soundStop();
+	};
+
+	this.logConsole = function (text) {
+		if (window.console && console.log) console.log(text);
+	};
+	this.log = function (html, preempt) {
+		var willScroll = (self.logFrameElem.scrollTop() + 60 >= self.logElem.height() + self.logPreemptElem.height() - self.logFrameElem.height());
+		if (preempt) {
+			self.logPreemptElem.append(html);
+		} else {
+			self.logElem.append(html);
+		}
+		if (willScroll) {
+			self.logFrameElem.scrollTop(self.logElem.height() + self.logPreemptElem.height());
+		}
+	};
+	this.preemptCatchup = function () {
+		self.logElem.append(self.logPreemptElem.children().first());
+	};
+
+	this.pos = function (loc, obj) {
+		var left, top, scale, width, height;
+
+		if (!loc.scale && loc.scale !== 0) loc.scale = 1;
+		if (!loc.xscale && loc.xscale !== 0) loc.xscale = loc.scale;
+		if (!loc.yscale && loc.yscale !== 0) loc.yscale = loc.scale;
+		if (!loc.opacity && loc.opacity !== 0) loc.opacity = 1;
+		if (!loc.z) loc.z = 0;
+		if (!loc.x) loc.x = 0;
+		if (!loc.y) loc.y = 0;
+
+		left = 210;
+		top = 245;
+		scale = 1;
+		scale = 2 - 1 * (loc.z / 200);
+		if (scale < .1) scale = .1;
+
+		left += (410 - 190) * (loc.z / 200);
+		top += (135 - 245) * (loc.z / 200);
+		left += Math.floor(loc.x * scale);
+		top -= Math.floor(loc.y * scale /* - loc.x * scale / 4 */ );
+		width = Math.floor(obj.w * scale * loc.xscale);
+		height = Math.floor(obj.h * scale * loc.yscale);
+		left -= Math.floor(width / 2);
+		top -= Math.floor(height / 2);
+
+		var pos = {
+			left: left,
+			top: top,
+			width: width,
+			height: height,
+			opacity: loc.opacity
+		};
+		if (loc.display) pos.display = loc.display;
+		return pos;
+	};
+	this.posT = function (loc, obj, transition, oldloc) {
+		var pos = self.pos(loc, obj);
+		var oldpos = null;
+		if (oldloc) oldpos = self.pos(oldloc, obj);
+		var transitionMap = {
+			left: 'linear',
+			top: 'linear',
+			width: 'linear',
+			height: 'linear',
+			opacity: 'linear'
+		};
+		if (transition === 'ballistic') {
+			transitionMap.top = (pos.top < oldpos.top ? 'ballisticUp' : 'ballisticDown');
+		}
+		if (transition === 'ballisticUnder') {
+			transitionMap.top = (pos.top < oldpos.top ? 'ballisticDown' : 'ballisticUp');
+		}
+		if (transition === 'ballistic2') {
+			transitionMap.top = (pos.top < oldpos.top ? 'quadUp' : 'quadDown');
+		}
+		if (transition === 'ballistic2Under') {
+			transitionMap.top = (pos.top < oldpos.top ? 'quadDown' : 'quadUp');
+		}
+		if (transition === 'swing') {
+			transitionMap.left = 'swing';
+			transitionMap.top = 'swing';
+			transitionMap.width = 'swing';
+			transitionMap.height = 'swing';
+		}
+		if (transition === 'accel') {
+			transitionMap.left = 'quadDown';
+			transitionMap.top = 'quadDown';
+			transitionMap.width = 'quadDown';
+			transitionMap.height = 'quadDown';
+		}
+		if (transition === 'decel') {
+			transitionMap.left = 'quadUp';
+			transitionMap.top = 'quadUp';
+			transitionMap.width = 'quadUp';
+			transitionMap.height = 'quadUp';
+		}
+		return {
+			left: [pos.left, transitionMap.left],
+			top: [pos.top, transitionMap.top],
+			width: [pos.width, transitionMap.width],
+			height: [pos.height, transitionMap.height],
+			opacity: [pos.opacity, transitionMap.opacity]
+		};
+	};
+	this.Sprite = function (spriteData, x, y, z, siden) {
+		var selfS = this;
+		var sp = null;
+		var subsp = null;
+		this.forme = '';
+		this.elem = null;
+		this.cryurl = '';
+		if (spriteData) {
+			sp = spriteData;
+			self.spriteElems[siden].append('<img src="' + sp.url + '" style="display:none;position:absolute" />');
+			this.elem = self.spriteElems[siden].children().last();
+			this.cryurl = spriteData.cryurl;
+		} else {
+			sp = {
+				w: 0,
+				h: 0,
+				url: ''
+			};
+		}
+		this.sp = sp;
+		this.subsp = null;
+		this.oldsp = null;
+		this.subElem = null;
+		this.iw = sp.w;
+		this.ih = sp.h;
+		this.w = 0;
+		this.h = 0;
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.statbarOffset = 0;
+		var pos = self.pos({
+			x: x,
+			y: y,
+			z: z
+		}, {
+			w: 0,
+			h: 96
+		});
+		this.top = parseInt(pos.top + 40);
+		this.left = parseInt(pos.left);
+		this.isBackSprite = !siden;
+		this.duringMove = false;
+		this.behindx = function (offset) {
+			return selfS.x + (selfS.isBackSprite ? -1 : 1) * offset;
+		}
+		this.behindy = function (offset) {
+			return selfS.y + (selfS.isBackSprite ? 1 : -1) * offset;
+		}
+		this.leftof = function (offset) {
+			return (selfS.isBackSprite ? -1 : 1) * offset;
+		};
+		this.behind = function (offset) {
+			return selfS.z + (selfS.isBackSprite ? -1 : 1) * offset;
+		};
+		this.animTransform = function (species) {
+			if (!selfS.oldsp) selfS.oldsp = selfS.sp;
+			if (species.volatiles && species.volatiles.formechange) species = species.volatiles.formechange[2];
+			sp = Tools.getSpriteData(species, selfS.isBackSprite ? 0 : 1, {afd: self.tier === "[Seasonal] Fools Festival"});
+			selfS.sp = sp;
+			selfS.elem.animate(self.pos({
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.z,
+				yscale: 0,
+				xcale: 1,
+				opacity: .3
+			}, selfS.oldsp), 300, function () {
+				selfS.elem.attr('src', sp.url);
+				selfS.elem.animate(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.z,
+					opacity: 1
+				}, sp), 300);
+			});
+			self.activityWait(500);
+		};
+		this.destroy = function () {
+			if (selfS.elem) selfS.elem.remove();
+			if (selfS.subElem) selfS.subElem.remove();
+		};
+		this.removeTransform = function (species) {
+			if (selfS.oldsp) {
+				sp = selfS.oldsp;
+				selfS.sp = sp;
+				selfS.oldsp = null;
+				selfS.elem.attr('src', sp.url);
+				selfS.elem.css(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: (selfS.subElem ? selfS.behind(30) : selfS.z),
+					opacity: (selfS.subElem ? .3 : 1)
+				}, sp));
+			}
+		};
+		this.animSub = function () {
+			subsp = Tools.getSpriteData('substitute', siden, {afd: self.tier === "[Seasonal] Fools Festival"});
+			selfS.subsp = subsp;
+			selfS.iw = subsp.w;
+			selfS.ih = subsp.h;
+			self.spriteElemsFront[siden].append('<img src="' + subsp.url + '" style="display:none;position:absolute" />');
+			selfS.subElem = self.spriteElemsFront[siden].children().last();
+
+			//temp//selfS.subElem.css({position: 'absolute', display: 'block'});
+			selfS.selfAnim({}, 500);
+			selfS.subElem.css({
+				position: 'absolute',
+				opacity: 0,
+				display: 'block'
+			});
+			selfS.subElem.css(self.pos({
+				x: selfS.x,
+				y: selfS.y + 50,
+				z: selfS.z,
+				opacity: 0
+			}, subsp));
+			selfS.subElem.animate(self.pos({
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.z
+			}, subsp), 500);
+			self.activityWait(selfS.subElem);
+		};
+		this.animSubFade = function () {
+			if (!selfS.subElem) return;
+			if (self.activityDelay) {
+				selfS.elem.delay(self.activityDelay);
+				selfS.subElem.delay(self.activityDelay);
+			}
+			selfS.subElem.animate(self.pos({
+				x: selfS.x,
+				y: selfS.y - 50,
+				z: selfS.z,
+				opacity: 0
+			}, selfS.subsp), 500);
+
+			selfS.subElem = null;
+			selfS.selfAnim({}, 500);
+			selfS.iw = selfS.sp.w;
+			selfS.ih = selfS.sp.h;
+			self.activityWait(selfS.elem);
+		};
+		this.beforeMove = function () {
+			if (selfS.subElem && !selfS.duringMove) {
+				selfS.duringMove = true;
+				selfS.selfAnim({}, 300);
+				selfS.subElem.animate(self.pos({
+					x: selfS.leftof(-50),
+					y: selfS.y,
+					z: selfS.z,
+					opacity: 0.5
+				}, selfS.subsp), 300);
+				if (self.sides[selfS.isBackSprite ? 1 : 0].active[0]) {
+					self.sides[selfS.isBackSprite ? 1 : 0].active[0].sprite.delay(300);
+				}
+				self.animationDelay = 300;
+				self.activityWait(selfS.elem);
+
+				return true;
+			}
+			return false;
+		};
+		this.afterMove = function () {
+			if (selfS.subElem && selfS.duringMove) {
+				selfS.subElem.delay(300);
+				selfS.duringMove = false;
+				selfS.elem.add(selfS.subElem).promise().done(function () {
+					if (!selfS.subElem || !selfS.elem) return;
+					selfS.selfAnim({}, 300);
+					selfS.subElem.animate(self.pos({
+						x: selfS.x,
+						y: selfS.y,
+						z: selfS.z,
+						opacity: 1
+					}, selfS.subsp), 300);
+				});
+				return true;
+			}
+			selfS.duringMove = false;
+			return false;
+		};
+		this.removeSub = function () {
+			if (selfS.subElem) {
+				var temp = selfS.subElem;
+				selfS.subElem.animate({
+					opacity: 0
+				}, function () {
+					temp.remove();
+				});
+				selfS.subElem = null;
+			}
+		};
+		this.animReset = function () {
+			if (selfS.subElem) {
+				selfS.elem.stop(true, false);
+				selfS.subElem.stop(true, false);
+				selfS.elem.css(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(30),
+					opacity: .3
+				}, selfS.sp));
+				selfS.subElem.css(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.z
+				}, selfS.subsp));
+			} else {
+				selfS.elem.stop(true, false);
+				selfS.elem.css(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.z
+				}, selfS.sp));
+			}
+		};
+		this.animSummon = function (slot, instant) {
+			selfS.x = slot * (selfS.isBackSprite ? -1 : 1) * -50;
+			selfS.y = slot * (selfS.isBackSprite ? -1 : 1) * 10;
+			selfS.statbarOffset = 0;
+			if (!selfS.isBackSprite && slot == 1) selfS.statbarOffset = 17;
+			if (selfS.isBackSprite && slot == 1) selfS.statbarOffset = -7;
+
+			// make sure element is in the right z-order
+			if (!slot && selfS.isBackSprite || slot && !selfS.isBackSprite) {
+				selfS.elem.prependTo(selfS.elem.parent());
+			} else {
+				selfS.elem.appendTo(selfS.elem.parent());
+			}
+
+			var pos = self.pos(selfS, {
+				w: 0,
+				h: 96
+			});
+			selfS.top = parseInt(pos.top + 40);
+			selfS.left = parseInt(pos.left);
+
+			selfS.anim();
+			selfS.w = sp.w;
+			selfS.h = sp.h;
+			selfS.elem.css({
+				// 'z-index': (selfS.isBackSprite ? 1+slot : 4-slot),
+				position: 'absolute',
+				display: 'block'
+			});
+			if (self.fastForward || instant) {
+				selfS.elem.css(self.pos({
+					opacity: 1,
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.z
+				}, selfS.sp));
+				return;
+			}
+			if (selfS.cryurl) {
+				//self.logConsole('cry: '+selfS.cryurl);
+				BattleSound.playEffect(selfS.cryurl);
+			}
+			selfS.elem.css(self.pos({
+				x: selfS.x,
+				y: selfS.y - 10,
+				z: selfS.z,
+				scale: 0,
+				opacity: 0
+			}, selfS.sp));
+			self.showEffect('pokeball', {
+				opacity: 0,
+				x: selfS.x,
+				y: selfS.y + 30,
+				z: selfS.behind(50),
+				scale: .7
+			}, {
+				opacity: 1,
+				x: selfS.x,
+				y: selfS.y - 10,
+				z: selfS.z,
+				time: 300
+			}, 'ballistic2', 'fade');
+			selfS.elem.delay(300).animate(self.pos({
+				x: selfS.x,
+				y: selfS.y + 30,
+				z: selfS.z
+			}, selfS.sp), 400).animate(self.posT({
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.z
+			}, selfS.sp, 'accel'), 300);
+			self.activityWait(selfS.elem);
+		};
+		this.animDragIn = function (slot) {
+			if (self.fastForward) return selfS.animSummon(slot, true);
+
+			selfS.x = slot * (selfS.isBackSprite ? -1 : 1) * -50;
+			selfS.y = slot * (selfS.isBackSprite ? -1 : 1) * 10;
+			selfS.statbarOffset = 0;
+			if (!selfS.isBackSprite && slot == 1) selfS.statbarOffset = 17;
+			if (selfS.isBackSprite && slot == 1) selfS.statbarOffset = -7;
+
+			// make sure element is in the right z-order
+			if (!slot && selfS.isBackSprite || slot && !selfS.isBackSprite) {
+				selfS.elem.prependTo(selfS.elem.parent());
+			} else {
+				selfS.elem.appendTo(selfS.elem.parent());
+			}
+
+			var pos = self.pos(selfS, {
+				w: 0,
+				h: 96
+			});
+			selfS.top = parseInt(pos.top + 40);
+			selfS.left = parseInt(pos.left);
+
+			selfS.anim();
+			selfS.elem.css({
+				// 'z-index': (selfS.isBackSprite ? 1+slot : 4-slot),
+				position: 'absolute',
+				opacity: 0,
+				display: 'block'
+			});
+			selfS.elem.css(self.pos({
+				x: selfS.leftof(-50),
+				y: selfS.y,
+				z: selfS.z,
+				opacity: 0
+			}, selfS.sp));
+			selfS.elem.delay(300).animate(self.posT({
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.z
+			}, selfS.sp, 'decel'), 400);
+			selfS.w = sp.w;
+			selfS.h = sp.h;
+			self.activityWait(selfS.elem);
+			self.animationDelay = 700;
+		};
+		this.animDragOut = function () {
+			selfS.removeSub();
+			if (self.fastForward) return selfS.animUnsummon(true);
+			selfS.elem.animate(self.posT({
+				x: selfS.leftof(50),
+				y: selfS.y,
+				z: selfS.z,
+				opacity: 0
+			}, selfS.sp, 'accel'), 400);
+		};
+		this.animUnsummon = function (instant) {
+			selfS.removeSub();
+			if (self.fastForward || instant) {
+				selfS.elem.css('display', 'none');
+				return;
+			}
+			selfS.anim({
+				x: selfS.x,
+				y: selfS.y - 40,
+				z: selfS.z,
+				scale: 0,
+				opacity: 0,
+				time: 400
+			});
+			self.showEffect('pokeball', {
+				opacity: 1,
+				x: selfS.x,
+				y: selfS.y - 40,
+				z: selfS.z,
+				scale: .7,
+				time: 300
+			}, {
+				opacity: 0,
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.behind(50),
+				time: 700
+			}, 'ballistic2');
+			self.activityWait(selfS.elem);
+		};
+		this.animFaint = function () {
+			selfS.removeSub();
+			if (self.fastForward) {
+				selfS.elem.remove();
+				selfS.elem = null;
+				return;
+			}
+			selfS.anim({
+				y: selfS.y - 80,
+				opacity: 0
+			}, 'accel');
+			self.activityWait(selfS.elem);
+		};
+		this.delay = function (time) {
+			selfS.elem.delay(time);
+			if (selfS.subElem) {
+				selfS.subElem.delay(time);
+			};
+			return selfS;
+		};
+		this.selfAnim = function (end, transition) {
+			if (!end) return;
+			end = $.extend({
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.z,
+				scale: 1,
+				opacity: 1,
+				time: 500
+			}, end);
+			if (selfS.subElem && !selfS.duringMove) {
+				end.z += (selfS.isBackSprite ? -1 : 1) * 30;
+				end.opacity *= .3;
+			}
+			selfS.elem.animate(self.posT(end, selfS.sp, transition, selfS), end.time);
+		};
+		this.anim = function (end, transition) {
+			if (!end) return;
+			end = $.extend({
+				x: selfS.x,
+				y: selfS.y,
+				z: selfS.z,
+				scale: 1,
+				opacity: 1,
+				time: 500
+			}, end);
+			if (selfS.subElem && !selfS.duringMove) {
+				selfS.subElem.animate(self.posT(end, selfS.subsp, transition, selfS), end.time);
+			} else {
+				selfS.elem.animate(self.posT(end, selfS.sp, transition, selfS), end.time);
+			}
+		};
+		if (!spriteData) {
+			this.delay = function () {};
+			this.anim = function () {};
+		}
+	};
+	this.backgroundEffect = function (bg, duration, opacity, delay) {
+		if (!opacity) {
+			opacity = 1;
+		}
+		if (!delay) delay = 0;
+		self.bgEffectElem.append('<div class="background"></div>');
+		var elem = self.bgEffectElem.children().last();
+		elem.css({
+			background: bg,
+			display: 'block',
+			opacity: 0
+		});
+		elem.delay(delay).animate({
+			opacity: opacity
+		}, 250).delay(duration - 250);
+		elem.animate({
+			opacity: 0
+		}, 250);
+	}
+	this.showEffect = function (img, start, end, transition, after) {
+		var effect = img;
+		if (img && img.length) effect = BattleEffects[img];
+		if (!start.time) start.time = 0;
+		if (!end.time) end.time = start.time + 500;
+		start.time += self.animationDelay;
+		end.time += self.animationDelay;
+		if (!end.scale && end.scale !== 0) end.scale = start.scale;
+		if (!end.xscale && end.xscale !== 0) end.xscale = start.xscale;
+		if (!end.yscale && end.yscale !== 0) end.yscale = start.yscale;
+		end = $.extend({}, start, end);
+
+		var startpos = self.pos(start, effect);
+		var endpos = self.posT(end, effect, transition, start);
+
+		self.fxElem.append('<img src="' + effect.url + '" style="display:none;position:absolute" />');
+		var effectElem = self.fxElem.children().last();
+		effectElem.css({
+			display: 'block',
+			opacity: 0
+		});
+		effectElem.css(startpos);
+		effectElem.css({
+			opacity: 0
+		});
+
+		if (start.time) {
+			effectElem.delay(start.time).animate({
+				opacity: startpos.opacity
+			}, 1);
+		} else {
+			effectElem.css('opacity', startpos.opacity);
+		}
+		effectElem.animate(endpos, end.time - start.time);
+		if (after === 'fade') {
+			effectElem.animate({
+				opacity: 0
+			}, 100);
+		}
+		if (after === 'explode') {
+			if (end.scale) end.scale *= 3;
+			if (end.xscale) end.xscale *= 3;
+			if (end.yscale) end.yscale *= 3;
+			end.opacity = 0;
+			var endendpos = self.pos(end, effect);
+			effectElem.animate(endendpos, 200);
+		}
+		self.activityWait(effectElem);
+	};
+
+	this.Side = function (n) {
+		var selfS = this;
+		this.battle = self;
+
+		this.name = '';
+		this.id = '';
+		this.initialized = false;
+		this.n = n;
+		this.foe = null;
+		this.spriteid = 262;
+		this.totalPokemon = 6;
+		this.rollSprites = function () {
+			var sprites = [1, 2, 101, 102, 169, 170];
+			selfS.spriteid = sprites[parseInt(Math.random() * sprites.length)];
+		};
+
+		this.behindx = function (offset) {
+			return selfS.x + (!selfS.n ? -1 : 1) * offset;
+		}
+		this.behindy = function (offset) {
+			return selfS.y + (!selfS.n ? 1 : -1) * offset;
+		}
+		this.leftof = function (offset) {
+			return (!selfS.n ? -1 : 1) * offset;
+		};
+		this.behind = function (offset) {
+			return selfS.z + (!selfS.n ? -1 : 1) * offset;
+		};
+		if (n == 0) {
+			this.x = 0;
+			this.y = 0;
+			this.z = 0;
+		} else {
+			this.x = 0;
+			this.y = 0;
+			this.z = 200;
+		}
+		this.missedPokemon = {
+			sprite: new self.Sprite(null, selfS.leftof(-100), selfS.y, selfS.z, selfS.n)
+		};
+
+		this.sideConditions = {};
+		this.wisher = null;
+
+		this.active = [null];
+		this.lastPokemon = null;
+		this.pokemon = [];
+
+		this.reset = function () {
+			selfS.updateSprites();
+			selfS.sideConditions = {};
+			for (var i = 0; i < selfS.pokemon.length; i++) {
+				selfS.pokemon[i].reset();
+			}
+		};
+		this.updateSprites = function () {
+			selfS.z = (selfS.n ? 200 : 0);
+			selfS.missedPokemon.sprite.destroy();
+			selfS.missedPokemon = {
+				sprite: new self.Sprite(null, selfS.leftof(-100), selfS.y, selfS.z, selfS.n)
+			};
+			for (var i = 0; i < selfS.pokemon.length; i++) {
+				poke = selfS.pokemon[i];
+				poke.sprite.destroy();
+				poke.sprite = new self.Sprite(Tools.getSpriteData(poke, selfS.n, {afd: self.tier === "[Seasonal] Fools Festival"}), selfS.x, selfS.y, selfS.z, selfS.n);
+			}
+		};
+		this.setSprite = function (spriteid) {
+			selfS.spriteid = spriteid;
+			selfS.updateSidebar();
+		};
+		this.setName = function (name, spriteid) {
+			selfS.name = (name||'');
+			selfS.id = toId(selfS.name);
+			if (spriteid) selfS.spriteid = spriteid;
+			else if (selfS.id === "Serei") selfS.spriteid = 172;
+			else if (selfS.id === "Hob'sGoblin") selfS.spriteid = 52;
+			else if (selfS.id === "EtherealSol") selfS.spriteid = 1001;
+			else if (selfS.id === "Morty(GymLeader)") selfS.spriteid = 144;
+			else if (selfS.id === "aeo") selfS.spriteid = 167;
+			else if (selfS.id === "aeo1") selfS.spriteid = 167;
+			else if (selfS.id === "aeo2") selfS.spriteid = 166;
+			else if (selfS.id === "sharktamer") selfS.spriteid = 7;
+			else if (selfS.id === "bmelts") selfS.spriteid = 226;
+			else {
+				selfS.rollSprites();
+				if (selfS.foe && selfS.spriteid === selfS.foe.spriteid) selfS.rollSprites();
+			}
+			selfS.initialized = true;
+			if (!name) {
+				selfS.initialized = false;
+			}
+			selfS.updateSidebar();
+			if (self.stagnateCallback) self.stagnateCallback(self);
+		};
+		this.getTeamName = function () {
+			if (selfS === self.mySide) return "Your team";
+			return "The opposing team";
+		};
+		this.getLowerTeamName = function () {
+			if (selfS === self.mySide) return "your team";
+			return "the opposing team";
+		};
+		this.updateSidebar = function () {
+			var pokemonhtml = '';
+			for (var i = 0; i < 6; i++) {
+				poke = selfS.pokemon[i];
+				if (i >= selfS.totalPokemon) {
+					pokemonhtml += '<span class="pokemonicon" style="'+Tools.getIcon('pokeball-none')+'"></span>';
+				} else if (!poke) {
+					//pokemonhtml += '<img src="/fx/pokeball.png" title="Not revealed" />';
+					pokemonhtml += '<span class="pokemonicon" style="'+Tools.getIcon('pokeball')+'" title="Not revealed"></span>';
+				//} else if (poke.fainted) {
+					//pokemonhtml += '<img src="/fx/pokeball.png" style="opacity:0.3;filter:alpha(opacity=30)" title="' + poke.getFullName(true) + '" />';
+				} else {
+					//pokemonhtml += '<img src="/fx/pokeball.png" title="' + poke.getFullName(true) + '" />';
+					pokemonhtml += '<span class="pokemonicon" style="'+Tools.getIcon(poke)+'" title="' + poke.getFullName(true) + '"></span>';
+				}
+				if (i % 3 === 2) pokemonhtml += '</div><div class="teamicons">';
+			}
+			pokemonhtml = '<div class="teamicons">' + pokemonhtml + '</div>';
+			if (selfS.n === 1) {
+				if (selfS.initialized) self.rightbarElem.html('<div class="trainer"><strong>' + Tools.escapeHTML(selfS.name) + '</strong><div class="trainersprite" style="background-image:url(' + Tools.resolveAvatar(selfS.spriteid) + ')"></div>' + pokemonhtml + '</div>').find('.trainer').css('opacity',1);
+				else self.rightbarElem.find('.trainer').css('opacity',0.4);
+			} else {
+				if (selfS.initialized) self.leftbarElem.html('<div class="trainer"><strong>' + Tools.escapeHTML(selfS.name) + '</strong><div class="trainersprite" style="background-image:url(' + Tools.resolveAvatar(selfS.spriteid) + ')"></div>' + pokemonhtml + '</div>').find('.trainer').css('opacity',1);
+				else self.leftbarElem.find('.trainer').css('opacity',0.4);
+			}
+		};
+		this.addSideCondition = function (condition) {
+			condition = toId(condition);
+			if (selfS.sideConditions[condition]) {
+				if (condition === 'spikes' || condition === 'toxicspikes') {
+					selfS.sideConditions[condition][2]++;
+					if (condition === 'spikes' && selfS.sideConditions[condition][2] == 2) {
+						self.spriteElemsFront[selfS.n].append('<img src="' + BattleEffects.caltrop.url + '" style="display:none;position:absolute" />');
+						curelem = self.spriteElemsFront[selfS.n].children().last();
+						curelem.css(self.pos({
+							display: 'block',
+							x: selfS.x + 50,
+							y: selfS.y - 40,
+							z: selfS.z,
+							scale: .3
+						}, BattleEffects.caltrop));
+						selfS.sideConditions['spikes'][1] = selfS.sideConditions['spikes'][1].add(curelem);
+					} else if (condition === 'spikes') {
+						self.spriteElemsFront[selfS.n].append('<img src="' + BattleEffects.caltrop.url + '" style="display:none;position:absolute" />');
+						curelem = self.spriteElemsFront[selfS.n].children().last();
+						curelem.css(self.pos({
+							display: 'block',
+							x: selfS.x + 30,
+							y: selfS.y - 45,
+							z: selfS.z,
+							scale: .3
+						}, BattleEffects.caltrop));
+						selfS.sideConditions['spikes'][1] = selfS.sideConditions['spikes'][1].add(curelem);
+					} else if (condition === 'toxicspikes') {
+						self.spriteElemsFront[selfS.n].append('<img src="' + BattleEffects.poisoncaltrop.url + '" style="display:none;position:absolute" />');
+						curelem = self.spriteElemsFront[selfS.n].children().last();
+						curelem.css(self.pos({
+							display: 'block',
+							x: selfS.x - 15,
+							y: selfS.y - 35,
+							z: selfS.z,
+							scale: .3
+						}, BattleEffects.poisoncaltrop));
+						selfS.sideConditions['toxicspikes'][1] = selfS.sideConditions['toxicspikes'][1].add(curelem);
+					}
+				}
+				return;
+			}
+			var elem, curelem;
+			switch (condition) {
+			case 'reflect':
+				self.spriteElemsFront[selfS.n].append('<div class="sidecondition-reflect" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-17),
+					xscale: 1,
+					yscale: 0,
+					opacity: .1
+				}, BattleEffects.none)).animate(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-17),
+					xscale: 1,
+					yscale: .5,
+					opacity: .7
+				}, BattleEffects.none)).animate({
+					opacity: .3
+				}, 300);
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 5];
+				break;
+			case 'safeguard':
+				self.spriteElemsFront[selfS.n].append('<div class="sidecondition-safeguard" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-20),
+					xscale: 1,
+					yscale: 0,
+					opacity: .1
+				}, BattleEffects.none)).animate(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-20),
+					xscale: 1,
+					yscale: .5,
+					opacity: .7
+				}, BattleEffects.none)).animate({
+					opacity: .2
+				}, 300);
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 5];
+				break;
+			case 'lightscreen':
+				self.spriteElemsFront[selfS.n].append('<div class="sidecondition-lightscreen" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-23),
+					xscale: 1,
+					yscale: 0,
+					opacity: .1
+				}, BattleEffects.none)).animate(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-23),
+					xscale: 1,
+					yscale: .5,
+					opacity: .7
+				}, BattleEffects.none)).animate({
+					opacity: .3
+				}, 300);
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 5];
+				break;
+			case 'mist':
+				self.spriteElemsFront[selfS.n].append('<div class="sidecondition-mist" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-27),
+					xscale: 1,
+					yscale: 0,
+					opacity: .1
+				}, BattleEffects.none)).animate(self.pos({
+					x: selfS.x,
+					y: selfS.y,
+					z: selfS.behind(-27),
+					xscale: 1,
+					yscale: .5,
+					opacity: .7
+				}, BattleEffects.none)).animate({
+					opacity: .2
+				}, 300);
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 5];
+				break;
+			case 'tailwind':
+				selfS.sideConditions[condition] = [condition, null, 5];
+				break;
+			case 'stealthrock':
+				self.spriteElemsFront[selfS.n].append('<img src="' + BattleEffects.rock1.url + '" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.leftof(-40),
+					y: selfS.y - 10,
+					z: selfS.z,
+					opacity: .5,
+					scale: .3
+				}, BattleEffects.rock1));
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 1];
+				break;
+			case 'spikes':
+				self.spriteElemsFront[selfS.n].append('<img src="' + BattleEffects.caltrop.url + '" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.x - 25,
+					y: selfS.y - 40,
+					z: selfS.z,
+					scale: .3
+				}, BattleEffects.caltrop));
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 1];
+				break;
+			case 'toxicspikes':
+				self.spriteElemsFront[selfS.n].append('<img src="' + BattleEffects.poisoncaltrop.url + '" style="display:none;position:absolute" />');
+				curelem = self.spriteElemsFront[selfS.n].children().last();
+				curelem.css(self.pos({
+					display: 'block',
+					x: selfS.x + 5,
+					y: selfS.y - 40,
+					z: selfS.z,
+					scale: .3
+				}, BattleEffects.poisoncaltrop));
+				elem = curelem;
+				selfS.sideConditions[condition] = [condition, elem, 1];
+				break;
+			default:
+				selfS.sideConditions[condition] = [condition, null, 1];
+			}
+		};
+		this.removeSideCondition = function (condition) {
+			condition = toId(condition);
+			if (!selfS.sideConditions[condition]) return;
+			if (selfS.sideConditions[condition][1]) selfS.sideConditions[condition][1].remove();
+			delete selfS.sideConditions[condition];
+		};
+		this.newPokemon = function (species, replaceSlot) {
+			var id;
+			var pokeobj;
+			if (species.species) {
+				pokeobj = species;
+				species = pokeobj.species;
+				id = pokeobj.id;
+			}
+			var poke = Tools.getTemplate(species);
+			poke = $.extend(new Pokemon(species), poke);
+			poke.side = selfS;
+			poke.atkStat = 10;
+			poke.defStat = 10;
+			poke.spaStat = 10;
+			poke.spdStat = 10;
+			poke.maxhp = 1000;
+			if (pokeobj) poke = $.extend(poke, pokeobj);
+			if (!poke.ability && poke.baseAbility) poke.ability = poke.baseAbility;
+			poke.id = id;
+			poke.reset();
+			poke.sprite = new self.Sprite(Tools.getSpriteData(poke, selfS.n, {afd: self.tier === "[Seasonal] Fools Festival"}), selfS.x, selfS.y, selfS.z, selfS.n);
+
+			if (typeof replaceSlot !== 'undefined') {
+				selfS.pokemon[replaceSlot] = poke;
+			} else {
+				selfS.pokemon.push(poke);
+			}
+			if (selfS.pokemon.length == 7) {
+				// something's wrong
+				self.logConsole('corruption');
+
+				// the other possibility is Illusion, which we'll assume
+				var existingTable = {};
+				for (var i=0; i<6; i++) {
+					var poke1 = selfS.pokemon[i];
+					if (existingTable[poke1.searchid]) {
+						var j = existingTable[poke1.searchid];
+						var poke2 = selfS.pokemon[j];
+						if (selfS.active.indexOf(poke1) >= 0) {
+							selfS.pokemon.splice(j,1);
+						} else if (selfS.active.indexOf(poke2) >= 0) {
+							selfS.pokemon.splice(i,1);
+						} else if (poke1.fainted && !poke2.fainted) {
+							selfS.pokemon.splice(j,1);
+						} else {
+							selfS.pokemon.splice(i,1);
+						}
+						break;
+					}
+					existingTable[poke1.searchid] = i;
+				}
+			}
+			selfS.updateSidebar();
+
+			return poke;
+		};
+
+		this.getStatbarHTML = function (pokemon) {
+			var gender = '';
+			if (pokemon.gender === 'F') gender = ' <small style="color:#C57575">&#9792;</small>';
+			if (pokemon.gender === 'M') gender = ' <small style="color:#7575C0">&#9794;</small>';
+			return '<div class="statbar' + (selfS.n ? ' lstatbar' : ' rstatbar') + '"><strong>' + Tools.escapeHTML(pokemon.name) + gender + (pokemon.level === 100 ? '' : ' <small>L' + pokemon.level + '</small>') + '</strong><div class="hpbar"><div class="hptext"></div><div class="hptextborder"></div><div class="prevhp"><div class="hp"></div></div><div class="status"></div></div>';
+		};
+		this.switchIn = function (pokemon, slot) {
+			if (slot === undefined) slot = pokemon.slot;
+			selfS.active[slot] = pokemon;
+			pokemon.slot = slot;
+			pokemon.clearVolatile();
+			pokemon.lastmove = '';
+			self.lastmove = 'switch-in';
+			if (selfS.lastPokemon && selfS.lastPokemon.lastmove === 'batonpass') {
+				pokemon.copyVolatileFrom(selfS.lastPokemon);
+			}
+
+			if (pokemon.side.n === 0) {
+				self.message('Go! ' + pokemon.getFullName() + '!');
+			} else {
+				self.message('' + Tools.escapeHTML(pokemon.side.name) + ' sent out ' + pokemon.getFullName() + '!');
+			}
+
+			pokemon.sprite.animSummon(slot);
+			if (pokemon.hasVolatile('substitute')) {
+				pokemon.sprite.animSub();
+			}
+			if (pokemon.statbarElem) {
+				pokemon.statbarElem.remove();
+			}
+			self.statElem.append(selfS.getStatbarHTML(pokemon));
+			pokemon.statbarElem = self.statElem.children().last();
+			selfS.updateStatbar(pokemon, true);
+			pokemon.side.updateSidebar();
+			if (self.fastForward) {
+				pokemon.statbarElem.css({
+					display: 'block',
+					left: pokemon.sprite.left - 80,
+					top: pokemon.sprite.top - 73 - pokemon.sprite.statbarOffset,
+					opacity: 1
+				});
+				if (self.switchCallback) self.switchCallback(self, selfS);
+				return;
+			}
+			pokemon.statbarElem.css({
+				display: 'block',
+				left: pokemon.sprite.left - 80,
+				top: pokemon.sprite.top - 53 - pokemon.sprite.statbarOffset,
+				opacity: 0
+			});
+			pokemon.statbarElem.delay(300).animate({
+				top: pokemon.sprite.top - 73 - pokemon.sprite.statbarOffset,
+				opacity: 1
+			}, 400);
+
+			self.dogarsCheck(pokemon);
+
+			if (self.switchCallback) self.switchCallback(self, selfS);
+		};
+		this.dragIn = function (pokemon, slot) {
+			if (slot === undefined) slot = pokemon.slot;
+			self.message('' + pokemon.getFullName() + ' was dragged out!');
+			if (pokemon === selfS.active[slot]) return;
+			var oldpokemon = selfS.active[slot];
+			selfS.lastPokemon = oldpokemon;
+			if (oldpokemon) oldpokemon.clearVolatile();
+			pokemon.clearVolatile();
+			pokemon.lastmove = '';
+			self.lastmove = 'switch-in';
+			selfS.active[slot] = pokemon;
+
+			if (oldpokemon === pokemon) return;
+
+			if (oldpokemon) {
+				oldpokemon.sprite.animDragOut();
+			}
+			pokemon.sprite.animDragIn(slot);
+			if (pokemon.statbarElem) {
+				pokemon.statbarElem.remove();
+			}
+			self.statElem.append(selfS.getStatbarHTML(pokemon));
+			pokemon.statbarElem = self.statElem.children().last();
+			selfS.updateStatbar(pokemon, true);
+			if (self.fastForward) {
+				if (oldpokemon) {
+					oldpokemon.statbarElem.remove();
+					oldpokemon.statbarElem = null;
+				}
+				pokemon.statbarElem.css({
+					display: 'block',
+					left: (selfS.n == 0 ? 100 : 340),
+					top: pokemon.sprite.top - 73 - pokemon.sprite.statbarOffset,
+					opacity: 1
+				});
+				if (self.dragCallback) self.dragCallback(self, selfS);
+				return;
+			}
+			if (selfS.n == 0) {
+				if (oldpokemon) {
+					oldpokemon.statbarElem.animate({
+						left: pokemon.sprite.left - 130,
+						opacity: 0
+					}, 400, function () {
+						oldpokemon.statbarElem.remove();
+						oldpokemon.statbarElem = null;
+					});
+				}
+				pokemon.statbarElem.css({
+					display: 'block',
+					left: pokemon.sprite.left - 30,
+					top: pokemon.sprite.top - 73 - pokemon.sprite.statbarOffset,
+					opacity: 0
+				});
+				pokemon.statbarElem.delay(300).animate({
+					left: pokemon.sprite.left - 80,
+					opacity: 1
+				}, 400);
+			} else {
+				if (oldpokemon) {
+					oldpokemon.statbarElem.animate({
+						left: pokemon.sprite.left - 30,
+						opacity: 0
+					}, 400, function () {
+						oldpokemon.statbarElem.remove();
+						oldpokemon.statbarElem = null;
+					});
+				}
+				pokemon.statbarElem.css({
+					display: 'block',
+					left: pokemon.sprite.left - 130,
+					top: pokemon.sprite.top - 73 - pokemon.sprite.statbarOffset,
+					opacity: 0
+				});
+				pokemon.statbarElem.delay(300).animate({
+					left: pokemon.sprite.left - 80,
+					opacity: 1
+				}, 400);
+			}
+
+			self.dogarsCheck(pokemon);
+
+			if (self.dragCallback) self.dragCallback(self, selfS);
+		};
+		this.replace = function (pokemon, slot) {
+			if (slot === undefined) slot = pokemon.slot;
+			var oldpokemon = selfS.active[slot];
+			if (pokemon === oldpokemon) return;
+			selfS.lastPokemon = oldpokemon;
+			pokemon.clearVolatile();
+			if (oldpokemon) {
+				pokemon.lastmove = oldpokemon.lastmove;
+				pokemon.hp = oldpokemon.hp;
+				pokemon.maxhp = oldpokemon.maxhp;
+				pokemon.status = oldpokemon.status;
+				pokemon.copyVolatileFrom(oldpokemon, true);
+			}
+			selfS.active[slot] = pokemon;
+
+			if (oldpokemon) {
+				oldpokemon.sprite.animUnsummon(true);
+			}
+			pokemon.sprite.animSummon(slot, true);
+			if (oldpokemon) {
+				oldpokemon.statbarElem.remove();
+				oldpokemon.statbarElem = null;
+			}
+			if (pokemon.statbarElem) {
+				pokemon.statbarElem.remove();
+			}
+			self.statElem.append(selfS.getStatbarHTML(pokemon));
+			pokemon.statbarElem = self.statElem.children().last();
+			selfS.updateStatbar(pokemon, true);
+			pokemon.statbarElem.css({
+				display: 'block',
+				left: pokemon.sprite.left - 80,
+				top: pokemon.sprite.top - 73 - pokemon.sprite.statbarOffset,
+				opacity: 1
+			});
+			// not sure if we want a different callback
+			if (self.dragCallback) self.dragCallback(self, selfS);
+		};
+		this.switchOut = function (pokemon, slot) {
+			if (slot === undefined) slot = pokemon.slot;
+			if (pokemon.lastmove !== 'batonpass') {
+				pokemon.clearVolatile();
+			} else {
+				pokemon.removeVolatile('transform');
+				pokemon.removeVolatile('formechange');
+			}
+			if (pokemon.lastmove === 'uturn' || pokemon.lastmove === 'voltswitch') {
+				self.message('' + pokemon.getName() + ' went back to ' + Tools.escapeHTML(pokemon.side.name) + '!');
+			} else if (pokemon.lastmove !== 'batonpass') {
+				if (pokemon.side.n === 0) {
+					self.message('' + pokemon.getName() + ', come back!');
+				} else {
+					self.message('' + Tools.escapeHTML(pokemon.side.name) + ' withdrew ' + pokemon.getFullName() + '!');
+				}
+			}
+			selfS.lastPokemon = pokemon;
+			selfS.active[slot] = null;
+
+			selfS.updateStatbar(pokemon, true);
+			pokemon.sprite.animUnsummon();
+			if (self.fastForward) {
+				pokemon.statbarElem.remove();
+				pokemon.statbarElem = null;
+				return;
+			}
+			pokemon.statbarElem.animate({
+				top: pokemon.sprite.top - 43 - pokemon.sprite.statbarOffset,
+				opacity: 0
+			}, 300, function () {
+				pokemon.statbarElem.remove();
+				pokemon.statbarElem = null;
+			});
+			//pokemon.statbarElem.done(pokemon.statbarElem.remove());
+		};
+		this.faint = function (pokemon, slot) {
+			if (slot === undefined) slot = pokemon.slot;
+			pokemon.clearVolatile();
+			selfS.lastPokemon = pokemon;
+			selfS.active[slot] = null;
+
+			self.message('' + pokemon.getName() + ' fainted!');
+
+			pokemon.fainted = true;
+			pokemon.zerohp = true;
+			pokemon.hp = 0;
+			pokemon.side.updateStatbar(pokemon, false, true);
+			pokemon.side.updateSidebar();
+
+			pokemon.sprite.animFaint();
+			pokemon.statbarElem.animate({
+				opacity: 0
+			}, 300, function () {
+				pokemon.statbarElem.remove();
+				pokemon.statbarElem = null;
+			});
+			if (self.faintCallback) self.faintCallback(self, selfS);
+		};
+		this.updateHPText = function (pokemon) {
+			var $hptext = pokemon.statbarElem.find('.hptext');
+			var $hptextborder = pokemon.statbarElem.find('.hptextborder');
+			if (pokemon.maxhp === 48) {
+				$hptext.hide();
+				$hptextborder.hide();
+			} else {
+				$hptext.html(pokemon.hpWidth(100) + '%');
+				$hptext.show();
+				$hptextborder.show();
+			}
+		};
+		this.updateStatbar = function (pokemon, updatePrevhp, updateHp) {
+			if (!pokemon) {
+				if (selfS.active[0]) selfS.updateStatbar(selfS.active[0], updatePrevhp, updateHp);
+				if (selfS.active[1]) selfS.updateStatbar(selfS.active[1], updatePrevhp, updateHp);
+				return;
+			}
+			if (!pokemon || !pokemon.statbarElem) {
+				return;
+			}
+			var hpcolor;
+			if (updatePrevhp || updateHp) {
+				hpcolor = pokemon.getHPColor();
+				var w = pokemon.hpWidth(150);
+				var $hp = pokemon.statbarElem.find('.hp');
+				$hp.css({
+					width: w,
+					'border-right-width': (w ? 1 : 0)
+				});
+				if (hpcolor === 'g') $hp.removeClass('hp-yellow hp-red');
+				else if (hpcolor === 'y') $hp.removeClass('hp-red').addClass('hp-yellow');
+				else $hp.addClass('hp-red');
+				selfS.updateHPText(pokemon);
+			}
+			if (updatePrevhp) {
+				var $prevhp = pokemon.statbarElem.find('.prevhp');
+				$prevhp.css('width', pokemon.hpWidth(150) + 1);
+				if (hpcolor === 'g') $prevhp.removeClass('prevhp-yellow prevhp-red');
+				else if (hpcolor ==='y' ) $prevhp.removeClass('prevhp-red').addClass('prevhp-yellow');
+				else $prevhp.addClass('prevhp-red');
+			}
+			var status = '';
+			if (pokemon.status === 'brn') {
+				status += '<span class="brn">BRN</span> ';
+			} else if (pokemon.status === 'psn') {
+				status += '<span class="psn">PSN</span> ';
+			} else if (pokemon.status === 'tox') {
+				status += '<span class="psn">TOX</span> ';
+			} else if (pokemon.status === 'slp') {
+				status += '<span class="slp">SLP</span> ';
+			} else if (pokemon.status === 'par') {
+				status += '<span class="par">PAR</span> ';
+			} else if (pokemon.status === 'frz') {
+				status += '<span class="frz">FRZ</span> ';
+			}
+			for (x in pokemon.boosts) {
+				if (pokemon.boosts[x]) {
+					status += '<span class="' + pokemon.getBoostType(x) + '">' + pokemon.getBoost(x) + '</span> ';
+				}
+			}
+			var statusTable = {
+				confusion: '<span class="bad">Confused</span> ',
+				healblock: '<span class="bad">Heal&nbsp;Block</span> ',
+				yawn: '<span class="bad">Drowsy</span> ',
+				flashfire: '<span class="good">Flash&nbsp;Fire</span> ',
+				imprison: '<span class="good">Imprisoning&nbsp;foe</span> ',
+				formechange: '',
+				typechange: '',
+				autotomize: '<span class="neutral">Lightened</span> ',
+				miracleeye: '<span class="bad">Miracle&nbsp;Eye</span> ',
+				foresight: '<span class="bad">Foresight</span> ',
+				telekinesis: '<span class="neutral">Telekinesis</span> ',
+				transform: '<span class="neutral">Transformed</span> ',
+				powertrick: '<span class="neutral">Power&nbsp;Trick</span> ',
+				curse: '<span class="bad">Curse</span> ',
+				nightmare: '<span class="bad">Nightmare</span> ',
+				attract: '<span class="bad">Attract</span> ',
+				torment: '<span class="bad">Torment</span> ',
+				taunt: '<span class="bad">Taunt</span> ',
+				disable: '<span class="bad">Disable</span> ',
+				embargo: '<span class="bad">Embargo</span> ',
+				ingrain: '<span class="good">Ingrain</span> ',
+				aquaring: '<span class="good">Aqua&nbsp;Ring</span> ',
+				stockpile1: '<span class="good">Stockpile</span> ',
+				stockpile2: '<span class="good">Stockpile&times;2</span> ',
+				stockpile3: '<span class="good">Stockpile&times;3</span> ',
+				perish1: '<span class="bad">Perish&nbsp;next&nbsp;turn</span> ',
+				perish2: '<span class="bad">Perish&nbsp;in&nbsp;2</span> ',
+				perish3: '<span class="bad">Perish&nbsp;in&nbsp;3</span> ',
+				airballoon: '<span class="good">Balloon</span> ',
+				leechseed: '<span class="bad">Leech&nbsp;Seed</span> ',
+				encore: '<span class="bad">Encore</span> ',
+				mustrecharge: '<span class="bad">Must&nbsp;recharge</span> ',
+				bide: '<span class="good">Bide</span> ',
+				magnetrise: '<span class="good">Magnet&nbsp;Rise</span> ',
+				smackdown: '<span class="bad">Smack&nbsp;Down</span> ',
+				focusenergy: '<span class="good">Focus&nbsp;Energy</span> ',
+				slowstart: '<span class="bad">Slow&nbsp;Start</span> ',
+				doomdesire: '',
+				futuresight: '',
+				mimic: '<span class="good">Mimic</span> ',
+				watersport: '<span class="good">Water&nbsp;Sport</span> ',
+				mudsport: '<span class="good">Mud&nbsp;Sport</span> ',
+				substitute: '',
+				// sub graphics are handled elsewhere, see Battle.Sprite.animSub()
+				uproar: '<span class="neutral">Uproar</span>',
+				roost: '<span class="neutral">Landed</span>',
+				protect: '<span class="good">Protect</span>',
+				quickguard: '<span class="good">Quick&nbsp;Guard</span>',
+				wideguard: '<span class="good">Wide&nbsp;Guard</span>',
+				helpinghand: '<span class="good">Helping&nbsp;Hand</span>',
+				magiccoat: '<span class="good">Magic&nbsp;Coat</span>',
+				destinybond: '<span class="good">Destiny&nbsp;Bond</span>',
+				snatch: '<span class="good">Snatch</span>',
+				grudge: '<span class="good">Grudge</span>',
+				endure: '<span class="good">Endure</span>',
+				focuspunch: '<span class="neutral">Focusing</span>',
+				powder: '<span class="bad">Powder</span>',
+				ragepowder: '<span class="good">Rage Powder</span>',
+				followme: '<span class="good">Follow Me</span>'
+			};
+			for (i in pokemon.volatiles) {
+				if (typeof statusTable[i] === 'undefined') status += '<span class="neutral">[['+i+']]</span>';
+				else status += statusTable[i];
+			}
+			for (i in pokemon.turnstatuses) {
+				if (typeof statusTable[i] === 'undefined') status += '<span class="neutral">[['+i+']]</span>';
+				else status += statusTable[i];
+			}
+			for (i in pokemon.movestatuses) {
+				if (typeof statusTable[i] === 'undefined') status += '<span class="neutral">[['+i+']]</span>';
+				else status += statusTable[i];
+			}
+			var statusbar = pokemon.statbarElem.find('.status');
+			statusbar.html(status);
+		}
+	};
+	this.sidesSwitched = false;
+	this.switchSides = function () {
+		self.sidesSwitched = !self.sidesSwitched;
+		if (self.sidesSwitched) {
+			self.mySide = self.p2;
+			self.yourSide = self.p1;
+		} else {
+			self.mySide = self.p1;
+			self.yourSide = self.p2;
+		}
+		self.mySide.n = 0;
+		self.yourSide.n = 1;
+		self.sides[0] = self.mySide;
+		self.sides[1] = self.yourSide;
+
+		self.mySide.updateSidebar();
+		self.mySide.updateSprites();
+		self.yourSide.updateSidebar();
+		self.yourSide.updateSprites();
+		// nothing else should need updating - don't call this function after sending out pokemon
+	}
+
+	this.messageActive = false;
+	this.message = function (message, hiddenmessage) {
+		if (message && !self.messageActive) {
+			self.log('<div class="spacer"></div>');
+		}
+		if (message && !self.fastForward) {
+			if (!self.messageActive) {
+				self.messagebarElem.empty();
+				self.messagebarElem.css({
+					display: 'block',
+					opacity: 0,
+					height: 'auto'
+				});
+				self.messagebarElem.animate({
+					opacity: 1
+				}, 300);
+			}
+			self.hiddenMessageElem.append('<p></p>');
+			var messageElem = self.hiddenMessageElem.children().last();
+			messageElem.html(message);
+			messageElem.css({
+				display: 'block',
+				opacity: 0
+			});
+			messageElem.animate({
+				height: 'hide'
+			}, 1, function () {
+				messageElem.appendTo(self.messagebarElem);
+				messageElem.animate({
+					height: 'show',
+					'padding-bottom': 4,
+					opacity: 1
+				}, 300);
+			});
+			self.activityWait(messageElem);
+		}
+		self.messageActive = true;
+		self.log('<div>' + message + (hiddenmessage ? hiddenmessage : '') + '</div>');
+	}
+	this.endAction = function () {
+		if (self.messageActive) {
+			self.messageActive = false;
+			if (!self.fastForward) {
+				self.messagebarElem.delay(self.messageDelay).animate({
+					height: 'toggle',
+					opacity: 0
+				}, 300);
+				self.activityWait(self.messagebarElem);
+			}
+		}
+	}
+
+	//
+	// activities
+	//
+	this.start = function () {
+		self.log('<div>Battle between ' + Tools.escapeHTML(self.p1.name) + ' and ' + Tools.escapeHTML(self.p2.name) + ' started!</div>');
+		if (self.startCallback) self.startCallback(self);
+	}
+	this.winner = function (winner) {
+		if (winner) self.message('' + winner + ' won the battle!');
+		else self.message('Tie between ' + Tools.escapeHTML(self.p1.name) + ' and ' + Tools.escapeHTML(self.p2.name) + '!');
+		self.done = 1;
+	}
+	this.prematureEnd = function () {
+		self.message('This replay ends here.');
+		self.done = 1;
+	}
+	this.endLastTurn = function() {
+		if (self.endLastTurnPending) {
+			self.endLastTurnPending = false;
+			self.mySide.updateStatbar(null, true);
+			self.yourSide.updateStatbar(null, true);
+		}
+	}
+	this.setTurn = function (turnnum) {
+		turnnum = parseInt(turnnum);
+		if (turnnum == self.turn+1) {
+			self.endLastTurnPending = true;
+		}
+		self.turn = turnnum;
+		self.updateWeatherLeft();
+
+		if (self.mySide.active[0]) self.mySide.active[0].clearTurnstatuses();
+		if (self.mySide.active[1]) self.mySide.active[1].clearTurnstatuses();
+		if (self.yourSide.active[0]) self.yourSide.active[0].clearTurnstatuses();
+		if (self.yourSide.active[1]) self.yourSide.active[1].clearTurnstatuses();
+
+		self.log('<h2>Turn ' + turnnum + '</h2>');
+
+		var prevTurnElem = self.turnElem.children();
+		if (self.fastForward) {
+			if (prevTurnElem.length) prevTurnElem.html('Turn ' + turnnum);
+			else self.turnElem.append('<div class="turn" style="display:block;opacity:1;left:110px;">Turn ' + turnnum + '</div>');
+			if (self.turnCallback) self.turnCallback(self);
+			if (self.fastForward > -1 && turnnum >= self.fastForward) {
+				self.fastForwardOff();
+			}
+			return;
+		}
+		self.turnElem.append('<div class="turn">Turn ' + turnnum + '</div>');
+		var newTurnElem = self.turnElem.children().last();
+		newTurnElem.css({
+			display: 'block',
+			opacity: 0,
+			left: 160
+		});
+		newTurnElem.animate({
+			opacity: 1,
+			left: 110
+		}, 500).animate({
+			opacity: .4
+		}, 1500);
+		prevTurnElem.animate({
+			opacity: 0,
+			left: 60
+		}, 500, function () {
+			prevTurnElem.remove();
+		});
+		self.activityWait(500);
+		if (self.turnCallback) self.turnCallback(self);
+	}
+	this.changeWeather = function (weather, poke, isUpkeep) {
+		weather = toId(weather);
+		var weatherTable = {
+			sunnyday: {
+				name: 'Sun',
+				startMessage: 'The sunlight turned harsh!',
+				abilityMessage: "'s Drought intensified the sun's rays!",
+				//upkeepMessage: 'The sunlight is strong!',
+				endMessage: "The sunlight faded."
+			},
+			raindance: {
+				name: 'Rain',
+				startMessage: 'It started to rain!',
+				abilityMessage: "'s Drizzle made it rain!",
+				//upkeepMessage: 'Rain continues to fall!',
+				endMessage: 'The rain stopped.'
+			},
+			sandstorm: {
+				name: 'Sandstorm',
+				startMessage: 'A sandstorm kicked up!',
+				abilityMessage: "'s Sand Stream whipped up a sandstorm!",
+				upkeepMessage: 'The sandstorm rages.',
+				endMessage: 'The sandstorm subsided.'
+			},
+			hail: {
+				name: 'Hail',
+				startMessage: 'It started to hail!',
+				abilityMessage: "'s Snow Warning whipped up a hailstorm!",
+				upkeepMessage: 'The hail crashes down.',
+				endMessage: 'The hail stopped.'
+			}
+		};
+		if (!weather || weather === 'none') {
+			weather = '';
+		}
+		var newWeather = weatherTable[weather];
+		if (isUpkeep) {
+			if (!self.fastForward) {
+				self.weatherElem.animate({
+					opacity: 1.0
+				}, 400).animate({
+					opacity: .4
+				}, 400);
+			}
+			if (newWeather && newWeather.upkeepMessage) self.log('<div><small>' + newWeather.upkeepMessage + '</small></div>');
+			return;
+		}
+		if (newWeather) {
+			if (poke) {
+				self.message('<small>' + poke.getName() + newWeather.abilityMessage + '</small>');
+				self.weatherTimeLeft = 0;
+				self.weatherMinTimeLeft = 0;
+			} else if (isUpkeep) {
+				self.log('<div><small>' + newWeather.upkeepMessage + '</small></div>');
+				self.weatherTimeLeft = 0;
+				self.weatherMinTimeLeft = 0;
+			} else {
+				self.message('<small>' + newWeather.startMessage + '</small>');
+				self.weatherTimeLeft = 8;
+				self.weatherMinTimeLeft = 5;
+			}
+		}
+		if (self.weather && !newWeather) {
+			self.message(weatherTable[self.weather].endMessage);
+		}
+		self.updateWeather(weather);
+	}
+	this.updateWeatherLeft = function () {
+		for (var i = 0; i < self.pseudoWeather.length; i++) {
+			if (self.pseudoWeather[i][1] > 0) self.pseudoWeather[i][1]--;
+		}
+		if (self.weather && self.weatherTimeLeft) {
+			self.weatherTimeLeft--;
+			if (self.weatherMinTimeLeft != 0) self.weatherMinTimeLeft--;
+		}
+		self.updateWeather();
+	};
+	this.weatherLeft = function (weather) {
+		if (weather) {
+			for (var i = 0; i < self.pseudoWeather.length; i++) {
+				if (self.pseudoWeather[i][0] === weather) {
+					if (self.pseudoWeather[i][1]) {
+						return ' <small>(' + self.pseudoWeather[i][1] + ' turn' + (self.pseudoWeather[i][1] == 1 ? '' : 's') + ' left)</small>';
+					}
+					return '';
+				}
+			}
+			return ''; // weather doesn't exist
+		}
+		if (self.weatherMinTimeLeft != 0) {
+			return ' <small>(' + self.weatherMinTimeLeft + ' to ' + self.weatherTimeLeft + ' turns left)</small>';
+		}
+		if (self.weatherTimeLeft != 0) {
+			return ' <small>(' + self.weatherTimeLeft + ' turn' + (self.weatherTimeLeft == 1 ? '' : 's') + ' left)</small>';
+		}
+		return '';
+	}
+	this.updateWeather = function (weather) {
+		var weatherNameTable = {
+			sunnyday: 'Sun',
+			raindance: 'Rain',
+			sandstorm: 'Sandstorm',
+			hail: 'Hail'
+		};
+
+		if (typeof weather === 'undefined') {
+			weather = self.weather;
+		}
+		if (weather === '' || weather === 'none' || weather === 'pseudo') {
+			weather = (self.pseudoWeather.length ? 'pseudo' : '');
+		}
+
+		var oldweather = self.weather;
+		self.weather = weather;
+
+		var weatherhtml = '';
+		if (weather) {
+			if (weather !== 'pseudo') {
+				weatherhtml += weatherNameTable[weather] + self.weatherLeft();
+			}
+			for (var i = 0; i < self.pseudoWeather.length; i++) {
+				weatherhtml += '<br />' + Tools.getMove(self.pseudoWeather[i][0]).name + self.weatherLeft(self.pseudoWeather[i][0]);
+			}
+		}
+		if (weather === oldweather) {
+			if (weather) self.weatherElem.html('<em>' + weatherhtml + '</em>');
+			return;
+		}
+		if (oldweather) {
+			if (weather) {
+				self.weatherElem.animate({
+					opacity: 0
+				}, 300, function () {
+					self.weatherElem.css({
+						display: 'block'
+					});
+					self.weatherElem.attr('class', 'weather ' + weather + 'weather');
+					self.weatherElem.html('<em>' + weatherhtml + '</em>');
+				});
+			} else {
+				self.weatherElem.animate({
+					opacity: 0
+				}, 500);
+			}
+		} else if (weather) {
+			self.weatherElem.css({
+				display: 'block',
+				opacity: 0
+			});
+			self.weatherElem.attr('class', 'weather ' + weather + 'weather');
+			self.weatherElem.html('<em>' + weatherhtml + '</em>');
+		}
+		if (weather) {
+			if (self.fastForward) {
+				self.weatherElem.css({opacity:.4});
+				return;
+			}
+			self.weatherElem.animate({
+				opacity: 1.0
+			}, 400).animate({
+				opacity: .4
+			}, 400);
+		}
+	}
+	this.resultAnim = function (pokemon, result, type, i) {
+		if (self.fastForward) {
+			pokemon.side.updateStatbar(pokemon, false, true);
+			return;
+		}
+		if (!i) {
+			i = 0;
+		}
+		self.fxElem.append('<div class="result ' + type + 'result"><strong>' + result + '</strong></div>');
+		effectElem = self.fxElem.children().last();
+		effectElem.delay(i * 350 + self.animationDelay).css({
+			display: 'block',
+			opacity: 0,
+			top: pokemon.sprite.top - 5,
+			left: pokemon.sprite.left - 75
+		}).animate({
+			opacity: 1
+		}, 1);
+		effectElem.animate({
+			opacity: 0,
+			top: pokemon.sprite.top - 65
+		}, 1000, 'swing');
+		pokemon.side.updateStatbar(pokemon);
+		self.activityWait(effectElem);
+	}
+	this.damageAnim = function (pokemon, damage, i) {
+		if (!pokemon.statbarElem) return;
+		if (!i) i = 0;
+		pokemon.side.updateHPText(pokemon);
+
+		self.resultAnim(pokemon, '&minus;' + damage, 'bad', i);
+
+		var $hp = pokemon.statbarElem.find('div.hp').delay(self.animationDelay);
+		var w = pokemon.hpWidth(150);
+		var hpcolor = pokemon.getHPColor();
+		var callback;
+		if (hpcolor === 'y') callback = function() {
+			$hp.addClass('hp-yellow');
+		};
+		if (hpcolor === 'r') callback = function() {
+			$hp.addClass('hp-yellow');
+			$hp.addClass('hp-red');
+		};
+
+		if (self.fastForward) {
+			$hp.css({
+				width: w,
+				'border-right-width': w ? 1 : 0
+			});
+			if (callback) callback();
+		} else {
+			$hp.animate({
+				width: w,
+				'border-right-width': w ? 1 : 0
+			}, 350, callback);
+		}
+	};
+	this.healAnim = function (pokemon, damage, i) {
+		if (!pokemon.statbarElem) return;
+		if (!i) i = 0;
+		pokemon.side.updateHPText(pokemon);
+
+		self.resultAnim(pokemon, '+' + damage, 'good', i);
+
+		var $hp = pokemon.statbarElem.find('div.hp').delay(self.animationDelay);
+		var w = pokemon.hpWidth(150);
+		var hpcolor = pokemon.getHPColor();
+		var callback;
+		if (hpcolor === 'g') callback = function() {
+			$hp.removeClass('hp-yellow');
+			$hp.removeClass('hp-red');
+		};
+		if (hpcolor === 'y') callback = function() {
+			$hp.removeClass('hp-red');
+		};
+
+		if (self.fastForward) {
+			$hp.css({
+				width: w,
+				'border-right-width': w ? 1 : 0
+			});
+			if (callback) callback();
+		} else {
+			$hp.animate({
+				width: w,
+				'border-right-width': w ? 1 : 0
+			}, 350, callback);
+		}
+	};
+	this.useMove = function (pokemon, move, target, kwargs) {
+		var fromeffect = Tools.getEffect(kwargs.from);
+		pokemon.clearMovestatuses();
+		if (move.id === 'focuspunch') {
+			pokemon.removeTurnstatus('focuspunch');
+		}
+		pokemon.side.updateStatbar(pokemon);
+		if (!target) {
+			target = pokemon.side.foe.active[0];
+		}
+		if (!target) {
+			target = pokemon.side.foe.missedPokemon;
+		}
+		if (!kwargs.silent) {
+			switch (fromeffect.id) {
+			case 'snatch':
+				break;
+			case 'magicbounce':
+			case 'magiccoat':
+			case 'rebound':
+				self.resultAnim(pokemon, "Bounced", 'good');
+				if (fromeffect.id === 'magiccoat') {
+					pokemon.addTurnstatus('magiccoat');
+				}
+				self.message(target.getName() + "'s " + move.name + " was bounced back by " +  fromeffect.name + "!");
+				break;
+			case 'metronome':
+				self.message('Waggling a finger let it use <strong>' + move.name + '</strong>!');
+				break;
+			case 'naturepower':
+				self.message('Nature Power turned into <strong>' + move.name + '</strong>!');
+				break;
+			case 'sleeptalk':
+			default:
+				// April Fool's 2013
+				if (window.Config && Config.server && Config.server.afd && move.id === 'earthquake') {
+					self.message(pokemon.getName() + ' used <strong>Fissure</strong>!');
+					self.message('Just kidding! It was <strong>Earthquake</strong>!');
+				} else {
+					self.message(pokemon.getName() + ' used <strong>' + move.name + '</strong>!');
+				}
+				break;
+			}
+			// April Fool's 2013
+			if (window.Config && Config.server && Config.server.afd && move.id === 'taunt') {
+				var quotes = [
+					"Yo mama so fat, she 4x resists Ice- and Fire-type attacks!",
+					"Yo mama so ugly, Captivate raises her opponent's Special Attack!",
+					"Yo mama so dumb, she lowers her Special Attack when she uses Nasty Plot!",
+					"Yo mama so fat, Smogon switched to Pokemon Showdown because PO had an integer overflow bug when you used Grass Knot against her!",
+					"Yo mama so dumb, she thought Sylveon would be Light Type!"
+				];
+				var quote = quotes[(self.p1.name.charCodeAt(2) + self.p2.name.charCodeAt(2) + self.turn) % quotes.length];
+				self.message(pokemon.getName() + " said, \"" + quote + "\"");
+			}
+		}
+		if (!self.fastForward && !kwargs.still) {
+			// skip
+			if (kwargs.miss && target.side) {
+				target = target.side.missedPokemon;
+			}
+			if (kwargs.notarget) {
+				target = pokemon.side.foe.missedPokemon;
+			}
+			if (kwargs.prepare || kwargs.anim === 'prepare') {
+				self.prepareMove(pokemon, move, target);
+			} else if (!kwargs.notarget) {
+				move.anim(self, [pokemon.sprite, target.sprite]);
+			}
+		}
+		pokemon.lastmove = move.id;
+		self.lastmove = move.id;
+		if (move.id === 'wish' || move.id === 'healingwish') {
+			pokemon.side.wisher = pokemon;
+		}
+		if (move.id === 'hyperbeam' || move.id === 'gigaimpact' || move.id === 'rockwrecker' || move.id === 'roaroftime' || move.id === 'blastburn' || move.id === 'frenzyplant' || move.id === 'hydrocannon') {
+			if (!kwargs.miss && !kwargs.notarget) {
+				pokemon.addMovestatus('mustrecharge');
+				pokemon.side.updateStatbar();
+				self.animationDelay += 500;
+			}
+		}
+	};
+	this.cantUseMove = function (pokemon, effect, move, kwargs) {
+		pokemon.clearMovestatuses();
+		pokemon.side.updateStatbar(pokemon);
+		switch (effect.id) {
+		case 'taunt':
+			self.message('' + pokemon.getName() + ' can\'t use ' + move.name + ' after the taunt!');
+			break;
+		case 'gravity':
+			self.message('' + pokemon.getName() + ' can\'t use ' + move.name + ' because of gravity!');
+			break;
+		case 'healblock':
+			self.message('' + pokemon.getName() + ' can\'t use ' + move.name + ' because of Heal Block!');
+			break;
+		case 'imprison':
+			self.message('' + pokemon.getName() + ' can\'t use the sealed ' + move.name + '!');
+			break;
+		case 'par':
+			self.resultAnim(pokemon, 'Paralyzed', 'par');
+			BattleOtherAnims['fullparalysis'].anim(self, [pokemon.sprite]);
+			self.message('' + pokemon.getName() + ' is paralyzed! It can\'t move!');
+			break;
+		case 'frz':
+			self.resultAnim(pokemon, 'Frozen', 'frz');
+			self.message('' + pokemon.getName() + ' is frozen solid!');
+			break;
+		case 'slp':
+			self.resultAnim(pokemon, 'Asleep', 'slp');
+			self.message('' + pokemon.getName() + ' is fast asleep.');
+			break;
+		case 'skydrop':
+			self.message('Sky Drop won\'t let ' + pokemon.getLowerName() + ' go!');
+			break;
+		case 'truant':
+			self.resultAnim(pokemon, 'Truant', 'neutral');
+			self.message('' + pokemon.getName() + ' is loafing around!');
+			break;
+		case 'recharge':
+			BattleOtherAnims['selfstatus'].anim(self, [pokemon.sprite]);
+			self.resultAnim(pokemon, 'Must recharge', 'neutral');
+			self.message('<small>' + pokemon.getName() + ' must recharge!</small>');
+			break;
+		case 'focuspunch':
+			self.resultAnim(pokemon, 'Lost focus', 'neutral');
+			self.message(pokemon.getName() + ' lost its focus and couldn\'t move!');
+			pokemon.removeTurnstatus('focuspunch');
+			break;
+		case 'flinch':
+			self.resultAnim(pokemon, 'Flinched', 'neutral');
+			self.message(pokemon.getName() + ' flinched and couldn\'t move!');
+			pokemon.removeTurnstatus('focuspunch');
+			break;
+		case 'attract':
+			self.resultAnim(pokemon, 'Immobilized', 'neutral');
+			self.message(pokemon.getName() + ' is immobilized by love!');
+			break;
+		case 'nopp':
+			self.message(pokemon.getName() + ' used <strong>' + move.name + '</strong>!');
+			self.message('But there was no PP left for the move!');
+			break;
+		default:
+			self.message('<small>' + pokemon.getName() + (move.name ? ' can\'t use ' + move.name + '' : ' can\'t move') + '!</small>');
+			break;
+		}
+		pokemon.sprite.anim({time:1});
+	};
+	this.prepareMove = function (pokemon, move, target) {
+		if (!move.prepareAnim) return;
+		if (!target) {
+			target = pokemon.side.foe.active[0];
+		}
+		if (!target) {
+			target = pokemon;
+		}
+		if (!self.fastForward) move.prepareAnim(self, [pokemon.sprite, target.sprite]);
+		self.message('<small>'+move.prepareMessage(pokemon, target)+'</small>');
+	};
+	this.animMultiHitMove = function () {
+		if (self.multiHitMove && !self.fastForward) {
+			self.multiHitMove[0].anim(self, [self.multiHitMove[1], self.multiHitMove[2]]);
+			self.multiHitMove[3]++;
+			self.animationDelay += 500;
+		}
+	};
+	this.runMinor = function (args, kwargs, preempt, nextArgs, nextKwargs) {
+		var actions = '';
+		var hiddenactions = '';
+		var minors = self.minorQueue;
+		if (self.multiHitMove && minors.length) {
+			var lastMinor = minors[minors.length - 1];
+			//if (lastMinor[0][0] === '-damage' || lastMinor[0][1]['subdamage']) self.animMultiHitMove();
+		}
+		if (args) {
+			if (args[0] === '-crit' || args[0] === '-supereffective' || args[0] === '-resisted') args.then = '.';
+			if (args[0] === '-damage' && kwargs.from === 'Leech Seed' && nextArgs[0] === '-heal' && nextKwargs.silent) args.then = '.';
+			minors.push([args, kwargs]);
+			if (args.simult || args.then) {
+				return;
+			}
+		}
+		var animDelay = 0;
+		var nextAnimDelay = 0;
+		while (minors.length) {
+			var row = minors.shift();
+			args = row[0];
+			kwargs = row[1];
+			animDelay = nextAnimDelay;
+			if (!kwargs.simult) nextAnimDelay++;
+
+			switch (args[0]) {
+			case '-damage':
+				var poke = this.getPokemon(args[1]);
+				var damage = poke.healthParse(args[2], true);
+				if (damage === false) break;
+				self.lastDamage = (damage[2] || 1); // not sure if this is used for anything
+				var range = poke.getDamageRange(damage);
+				self.damageAnim(poke, poke.getFormattedRange(range, 0, ' to '), animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else if (kwargs.from) {
+					var effect = Tools.getEffect(kwargs.from);
+					var ofpoke = this.getPokemon(kwargs.of);
+					switch (effect.id) {
+					case 'stealthrock':
+						actions += "Pointed stones dug into " + poke.getLowerName() + "!";
+						break;
+					case 'spikes':
+						actions += "" + poke.getName() + " is hurt by the spikes!";
+						break;
+					case 'brn':
+						actions += "" + poke.getName() + " was hurt by its burn!";
+						break;
+					case 'psn':
+						actions += "" + poke.getName() + " was hurt by poison!";
+						break;
+					case 'lifeorb':
+						hiddenactions += "" + poke.getName() + " lost some of its HP!";
+						break;
+					case 'recoil':
+						actions += "" + poke.getName() + " is damaged by recoil!";
+						break;
+					case 'sandstorm':
+						actions += "" + poke.getName() + " is buffeted by the sandstorm!";
+						break;
+					case 'hail':
+						actions += "" + poke.getName() + " is buffeted by the hail!";
+						break;
+					case 'baddreams':
+						actions += "" + poke.getName() + " is tormented!";
+						break;
+					case 'nightmare':
+						actions += "" + poke.getName() + " is locked in a nightmare!";
+						break;
+					case 'confusion':
+						actions += "It hurt itself in its confusion! ";
+						break;
+					case 'leechseed':
+						if (!self.fastForward) {
+							BattleOtherAnims.leech.anim(self, [ofpoke.sprite, poke.sprite]);
+							self.activityWait(500);
+						}
+						actions += "" + poke.getName() + "'s health is sapped by Leech Seed!";
+						break;
+					case 'flameburst':
+						actions += "The bursting flame hit " + poke.getLowerName() + "!";
+						break;
+					case 'grasspledge':
+						actions += "" + poke.getName() + " is hurt by the sea of fire!";
+						break;
+					case 'jumpkick':
+					case 'highjumpkick':
+						actions += "" + poke.getName() + " kept going and crashed!";
+						break;
+					default:
+						if (ofpoke) {
+							actions += "" + poke.getName() + " is hurt by " + ofpoke.getLowerName() + "'s " + effect.name + "!";
+						} else if (effect.effectType === 'Item' || effect.effectType === 'Ability') {
+							actions += "" + poke.getName() + " is hurt by its " + effect.name + "!";
+						} else if (kwargs.partiallytrapped) {
+							actions += "" + poke.getName() + ' is hurt by ' + effect.name + '!';
+						} else {
+							actions += "" + poke.getName() + " lost some HP because of " + effect.name + "!";
+						}
+						break;
+					}
+				} else {
+					var damageinfo = '' + poke.getFormattedRange(range, 1, '–');
+					if (damage[1] !== 100) {
+						var hover = '' + ((damage[0] < 0) ? '&minus;' : '') +
+							Math.abs(damage[0]) + '/' + damage[1];
+						if (damage[1] === 48) { // this is a hack
+							hover += ' pixels';
+						}
+						damageinfo = '<abbr title="' + hover + '">' + damageinfo + '</abbr>';
+					}
+					hiddenactions += "" + poke.getName() + " lost " + damageinfo + " of its health!";
+				}
+				break;
+			case '-heal':
+				var poke = this.getPokemon(args[1]);
+				var damage = poke.healthParse(args[2], true, true);
+				if (damage === false) break;
+				var range = poke.getDamageRange(damage);
+				self.healAnim(poke, poke.getFormattedRange(range, 0, ' to '), animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else if (kwargs.from) {
+					var effect = Tools.getEffect(kwargs.from);
+					var ofpoke = this.getPokemon(kwargs.of);
+					switch (effect.id) {
+					case 'ingrain':
+						actions += "" + poke.getName() + " absorbed nutrients with its roots!";
+						break;
+					case 'aquaring':
+						actions += "Aqua Ring restored " + poke.getLowerName() + "'s HP!";
+						break;
+					case 'raindish': case 'dryskin': case 'icebody':
+						actions += "" + poke.getName() + "'s " + effect.name + " heals it!";
+						break;
+					case 'healingwish':
+						actions += "The healing wish came true for "+poke.getLowerName()+"!";
+						self.lastmove = 'healing-wish';
+						Tools.getMove('healingwish').residualAnim(self, [poke.sprite]);
+						poke.side.wisher = null;
+						break;
+					case 'lunardance':
+						actions += ""+poke.getName()+" became cloaked in mystical moonlight!";
+						self.lastmove = 'healing-wish';
+						Tools.getMove('healingwish').residualAnim(self, [poke.sprite]);
+						poke.side.wisher = null;
+						break;
+					case 'wish':
+						actions += "" + kwargs.wisher + "'s wish came true!";
+						Tools.getMove('wish').residualAnim(self, [poke.sprite]);
+						self.animationDelay += 500;
+						break;
+					case 'drain':
+						actions += ofpoke.getName() + ' had its energy drained!';
+						break;
+					default:
+						if (kwargs.absorb) {
+							actions += "" + poke.getName() + "'s " + effect.name + " absorbs the attack!";
+						} else if (effect.id) {
+							actions += "" + poke.getName() + " restored HP using its " + effect.name + "!";
+						} else {
+							actions += poke.getName() + ' regained health!';
+						}
+						break;
+					}
+				} else {
+					actions += poke.getName() + ' regained health!';
+				}
+				break;
+			case '-sethp':
+				var effect = Tools.getEffect(kwargs.from);
+				var poke, ofpoke;
+				for (var k=0; k<2; k++)
+				{
+					var cpoke = self.getPokemon(args[1+2*k]);
+					if (cpoke) {
+						var oldhp = cpoke.hp;
+						cpoke.healthParse(args[2+2*k]);
+						var diff = parseFloat(args[2+2*k]);
+						if (isNaN(diff)) {
+							diff = cpoke.hp - oldhp;
+						}
+						if (diff > 0) {
+							self.healAnim(cpoke, diff, animDelay);
+						} else {
+							self.damageAnim(cpoke, -diff, animDelay);
+						}
+					}
+					if (k==0) poke = cpoke;
+					if (k==1) ofpoke = cpoke;
+				}
+				switch (effect.id) {
+				case 'painsplit':
+					actions += 'The battlers shared their pain!';
+					break;
+				}
+
+				break;
+
+			case '-boost':
+				var poke = this.getPokemon(args[1]);
+				var stat = args[2];
+				var amount = parseInt(args[3]);
+				if (!poke.boosts[stat]) {
+					poke.boosts[stat] = 0;
+				}
+				poke.boosts[stat] += amount;
+				self.resultAnim(poke, poke.getBoost(stat), 'good', animDelay);
+
+				var amountString = '';
+				if (amount === 2) amountString = ' sharply';
+				if (amount >= 3) amountString = ' drastically';
+				if (kwargs.silent) {
+					// do nothing
+				} else if (kwargs.from) {
+					var effect = Tools.getEffect(kwargs.from);
+					var ofpoke = this.getPokemon(kwargs.of);
+					switch (effect.id) {
+					default:
+						if (effect.effectType === 'Item') {
+							actions += "The " + effect.name + amountString+" raised " + poke.getLowerName() + "'s " + BattleStats[stat] + "!";
+						} else {
+							actions += "" + poke.getName() + "'s " + effect.name +amountString+" raised its " + BattleStats[stat] + "!";
+						}
+						break;
+					}
+				} else {
+					actions += "" + poke.getName() + "'s " + BattleStats[stat] + amountString + " rose" + "!";
+				}
+				break;
+			case '-unboost':
+				var poke = this.getPokemon(args[1]);
+				var stat = args[2];
+				var amount = parseInt(args[3]);
+				if (!poke.boosts[stat]) {
+					poke.boosts[stat] = 0;
+				}
+				poke.boosts[stat] -= amount;
+				self.resultAnim(poke, poke.getBoost(stat), 'bad', animDelay);
+
+				var amountString = '';
+				if (amount === 2) amountString = ' harshly';
+				if (amount >= 3) amountString = ' severely';
+				if (kwargs.silent) {
+					// do nothing
+				} else if (kwargs.from) {
+					var effect = Tools.getEffect(kwargs.from);
+					var ofpoke = this.getPokemon(kwargs.of);
+					switch (effect.id) {
+					default:
+						if (effect.effectType === 'Item') {
+							actions += "The " + effect.name + amountString+" lowered " + poke.getLowerName() + "'s " + BattleStats[stat] + "!";
+						} else {
+							actions += "" + poke.getName() + "'s " + effect.name +amountString+" lowered its " + BattleStats[stat] + "!";
+						}
+						break;
+					}
+				} else {
+					actions += "" + poke.getName() + "'s " + BattleStats[stat] + amountString + " fell!";
+				}
+				break;
+			case '-setboost':
+				var poke = this.getPokemon(args[1]);
+				var stat = args[2];
+				var amount = parseInt(args[3]);
+				var effect = Tools.getEffect(kwargs.from);
+				var ofpoke = this.getPokemon(kwargs.of);
+				poke.boosts[stat] = amount;
+				self.resultAnim(poke, poke.getBoost(stat), (amount>0?'good':'bad'), animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else if (kwargs.from) {
+					switch (effect.id) {
+					case 'bellydrum':
+						actions += '' + poke.getName() + ' cut its own HP and maximized its Attack!';
+						break;
+					case 'angerpoint':
+						actions += '' + poke.getName() + ' maxed its Attack!';
+						break;
+					}
+				}
+				break;
+			case '-swapboost':
+				var poke = this.getPokemon(args[1]);
+				var poke2 = this.getPokemon(args[2]);
+				var stats = args[3]?args[3].split(', '):['atk','def','spa','spd','spe','accuracy','evasion'];
+				var effect = Tools.getEffect(kwargs.from);
+				for (var i=0; i<stats.length; i++)
+				{
+					var tmp = poke.boosts[stats[i]];
+					poke.boosts[stats[i]] = poke2.boosts[stats[i]];
+					if (!poke.boosts[stats[i]]) delete poke.boosts[stats[i]];
+					poke2.boosts[stats[i]] = tmp;
+					if (!poke2.boosts[stats[i]]) delete poke2.boosts[stats[i]];
+				}
+				self.resultAnim(poke, 'Stats swapped', 'neutral', animDelay);
+				self.resultAnim(poke2, 'Stats swapped', 'neutral', animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else if (effect.id) {
+					switch (effect.id) {
+					case 'guardswap':
+						actions += '' + poke.getName() + ' switched all changes to its Defense and Sp. Def with the target!';
+						break;
+					case 'heartswap':
+						actions += '' + poke.getName() + ' switched stat changes with the target!';
+						break;
+					case 'powerswap':
+						actions += '' + poke.getName() + ' switched all changes to its Attack and Sp. Atk with the target!';
+						break;
+					}
+				}
+				break;
+			case '-restoreboost':
+				var poke = this.getPokemon(args[1]);
+				for (i in poke.boosts) {
+					if (poke.boosts[i] < 0) delete poke.boosts[i];
+				}
+				self.resultAnim(poke, 'Restored', 'good', animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				}
+				break;
+			case '-copyboost':
+				var poke = this.getPokemon(args[1]);
+				var frompoke = this.getPokemon(args[2]);
+				var stats = args[3]?args[3].split(', '):['atk','def','spa','spd','spe','accuracy','evasion'];
+				var effect = Tools.getEffect(kwargs.from);
+				for (var i=0; i<stats.length; i++)
+				{
+					poke.boosts[stats[i]] = frompoke.boosts[stats[i]];
+					if (!poke.boosts[stats[i]]) delete poke.boosts[stats[i]];
+				}
+				//poke.boosts = $.extend({}, frompoke.boosts);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else {
+					self.resultAnim(poke, 'Stats copied', 'neutral', animDelay);
+					actions += "" + poke.getName() + " copied " + frompoke.getLowerName() + "'s stat changes!";
+				}
+				break;
+			case '-clearboost':
+				var poke = this.getPokemon(args[1]);
+				poke.boosts = {};
+				self.resultAnim(poke, 'Stats reset', 'neutral', animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else {
+					actions += '' + poke.getName() + '\'s stat changes were removed!';
+				}
+				break;
+			case '-invertboost':
+				var poke = this.getPokemon(args[1]);
+				for (i in poke.boosts) {
+					poke.boosts[i] = -poke.boosts[i];
+				}
+				self.resultAnim(poke, 'Stats inverted', 'neutral', animDelay);
+
+				if (kwargs.silent) {
+					// do nothing
+				} else {
+					actions += '' + poke.getName() + '\'s stat changes were inverted!';
+				}
+				break;
+			case '-clearallboost':
+				for (var slot=0; slot<self.mySide.active.length; slot++) {
+					if (self.mySide.active[slot]) {
+						self.mySide.active[slot].boosts = {};
+						self.resultAnim(self.mySide.active[slot], 'Stats reset', 'neutral', animDelay);
+					}
+					if (self.yourSide.active[slot]) {
+						self.yourSide.active[slot].boosts = {};
+						self.resultAnim(self.yourSide.active[slot], 'Stats reset', 'neutral', animDelay);
+					}
+				}
+
+				if (kwargs.silent) {
+					// do nothing
+				} else {
+					actions += 'All stat changes were eliminated!';
+				}
+				break;
+
+			case '-crit':
+				var poke = this.getPokemon(args[1]);
+				for (var j=1; !poke && j<10; j++) poke = this.getPokemon(minors[i+j][0][1]);
+				if (poke) self.resultAnim(poke, 'Critical hit', 'bad', animDelay);
+				actions += "A critical hit! ";
+				break;
+
+			case '-supereffective':
+				var poke = this.getPokemon(args[1]);
+				for (var j=1; !poke && j<10; j++) poke = this.getPokemon(minors[i+j][0][1]);
+				if (poke) self.resultAnim(poke, 'Super-effective', 'bad', animDelay);
+				actions += "It's super effective! ";
+				break;
+
+			case '-resisted':
+				var poke = this.getPokemon(args[1]);
+				for (var j=1; !poke && j<10; j++) poke = this.getPokemon(minors[i+j][0][1]);
+				if (poke) self.resultAnim(poke, 'Resisted', 'neutral', animDelay);
+				actions += "It's not very effective... ";
+				break;
+
+			case '-immune':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				self.resultAnim(poke, 'Immune', 'neutral', animDelay);
+				switch (effect.id) {
+				case 'confusion':
+					actions += "" + poke.getName() + " doesn't become confused! ";
+					break;
+				default:
+					if (kwargs.msg) {
+						actions += "It doesn't affect " + poke.getLowerName() + "... ";
+					} else {
+						actions += "It had no effect! ";
+					}
+					break;
+				}
+				break;
+
+			case '-miss':
+				var user = this.getPokemon(args[1]);
+				var target = this.getPokemon(args[2]);
+				if (target) {
+					actions += "" + target.getName() + " avoided the attack!";
+				} else {
+					actions += "" + user.getName() + "'s attack missed!";
+				}
+				break;
+
+			case '-fail':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var fromeffect = Tools.getEffect(kwargs.from);
+				if (poke) {
+					self.resultAnim(poke, 'Failed', 'neutral', animDelay);
+				}
+				switch (effect.id) {
+				case 'brn':
+					self.resultAnim(poke, 'Already burned', 'neutral', animDelay);
+					actions += "" + poke.getName() + " is already burned.";
+					break;
+				case 'tox':
+				case 'psn':
+					self.resultAnim(poke, 'Already poisoned', 'neutral', animDelay);
+					actions += "" + poke.getName() + " is already poisoned.";
+					break;
+				case 'slp':
+					if (fromeffect.id === 'uproar') {
+						self.resultAnim(poke, 'Failed', 'neutral', animDelay);
+						if (kwargs.msg) {
+							actions += "But " + poke.getLowerName() + " can't sleep in an uproar!";
+						} else {
+							actions += "But the uproar kept " + poke.getLowerName() + " awake!";
+						}
+					} else {
+						self.resultAnim(poke, 'Already asleep', 'neutral', animDelay);
+						actions += "" + poke.getName() + " is already asleep.";
+					}
+					break;
+				case 'par':
+					self.resultAnim(poke, 'Already paralyzed', 'neutral', animDelay);
+					actions += "" + poke.getName() + " is already paralyzed.";
+					break;
+				case 'frz':
+					self.resultAnim(poke, 'Already frozen', 'neutral', animDelay);
+					actions += "" + poke.getName() + " is already frozen.";
+					break;
+				case 'substitute':
+					if (kwargs.weak) {
+						actions += "It was too weak to make a substitute!";
+					} else {
+						actions += '' + poke.getName() + ' already has a substitute!';
+					}
+					break;
+				case 'unboost':
+					self.resultAnim(poke, 'Stat drop blocked', 'neutral', animDelay);
+					actions += "" + poke.getName() + "'s " + (args[3] ? args[3] + " was" : "stats were") + " not lowered!";
+					break;
+				case '':
+				default:
+					actions += "But it failed!";
+					break;
+				}
+				break;
+
+			case '-notarget':
+				actions += "But there was no target...";
+				break;
+
+			case '-ohko':
+				actions += "It's a one-hit KO!";
+				break;
+
+			case '-hitcount':
+				var hits = parseInt(args[2]);
+				if (self.multiHitMove && self.multiHitMove[3] === 0 && hits > 0) self.animMultiHitMove();
+				actions += 'Hit ' + hits + (hits > 1 ? ' times!' : ' time!');
+				break;
+
+			case '-nothing':
+				actions += "But nothing happened! ";
+				break;
+
+			case '-waiting':
+				var poke = this.getPokemon(args[1]);
+				var ofpoke = this.getPokemon(args[2]);
+				actions += "" + poke.getName() + " is waiting for " + ofpoke.getLowerName() + "'s move...";
+				break;
+
+			case '-combine':
+				actions += "The two moves are joined! It's a combined move!";
+				break;
+
+			case '-prepare':
+				var poke = this.getPokemon(args[1]);
+				var move = Tools.getMove(args[2]);
+				var target = this.getPokemon(args[3]);
+				self.prepareMove(poke, move, target);
+				break;
+
+			case '-status':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(kwargs.from);
+				poke.status = args[2];
+				poke.removeVolatile('yawn');
+
+				switch (args[2]) {
+				case 'brn':
+					self.resultAnim(poke, 'Burned', 'brn', animDelay);
+					actions += "" + poke.getName() + " was burned!";
+					break;
+				case 'tox':
+					self.resultAnim(poke, 'Toxic poison', 'psn', animDelay);
+					actions += "" + poke.getName() + " was badly poisoned!";
+					break;
+				case 'psn':
+					self.resultAnim(poke, 'Poisoned', 'psn', animDelay);
+					actions += "" + poke.getName() + " was poisoned!";
+					break;
+				case 'slp':
+					if (effect.id === 'rest') {
+						self.resultAnim(poke, 'Asleep', 'slp', animDelay);
+						actions += '' + poke.getName() + ' slept and became healthy!';
+					} else {
+						self.resultAnim(poke, 'Asleep', 'slp', animDelay);
+						actions += "" + poke.getName() + " fell asleep!";
+					}
+					break;
+				case 'par':
+					self.resultAnim(poke, 'Paralyzed', 'par', animDelay);
+					actions += "" + poke.getName() + " is paralyzed! It may be unable to move!";
+					break;
+				case 'frz':
+					self.resultAnim(poke, 'Frozen', 'frz', animDelay);
+					actions += "" + poke.getName() + " was frozen solid!";
+					break;
+				}
+				break;
+
+			case '-curestatus':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(kwargs.from);
+				var ofpoke = this.getPokemon(kwargs.of);
+				poke.status = '';
+
+				if (effect.id) switch (effect.id) {
+				case 'psychoshift':
+					actions += '' + poke.getName() + ' moved its status onto ' + ofpoke.getLowerName() + '!';
+					self.resultAnim(poke, 'Cured', 'good', animDelay);
+					break;
+				default:
+					self.resultAnim(poke, 'Cured', 'good', animDelay);
+					actions += "" + poke.getName() + "'s "+effect.name+" heals its status!";
+					break;
+				} else switch (args[2]) {
+				case 'brn':
+					self.resultAnim(poke, 'Burn cured', 'good', animDelay);
+					if (poke.side.n === 0) actions += "" + poke.getName() + "'s burn was healed.";
+					else actions += "" + poke.getName() + " healed its burn!";
+					break;
+				case 'tox':
+				case 'psn':
+					self.resultAnim(poke, 'Poison cured', 'good', animDelay);
+					var n = poke.side.n; // hack for eliminating "the opposing"
+					poke.side.n = 0;
+					actions += "" + poke.getName() + " was cured of its poisoning.";
+					poke.side.n = n;
+					break;
+				case 'slp':
+					self.resultAnim(poke, 'Woke up', 'good', animDelay);
+					actions += "" + poke.getName() + " woke up!";
+					break;
+				case 'par':
+					self.resultAnim(poke, 'Paralysis cured', 'good', animDelay);
+					actions += "" + poke.getName() + " was cured of paralysis.";
+					break;
+				case 'frz':
+					self.resultAnim(poke, 'Thawed', 'good', animDelay);
+					actions += "" + poke.getName() + " thawed out!";
+					break;
+				default:
+					poke.removeVolatile('confusion');
+					self.resultAnim(poke, 'Cured', 'good', animDelay);
+					actions += "" + poke.getName() + "'s status cleared!";
+				}
+				break;
+
+			case '-cureteam':
+				var poke = this.getPokemon(args[1]);
+				for (var k = 0; k < poke.side.pokemon.length; k++) {
+					poke.side.pokemon[k].status = '';
+					poke.side.updateStatbar(poke.side.pokemon[k]);
+				}
+
+				self.resultAnim(poke, 'Team Cured', 'good', animDelay);
+				var effect = Tools.getEffect(kwargs.from);
+				switch (effect.id) {
+				case 'aromatherapy':
+					actions += 'A soothing aroma wafted through the area!';
+					break;
+				case 'healbell':
+					actions += 'A bell chimed!';
+					break;
+				default:
+					actions += "" + poke.getName() + "'s team was cured!";
+					break;
+				}
+				break;
+
+			case '-item':
+				var poke = this.getPokemon(args[1]);
+				var item = Tools.getItem(args[2]);
+				var effect = Tools.getEffect(kwargs.from);
+				var ofpoke = this.getPokemon(kwargs.of);
+				poke.item = item.name;
+				poke.removeVolatile('airballoon');
+				if (item.id === 'airballoon') poke.addVolatile('airballoon');
+
+				if (effect.id) switch (effect.id) {
+				case 'recycle':
+				case 'pickup':
+					actions += '' + poke.getName() + ' found one ' + item.name + '!';
+					self.resultAnim(poke, item.name, 'neutral', animDelay);
+					break;
+				case 'frisk':
+					if (kwargs.identify) { // used for gen 6
+						actions += '' + ofpoke.getName() + ' frisked ' + poke.getLowerName() + ' and found its ' + item.name + '!';
+						self.resultAnim(poke, item.name, 'neutral', animDelay);
+					} else {
+						actions += '' + ofpoke.getName() + ' frisked its target and found one ' + item.name + '!';
+					}
+					break;
+				case 'thief':
+				case 'covet':
+					actions += '' + poke.getName() + ' stole ' + ofpoke.getLowerName() + "'s " + item.name + "!";
+					self.resultAnim(poke, item.name, 'neutral', animDelay);
+					self.resultAnim(ofpoke, 'Item Stolen', 'bad', animDelay);
+					break;
+				case 'harvest':
+					actions += '' + poke.getName() + ' harvested one ' + item.name + '!';
+					self.resultAnim(poke, item.name, 'neutral', animDelay);
+					break;
+				case 'bestow':
+					actions += '' + poke.getName() + ' received ' + item.name + ' from ' + ofpoke.getLowerName() + '!';
+					self.resultAnim(poke, item.name, 'neutral', animDelay);
+					break;
+				default:
+					actions += '' + poke.getName() + ' obtained one ' + item.name + '.';
+					self.resultAnim(poke, item.name, 'neutral', animDelay);
+					break;
+				} else switch (item.id) {
+				case 'airballoon':
+					self.resultAnim(poke, 'Balloon', 'good', animDelay);
+					actions += "" + poke.getName() + " floats in the air with its Air Balloon!";
+					break;
+				default:
+					actions += "" + poke.getName() + " has " + item.name + "!";
+					break;
+				}
+				break;
+
+			case '-enditem':
+				var poke = this.getPokemon(args[1]);
+				var item = Tools.getItem(args[2]);
+				var effect = Tools.getEffect(kwargs.from);
+				var ofpoke = this.getPokemon(kwargs.of);
+				poke.item = '';
+				poke.removeVolatile('airballoon');
+
+				if (kwargs.silent) {
+					// do nothing
+				} else if (kwargs.eat) {
+					actions += '' + poke.getName() + ' ate its ' + item.name + '!';
+					self.lastmove = item.id;
+				} else if (kwargs.weaken) {
+					actions += 'The ' + item.name + ' weakened the damage to '+poke.getLowerName();
+					self.lastmove = item.id;
+				} else if (effect.id) switch (effect.id) {
+				case 'fling':
+					actions += "" + poke.getName() + ' flung its ' + item.name + '!';
+					break;
+				case 'knockoff':
+					actions += '' + ofpoke.getName() + ' knocked off ' + poke.getLowerName() + '\'s ' + item.name + '!';
+					self.resultAnim(poke, 'Item knocked off', 'neutral', animDelay);
+					break;
+				case 'stealeat':
+					actions += '' + ofpoke.getName() + ' stole and ate its target\'s ' + item.name + '!';
+					break;
+				case 'gem':
+					actions += 'The ' + item.name + ' strengthened ' + Tools.getMove(kwargs.move).name + '\'s power!';
+					break;
+				case 'incinerate':
+					actions += "" + poke.getName() + "'s " + item.name + " was burnt up!";
+					break;
+				default:
+					actions += "" + poke.getName() + ' lost its ' + item.name + '!';
+					break;
+				} else switch (item.id) {
+				case 'airballoon':
+					poke.removeVolatile('airballoon');
+					self.resultAnim(poke, 'Balloon popped', 'neutral', animDelay);
+					actions += "" + poke.getName() + "'s Air Balloon popped!";
+					break;
+				case 'focussash':
+					self.resultAnim(poke, 'Sash', 'neutral', animDelay);
+					actions += "" + poke.getName() + ' hung on using its Focus Sash!';
+					break;
+				case 'focusband':
+					self.resultAnim(poke, 'Focus Band', 'neutral', animDelay);
+					actions += "" + poke.getName() + ' hung on using its Focus Band!';
+					break;
+				case 'mentalherb':
+					poke.removeVolatile('taunt');
+					poke.removeVolatile('encore');
+					poke.removeVolatile('torment');
+					self.resultAnim(poke, 'Cured', 'good', animDelay);
+					actions += "" + poke.getName() + " used its " + item.name + " to come back to its senses!";
+					break;
+				case 'whiteherb':
+					actions += "" + poke.getName() + " restored its status using its White Herb!";
+					break;
+				case 'ejectbutton':
+					actions += "" + poke.getName() + " is switched out with the Eject Button!";
+					break;
+				case 'redcard':
+					actions += "" + poke.getName() + " held up its Red Card against " + ofpoke.getLowerName() + "!";
+					break;
+				default:
+					actions += "" + poke.getName() + "'s " + item.name + " activated!";
+					break;
+				}
+				break;
+
+			case '-ability':
+				var poke = this.getPokemon(args[1]);
+				var ability = Tools.getAbility(args[2]);
+				var effect = Tools.getEffect(kwargs.from);
+				var ofpoke = this.getPokemon(kwargs.of);
+				poke.ability = ability.name;
+
+				if (kwargs.silent) {
+					// do nothing
+				} else if (effect.id) switch (effect.id) {
+				case 'trace':
+					actions += '' + poke.getName() + ' traced ' + ofpoke.getLowerName() + '\'s ' + ability.name + '!';
+					break;
+				case 'roleplay':
+					actions += '' + poke.getName() + ' copied ' + ofpoke.getLowerName() + '\'s ' + ability.name + '!';
+					break;
+				case 'mummy':
+					actions += "" + poke.getName() + "'s Ability became Mummy!";
+					break;
+				default:
+					actions += "" + poke.getName() + " acquired " + ability.name + "!";
+					break;
+				} else switch (ability.id) {
+				case 'pressure':
+					actions += "" + poke.getName() + " is exerting its pressure!";
+					break;
+				case 'moldbreaker':
+					actions += "" + poke.getName() + " breaks the mold!";
+					break;
+				case 'turboblaze':
+					actions += "" + poke.getName() + " is radiating a blazing aura!";
+					break;
+				case 'teravolt':
+					actions += "" + poke.getName() + " is radiating a bursting aura!";
+					break;
+				case 'intimidate':
+					actions += '' + poke.getName() + ' intimidates ' + ofpoke.getLowerName() + '!';
+					break;
+				case 'unnerve':
+					actions += "" + poke.getName() + "'s Unnerve makes " + this.getSide(args[3]).getLowerTeamName() + " too nervous to eat Berries!";
+					break;
+				case 'aurabreak':
+					actions += "" + poke.getName() + " reversed all other Pokémon's auras!";
+					break;
+				default:
+					actions += "" + poke.getName() + " has " + ability.name + "!";
+					break;
+				}
+				break;
+
+			case '-endability':
+				var poke = this.getPokemon(args[1]);
+				var ability = Tools.getAbility(args[2]);
+				var effect = Tools.getEffect(kwargs.from);
+				poke.ability = '';
+
+				if (kwargs.silent) {
+					// do nothing
+				} else switch (effect.id) {
+				default:
+					actions += "" + poke.getName() + "\'s Ability was suppressed!";
+					break;
+				}
+				break;
+
+			case '-transform':
+				var poke = this.getPokemon(args[1]);
+				var tpoke = this.getPokemon(args[2]);
+				actions += '' + poke.getName() + ' transformed into ' + tpoke.species + '!';
+				poke.sprite.animTransform(tpoke);
+				poke.boosts = $.extend({}, tpoke.boosts);
+				poke.addVolatile('transform');
+				poke.addVolatile('formechange'); // the formechange volatile reminds us to revert the sprite change on switch-out
+				//poke.removeVolatile('typechange'); // does this happen??
+				poke.ability = tpoke.ability;
+				poke.volatiles.formechange[2] = (tpoke.volatiles.formechange ? tpoke.volatiles.formechange[2] : tpoke.species);
+				self.resultAnim(poke, 'Transformed', 'good', animDelay);
+				break;
+			case '-formechange':
+				var poke = this.getPokemon(args[1]);
+				var template = Tools.getTemplate(args[2]);
+				if (poke.sprite.sp.shiny) template.shiny = true;
+				poke.sprite.animTransform(template);
+				poke.addVolatile('formechange'); // the formechange volatile reminds us to revert the sprite change on switch-out
+				poke.volatiles.formechange[2] = template.species;
+				poke.side.updateStatbar();
+				break;
+
+			case '-start':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var ofpoke = this.getPokemon(kwargs.of);
+				var fromeffect = Tools.getEffect(kwargs.from);
+				poke.addVolatile(effect.id);
+
+				switch (effect.id) {
+				case 'typechange':
+					args[3] = Tools.escapeHTML(args[3]);
+					poke.volatiles.typechange[2] = args[3];
+					if (fromeffect.id) {
+						if (fromeffect.id === 'reflecttype') {
+							actions += "" + poke.getName() + "'s type changed to match " + ofpoke.getLowerName() + "'s!";
+						} else if (fromeffect.id === 'forestscurse') {
+							actions += "Grass type was added to " + poke.getLowerName();
+						} else if (fromeffect.id === 'trickortreat') {
+							actions += "Ghost type was added to " + poke.getLowerName();
+						} else {
+							actions += "" + poke.getName() + "'s " + fromeffect.name + " made it the " + args[3] + " type!";
+						}
+					} else {
+						actions += "" + poke.getName() + " transformed into the " + args[3] + " type!";
+					}
+					break;
+				case 'powertrick':
+					self.resultAnim(poke, 'Power Trick', 'neutral', animDelay);
+					actions += "" + poke.getName() + " switched its Attack and Defense!";
+					break;
+				case 'foresight':
+				case 'miracleeye':
+					self.resultAnim(poke, 'Identified', 'bad', animDelay);
+					actions += "" + poke.getName() + " was identified!";
+					break;
+				case 'telekinesis':
+					self.resultAnim(poke, 'Telekinesis', 'neutral', animDelay);
+					actions += "" + poke.getName() + " was hurled into the air!";
+					break;
+				case 'confusion':
+					if (kwargs.already) {
+						actions += "" + poke.getName() + " is already confused!";
+					} else {
+						self.resultAnim(poke, 'Confused', 'bad', animDelay);
+						actions += "" + poke.getName() + " became confused!";
+					}
+					break;
+				case 'leechseed':
+					poke.side.updateStatbar(poke);
+					actions += '' + poke.getName() + ' was seeded!';
+					break;
+				case 'healblock':
+					self.resultAnim(poke, 'Heal Block', 'bad', animDelay);
+					actions += "" + poke.getName() + " was prevented from healing!";
+					break;
+				case 'mudsport':
+					self.resultAnim(poke, 'Mud Sport', 'neutral', animDelay);
+					actions += "Electricity's power was weakened!";
+					break;
+				case 'watersport':
+					self.resultAnim(poke, 'Water Sport', 'neutral', animDelay);
+					actions += "Fire's power was weakened!";
+					break;
+				case 'yawn':
+					self.resultAnim(poke, 'Drowsy', 'slp', animDelay);
+					actions += "" + poke.getName() + ' grew drowsy!';
+					break;
+				case 'flashfire':
+					self.resultAnim(poke, 'Flash Fire', 'good', animDelay);
+					actions += 'The power of ' + poke.getLowerName() + '\'s Fire-type moves rose!';
+					break;
+				case 'taunt':
+					self.resultAnim(poke, 'Taunted', 'bad', animDelay);
+					actions += '' + poke.getName() + ' fell for the taunt!';
+					break;
+				case 'imprison':
+					self.resultAnim(poke, 'Imprisoning', 'good', animDelay);
+					actions += "" + poke.getName() + " sealed the opponent's move(s)!";
+					break;
+				case 'disable':
+					self.resultAnim(poke, 'Disabled', 'bad', animDelay);
+					actions += "" + poke.getName() + "'s " + Tools.escapeHTML(args[3]) + " was disabled!";
+					break;
+				case 'embargo':
+					self.resultAnim(poke, 'Embargo', 'bad', animDelay);
+					actions += "" + poke.getName() + " can't use items anymore!";
+					break;
+				case 'torment':
+					self.resultAnim(poke, 'Tormented', 'bad', animDelay);
+					actions += '' + poke.getName() + ' was subjected to torment!';
+					break;
+				case 'ingrain':
+					self.resultAnim(poke, 'Ingrained', 'good', animDelay);
+					actions += '' + poke.getName() + ' planted its roots!';
+					break;
+				case 'aquaring':
+					self.resultAnim(poke, 'Aqua Ring', 'good', animDelay);
+					actions += '' + poke.getName() + ' surrounded itself with a veil of water!';
+					break;
+				case 'stockpile1':
+					self.resultAnim(poke, 'Stockpile', 'good', animDelay);
+					actions += '' + poke.getName() + ' stockpiled 1!';
+					break;
+				case 'stockpile2':
+					poke.removeVolatile('stockpile1');
+					self.resultAnim(poke, 'Stockpile&times;2', 'good', animDelay);
+					actions += '' + poke.getName() + ' stockpiled 2!';
+					break;
+				case 'stockpile3':
+					poke.removeVolatile('stockpile2');
+					self.resultAnim(poke, 'Stockpile&times;3', 'good', animDelay);
+					actions += '' + poke.getName() + ' stockpiled 3!';
+					break;
+				case 'perish0':
+					poke.removeVolatile('perish1');
+					actions += '' + poke.getName() + "'s perish count fell to 0.";
+					break;
+				case 'perish1':
+					poke.removeVolatile('perish2');
+					self.resultAnim(poke, 'Perish next turn', 'bad', animDelay);
+					actions += '' + poke.getName() + "'s perish count fell to 1.";
+					break;
+				case 'perish2':
+					poke.removeVolatile('perish3');
+					self.resultAnim(poke, 'Perish in 2', 'bad', animDelay);
+					actions += '' + poke.getName() + "'s perish count fell to 2.";
+					break;
+				case 'perish3':
+					self.resultAnim(poke, 'Perish in 3', 'bad', animDelay);
+					actions += '' + poke.getName() + "'s perish count fell to 3.";
+					break;
+				case 'encore':
+					self.resultAnim(poke, 'Encored', 'bad', animDelay);
+					actions += '' + poke.getName() + ' received an encore!';
+					break;
+				case 'bide':
+					self.resultAnim(poke, 'Bide', 'good', animDelay);
+					actions += "" + poke.getName() + " is storing energy!";
+					break;
+				case 'slowstart':
+					self.resultAnim(poke, 'Slow Start', 'bad', animDelay);
+					actions += "" + poke.getName() + " can't get it going because of its Slow Start!";
+					break;
+				case 'attract':
+					self.resultAnim(poke, 'Attracted', 'bad', animDelay);
+					if (fromeffect.id) {
+						actions += "" + poke.getName() + " fell in love from the " + fromeffect.name + "!";
+					} else {
+						actions += "" + poke.getName() + " fell in love!";
+					}
+					break;
+				case 'autotomize':
+					self.resultAnim(poke, 'Lightened', 'good', animDelay);
+					actions += "" + poke.getName() + " became nimble!";
+					break;
+				case 'focusenergy':
+					self.resultAnim(poke, '+Crit rate', 'good', animDelay);
+					actions += "" + poke.getName() + " is getting pumped!";
+					break;
+				case 'curse':
+					self.resultAnim(poke, 'Cursed', 'bad', animDelay);
+					actions += "" + ofpoke.getName() + " cut its own HP and laid a curse on " + poke.getLowerName() + "!";
+					break;
+				case 'nightmare':
+					self.resultAnim(poke, 'Nightmare', 'bad', animDelay);
+					actions += "" + poke.getName() + " began having a nightmare!";
+					break;
+				case 'magnetrise':
+					self.resultAnim(poke, 'Magnet Rise', 'good', animDelay);
+					actions += "" + poke.getName() + " levitated with electromagnetism!";
+					break;
+				case 'smackdown':
+					self.resultAnim(poke, 'Smacked Down', 'bad', animDelay);
+					actions += "" + poke.getName() + " fell straight down!";
+					poke.removeVolatile('magnetrise');
+					poke.removeVolatile('telekinesis');
+					break;
+				case 'substitute':
+					if (kwargs.damage) {
+						self.resultAnim(poke, 'Damage', 'bad', animDelay);
+						actions += "The substitute took damage for "+poke.getLowerName()+"!";
+					} else if (kwargs.block) {
+						self.resultAnim(poke, 'Blocked', 'neutral', animDelay);
+						actions += 'But it failed!';
+					} else if (kwargs.already) {
+						actions += '' + poke.getName() + ' already has a substitute!';
+					} else {
+						poke.sprite.animSub();
+						actions += '' + poke.getName() + ' put in a substitute!';
+					}
+					break;
+				case 'uproar':
+					if (kwargs.upkeep) {
+						actions += "" + poke.getName() + " is making an uproar!";
+					} else {
+						actions += "" + poke.getName() + " caused an uproar!";
+					}
+					break;
+				case 'doomdesire':
+					actions += '' + poke.getName() + ' chose Doom Desire as its destiny!';
+					break;
+				case 'futuresight':
+					actions += '' + poke.getName() + ' foresaw an attack!';
+					break;
+				case 'mimic':
+					actions += '' + poke.getName() + ' learned ' + Tools.escapeHTML(args[3]) + '!';
+					break;
+				case 'followme':
+				case 'ragepowder':
+					actions += '' + poke.getName() + ' became the center of attention!';
+					break;
+				case 'powder':
+					actions += '' + poke.getName() + ' is covered in powder!';
+					break;
+				default:
+					actions += "" + poke.getName() + "'s " + effect.name + " started!";
+				}
+				break;
+			case '-end':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var fromeffect = Tools.getEffect(kwargs.from);
+				poke.removeVolatile(effect.id);
+				switch (effect.id) {
+				case 'powertrick':
+					self.resultAnim(poke, 'Power Trick', 'neutral', animDelay);
+					actions += "" + poke.getName() + " switched its Attack and Defense!";
+					break;
+				case 'telekinesis':
+					self.resultAnim(poke, 'Telekinesis&nbsp;ended', 'neutral', animDelay);
+					actions += "" + poke.getName() + " was freed from the telekinesis!";
+					break;
+				case 'confusion':
+					self.resultAnim(poke, 'Confusion&nbsp;ended', 'good', animDelay);
+					if (!kwargs.silent) {
+						if (poke.side.n === 0) actions += "" + poke.getName() + " snapped out of its confusion.";
+						else actions += "" + poke.getName() + " snapped out of confusion!";
+					}
+					break;
+				case 'leechseed':
+					if (fromeffect.id === 'rapidspin') {
+						self.resultAnim(poke, 'De-seeded', 'good', animDelay);
+						actions += "" + poke.getName() + " was freed from Leech Seed!";
+					}
+					break;
+				case 'healblock':
+					self.resultAnim(poke, 'Heal Block ended', 'good', animDelay);
+					actions += "" + poke.getName() + "'s Heal Block wore off!";
+					break;
+				case 'taunt':
+					self.resultAnim(poke, 'Taunt&nbsp;ended', 'good', animDelay);
+					actions += '' + poke.getName() + "'s taunt wore off!";
+					break;
+				case 'disable':
+					self.resultAnim(poke, 'Disable&nbsp;ended', 'good', animDelay);
+					actions += '' + poke.getName() + " is no longer disabled!";
+					break;
+				case 'embargo':
+					self.resultAnim(poke, 'Embargo ended', 'good', animDelay);
+					actions += "" + poke.getName() + " can use items again!";
+					break;
+				case 'torment':
+					self.resultAnim(poke, 'Torment&nbsp;ended', 'good', animDelay);
+					actions += '' + poke.getName() + "'s torment wore off!";
+					break;
+				case 'encore':
+					self.resultAnim(poke, 'Encore&nbsp;ended', 'good', animDelay);
+					actions += '' + poke.getName() + "'s encore ended!";
+					break;
+				case 'bide':
+					actions += "" + poke.getName() + " unleashed energy!";
+					break;
+				case 'magnetrise':
+					if (poke.side.n === 0) actions += "" + poke.getName() + "'s electromagnetism wore off!";
+					else actions += "The electromagnetism of "+poke.getLowerName()+" wore off!";
+					break;
+				case 'perishsong':
+					poke.removeVolatile('perish3');
+					break;
+				case 'substitute':
+					poke.sprite.animSubFade();
+					self.resultAnim(poke, 'Faded', 'bad', animDelay);
+					actions += '' + poke.getName() + "'s substitute faded!";
+					break;
+				case 'uproar':
+					actions += "" + poke.getName() + " calmed down.";
+					break;
+				case 'stockpile':
+					poke.removeVolatile('stockpile1');
+					poke.removeVolatile('stockpile2');
+					poke.removeVolatile('stockpile3');
+					actions += "" + poke.getName() + "'s stockpiled effect wore off!";
+					break;
+				default:
+					if (effect.effectType === 'Move') {
+						actions += '' + poke.getName() + " took the " + effect.name + " attack!";
+					} else {
+						actions += "" + poke.getName() + "'s " + effect.name + " ended!";
+					}
+				}
+				break;
+			case '-singleturn':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var ofpoke = this.getPokemon(kwargs.of);
+				var fromeffect = Tools.getEffect(kwargs.from);
+				poke.addTurnstatus(effect.id);
+
+				switch (effect.id) {
+				case 'roost':
+					self.resultAnim(poke, 'Landed', 'neutral', animDelay);
+					//actions += '' + poke.getName() + ' landed on the ground!';
+					break;
+				case 'quickguard':
+					self.resultAnim(poke, 'Quick Guard', 'good', animDelay);
+					actions += "Quick Guard protected " + poke.side.getLowerTeamName() + "!";
+					break;
+				case 'wideguard':
+					self.resultAnim(poke, 'Wide Guard', 'good', animDelay);
+					actions += "Wide Guard protected " + poke.side.getLowerTeamName() + "!";
+					break;
+				case 'protect':
+					self.resultAnim(poke, 'Protected', 'good', animDelay);
+					actions += '' + poke.getName() + ' protected itself!';
+					break;
+				case 'endure':
+					self.resultAnim(poke, 'Enduring', 'good', animDelay);
+					actions += '' + poke.getName() + ' braced itself!';
+					break;
+				case 'helpinghand':
+					self.resultAnim(poke, 'Helping Hand', 'good', animDelay);
+					actions += '' + ofpoke.getName() + " is ready to help " + poke.getLowerName() + "!";
+					break;
+				case 'focuspunch':
+					self.resultAnim(poke, 'Focusing', 'neutral', animDelay);
+					actions += '' + poke.getName() + ' is tightening its focus!';
+					break;
+				case 'snatch':
+					actions += '' + poke.getName() + ' waits for a target to make a move!';
+					break;
+				case 'magiccoat':
+					actions += '' + poke.getName() + ' shrouded itself with Magic Coat!';
+					break;
+				case 'matblock':
+					actions += '' + poke.getName() + ' intends to flip up a mat and block incoming attacks!';
+					break;
+				case 'electrify':
+					actions += '' + poke.getName() + '\'s moves have been electrified!';
+					break;
+				}
+				break;
+			case '-singlemove':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var ofpoke = this.getPokemon(kwargs.of);
+				var fromeffect = Tools.getEffect(kwargs.from);
+				poke.addMovestatus(effect.id);
+
+				switch (effect.id) {
+				case 'grudge':
+					actions += '' + poke.getName() + ' wants its target to bear a grudge!';
+					break;
+				case 'destinybond':
+					actions += '' + poke.getName() + ' is trying to take its foe down with it!';
+					break;
+				}
+				break;
+
+			case '-activate':
+				var poke = this.getPokemon(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var ofpoke = this.getPokemon(kwargs.of);
+				switch (effect.id) {
+				case 'confusion':
+					actions += "" + poke.getName() + " is confused!";
+					break;
+				case 'destinybond':
+					actions += '' + poke.getName() + ' took its attacker down with it!';
+					break;
+				case 'snatch':
+					actions += "" + poke.getName() + " snatched " + ofpoke.getLowerName() + "'s move!";
+					break;
+				case 'grudge':
+					actions += "" + poke.getName() + "'s " + Tools.escapeHTML(args[3]) + " lost all its PP due to the grudge!";
+					break;
+				case 'quickguard':
+					poke.addTurnstatus('quickguard');
+					self.resultAnim(poke, 'Quick Guard', 'good', animDelay);
+					actions += "Quick Guard protected " + poke.getLowerName() + "!";
+					break;
+				case 'wideguard':
+					poke.addTurnstatus('wideguard');
+					self.resultAnim(poke, 'Wide Guard', 'good', animDelay);
+					actions += "Wide Guard protected " + poke.getLowerName() + "!";
+					break;
+				case 'protect':
+					poke.addTurnstatus('protect');
+					self.resultAnim(poke, 'Protected', 'good', animDelay);
+					actions += '' + poke.getName() + ' protected itself!';
+					break;
+				case 'substitute':
+					if (kwargs.damage) {
+						self.resultAnim(poke, 'Damage', 'bad', animDelay);
+						actions += 'The substitute took damage for ' + poke.getLowerName() + '!';
+					} else if (kwargs.block) {
+						self.resultAnim(poke, 'Blocked', 'neutral', animDelay);
+						actions += '' + poke.getName() + "'s Substitute blocked " + Tools.getMove(kwargs.block || args[3]).name + '!';
+					}
+					break;
+				case 'attract':
+					actions += '' + poke.getName() + ' is in love with ' + ofpoke.getLowerName() + '!';
+					break;
+				case 'bide':
+					actions += "" + poke.getName() + " is storing energy!";
+					break;
+				case 'mist':
+					actions += "" + poke.getName() + " is protected by the mist!";
+					break;
+				case 'trapped':
+					actions += "" + poke.getName() + " can no longer escape!";
+					break;
+				case 'stickyweb':
+					actions += '' + poke.getName() + ' was caught in a sticky web!';
+					break;
+				case 'happyhour':
+					actions += 'Everyone is caught up in the happy atmosphere!';
+					break;
+				case 'celebrate':
+					actions += 'Congratulations, ' + Tools.escapeHTML(poke.side.name) + '!';
+					break;
+
+				// move activations
+				case 'trick':
+				case 'switcheroo':
+					actions += '' + poke.getName() + ' switched items with its target!';
+					break;
+				case 'brickbreak':
+					actions += poke.getName() + " shattered " + ofpoke.getTeamName() + " protections!";
+					ofpoke.removeSideCondition('Reflect');
+					ofpoke.removeSideCondition('LightScreen');
+					break;
+				case 'pursuit':
+					actions += "" + poke.getName() + " is being sent back!";
+					break;
+				case 'feint':
+					actions += "" + poke.getName() + " fell for the feint!";
+					break;
+				case 'spite':
+					actions += "It reduced the PP of " + poke.getLowerName() + "'s " + Tools.getMove(args[3]).name + " by " + Tools.escapeHTML(args[4]) + "!";
+					break;
+				case 'gravity':
+					actions += "" + poke.getName() + " couldn't stay airborne because of gravity!";
+					poke.removeVolatile('magnetrise');
+					poke.removeVolatile('telekinesis');
+					poke.sprite.anim({time:100});
+					break;
+				case 'magnitude':
+					actions += "Magnitude " + Tools.escapeHTML(args[3]) + "!";
+					break;
+				case 'sketch':
+					actions += "" + poke.getName() + " sketched " + Tools.escapeHTML(args[3]) + "!";
+					break;
+				case 'skillswap':
+					actions += "" + poke.getName() + " swapped Abilities with its target!";
+					if (ofpoke && poke.side !== ofpoke.side) {
+						self.resultAnim(poke, Tools.escapeHTML(args[3]), 'neutral', 1);
+						self.resultAnim(ofpoke, Tools.escapeHTML(args[4]), 'neutral', 4);
+						actions += "<br />" + poke.getName() + " acquired " + Tools.escapeHTML(args[3]) + "!";
+						actions += "<br />" + ofpoke.getName() + " acquired " + Tools.escapeHTML(args[4]) + "!";
+					}
+					break;
+				case 'charge':
+					actions += "" + poke.getName() + " began charging power!";
+					break;
+				case 'struggle':
+					actions += "" + poke.getName() + " has no moves left!";
+					break;
+				case 'bind':
+					actions += '' + poke.getName() + ' was squeezed by ' + ofpoke.getLowerName() + '!';
+					break;
+				case 'wrap':
+					actions += '' + poke.getName() + ' was wrapped by ' + ofpoke.getLowerName() + '!';
+					break;
+				case 'clamp':
+					actions += '' + ofpoke.getName() + ' clamped ' + poke.getLowerName() + '!';
+					break;
+				case 'whirlpool':
+					actions += '' + poke.getName() + ' became trapped in the vortex!';
+					break;
+				case 'firespin':
+					actions += '' + poke.getName() + ' became trapped in the fiery vortex!';
+					break;
+				case 'magmastorm':
+					actions += '' + poke.getName() + ' became trapped by swirling magma!';
+					break;
+				case 'sandtomb':
+					actions += '' + poke.getName() + ' became trapped by Sand Tomb!';
+					break;
+				case 'infestation':
+					actions += '' + poke.getName() + ' has been afflicted with an infestation by ' + ofpoke.getLowerName() + '!';
+					break;
+				case 'afteryou':
+					actions += '' + poke.getName() + ' took the kind offer!';
+					break;
+				case 'quash':
+					actions += "" + poke.getName() + "'s move was postponed!";
+					break;
+				case 'powersplit':
+					actions += '' + poke.getName() + ' shared its power with the target!';
+					break;
+				case 'guardsplit':
+					actions += '' + poke.getName() + ' shared its guard with the target!';
+					break;
+				case 'ingrain':
+					actions += '' + poke.getName() + ' anchored itself with its roots!';
+					break;
+				case 'matblock':
+					actions += '' + Tools.escapeHTML(args[3]) + ' was blocked by the kicked-up mat!';
+					break;
+				case 'powder':
+					actions += 'When the flame touched the powder on the Pokémon, it exploded!';
+					break;
+
+				// ability activations
+				case 'sturdy':
+					actions += '' + poke.getName() + ' held on thanks to Sturdy!';
+					break;
+				case 'magicbounce':
+				case 'magiccoat':
+				case 'rebound':
+					break;
+				case 'wonderguard':
+					self.resultAnim(poke, 'Immune', 'neutral', animDelay);
+					actions += '' + poke.getName() + '\'s Wonder Guard evades the attack!';
+					break;
+				case 'speedboost':
+					actions += "" + poke.getName() + "'s' Speed Boost increases its speed!";
+					break;
+				case 'forewarn':
+					actions += "" + poke.getName() + "'s Forewarn alerted it to " + Tools.escapeHTML(args[3]) + "!";
+					break;
+				case 'anticipation':
+					actions += "" + poke.getName() + " shuddered!";
+					break;
+				case 'telepathy':
+					actions += "" + poke.getName() + " avoids attacks by its ally Pok&#xE9;mon!";
+					break;
+				case 'suctioncups':
+					actions += '' + poke.getName() + ' anchors itself!';
+					break;
+
+				// item activations
+				case 'custapberry':
+				case 'quickclaw':
+					//actions += ''+poke.getName()+' is already preparing its next move!';
+					actions += '' + poke.getName() + '\'s ' + effect.name + ' let it move first!';
+					break;
+				case 'leppaberry':
+					actions += '' + poke.getName() + " restored " + Tools.escapeHTML(args[3]) + "'s PP using its Leppa Berry!";
+					break;
+				default:
+					actions += "" + poke.getName() + "'s " + effect.name + " activated!";
+				}
+				break;
+
+			case '-sidestart':
+				var side = this.getSide(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				side.addSideCondition(effect.name);
+
+				switch (effect.id) {
+				case 'stealthrock':
+					actions += "Pointed stones float in the air around " + side.getLowerTeamName() + "!";
+					break;
+				case 'spikes':
+					actions += "Spikes were scattered all around the feet of " + side.getLowerTeamName() + "!";
+					break;
+				case 'toxicspikes':
+					actions += "Poison spikes were scattered all around the feet of " + side.getLowerTeamName() + "!";
+					break;
+				case 'stickyweb':
+					actions += "A sticky web spreads out beneath " + side.getLowerTeamName() + "'s feet!";
+					break;
+				case 'tailwind':
+					actions += "The tailwind blew from behind " + side.getLowerTeamName() + "!";
+					break;
+				case 'reflect':
+					actions += "Reflect raised " + side.getLowerTeamName() + "'s Defense!";
+					break;
+				case 'lightscreen':
+					actions += "Light Screen raised " + side.getLowerTeamName() + "'s Special Defense!";
+					break;
+				case 'safeguard':
+					actions += "" + side.getTeamName() + " became cloaked in a mystical veil!";
+					break;
+				case 'mist':
+					actions += "" + side.getTeamName() + " became shrouded in mist!";
+					break;
+				case 'luckychant':
+					actions += 'The Lucky Chant shielded ' + side.getLowerTeamName() + ' from critical hits!';
+					break;
+				case 'firepledge':
+					actions += "A rainbow appeared in the sky on " + side.getLowerTeamName() + "'s side!";
+					break;
+				case 'waterpledge':
+					actions += "A swamp enveloped " + side.getLowerTeamName() + "!";
+					break;
+				case 'grasspledge':
+					actions += "A sea of fire enveloped " + side.getLowerTeamName() + "!";
+					break;
+				default:
+					actions += "" + effect.name + " started!";
+					break;
+				}
+				break;
+			case '-sideend':
+				var side = this.getSide(args[1]);
+				var effect = Tools.getEffect(args[2]);
+				var from = Tools.getEffect(kwargs.from);
+				var ofpoke = this.getPokemon(kwargs.of);
+				side.removeSideCondition(effect.name);
+
+				switch (effect.id) {
+				case 'stealthrock':
+					actions += "The pointed stones disappeared from around " + side.getLowerTeamName() + "!";
+					break;
+				case 'spikes':
+					actions += "The spikes disappeared from around " + side.getLowerTeamName() + "'s feet!";
+					break;
+				case 'toxicspikes':
+					actions += "The poison spikes disappeared from around " + side.getLowerTeamName() + "'s feet!";
+					break;
+				case 'stickyweb':
+					actions += "The sticky web has disappeared from beneath " + side.getLowerTeamName() + "'s feet!";
+					break;
+				case 'tailwind':
+					actions += "" + side.getTeamName() + "'s tailwind petered out!";
+					break;
+				case 'reflect':
+					actions += "" + side.getTeamName() + "'s Reflect wore off!";
+					break;
+				case 'lightscreen':
+					actions += "" + side.getTeamName() + "'s Light Screen wore off!";
+					break;
+				case 'safeguard':
+					actions += "" + side.getTeamName() + " is no longer protected by Safeguard!";
+					break;
+				case 'mist':
+					actions += "" + side.getTeamName() + " is no longer protected by mist!";
+					break;
+				case 'luckychant':
+					actions += "" + side.getTeamName() + "'s Lucky Chant wore off!";
+					break;
+				case 'firepledge':
+					actions += "The rainbow on " + side.getLowerTeamName() + "'s side disappeared!";
+					break;
+				case 'waterpledge':
+					actions += "The swamp around " + side.getLowerTeamName() + " disappeared!";
+					break;
+				case 'grasspledge':
+					actions += "The sea of fire around " + side.getLowerTeamName() + " disappeared!";
+					break;
+				default:
+					actions += "" + effect.name + " ended!";
+					break;
+				}
+				break;
+
+			case '-weather':
+				var effect = Tools.getEffect(args[1]);
+				var poke = this.getPokemon(kwargs.of);
+				self.changeWeather(effect.name, poke, kwargs.upkeep);
+				break;
+
+			case '-fieldstart':
+				var effect = Tools.getEffect(args[1]);
+				var poke = this.getPokemon(kwargs.of);
+				self.addPseudoWeather(effect.name, poke);
+
+				switch (effect.id) {
+				case 'trickroom':
+					actions += "" + poke.getName() + ' twisted the dimensions!';
+					break;
+				case 'wonderroom':
+					actions += "It created a bizarre area in which the Defense and Sp. Def stats are swapped!";
+					break;
+				case 'magicroom':
+					actions += "It created a bizarre area in which Pok&#xE9;mon's held items lose their effects!";
+					break;
+				case 'gravity':
+					actions += "Gravity intensified!";
+					break;
+				default:
+					actions += effect.name+" started!";
+					break;
+				}
+				break;
+
+			case '-fieldend':
+				var effect = Tools.getEffect(args[1]);
+				var poke = this.getPokemon(kwargs.of);
+				self.removePseudoWeather(effect.name, poke);
+
+				switch (effect.id) {
+				case 'trickroom':
+					actions += 'The twisted dimensions returned to normal!';
+					break;
+				case 'wonderroom':
+					actions += 'Wonder Room wore off, and the Defense and Sp. Def stats returned to normal!';
+					break;
+				case 'magicroom':
+					actions += "Magic Room wore off, and the held items' effects returned to normal!";
+					break;
+				case 'gravity':
+					actions += 'Gravity returned to normal!';
+					break;
+				default:
+					actions += effect.name+" ended!";
+					break;
+				}
+				break;
+
+			case '-fieldactivate':
+				var effect = Tools.getEffect(args[1]);
+				switch (effect.id) {
+				case 'perishsong':
+					actions += 'All Pok&#xE9;mon hearing the song will faint in three turns!';
+					if (self.mySide.active[0] && !self.mySide.active[0].volatiles['perish0']
+					&& !self.mySide.active[0].volatiles['perish1'] && !self.mySide.active[0].volatiles['perish2']) {
+						self.mySide.active[0].addVolatile('perish3');
+					}
+					if (self.yourSide.active[0] && !self.yourSide.active[0].volatiles['perish0']
+					 && !self.yourSide.active[0].volatiles['perish1'] && !self.yourSide.active[0].volatiles['perish2']) {
+						self.yourSide.active[0].addVolatile('perish3');
+					}
+					self.mySide.updateStatbar();
+					self.yourSide.updateStatbar();
+					break;
+				case 'payday':
+					actions += 'Coins were scattered everywhere!';
+					break;
+				case 'iondeluge':
+					actions += 'A deluge of ions showers the battlefield!';
+					break;
+				default:
+					actions += ''+effect.name+' hit!';
+					break;
+				}
+				break;
+
+			case '-message':
+				actions += Tools.escapeHTML(args[1]);
+				break;
+
+			case '-anim':
+				var poke = self.getPokemon(args[1]);
+				var move = Tools.getMove(args[2]);
+				if (self.checkActive(poke)) return;
+				poke2 = self.getPokemon(args[3]);
+				poke.sprite.beforeMove();
+				kwargs.silent = true;
+				self.useMove(poke, move, poke2, kwargs);
+				poke.sprite.afterMove();
+				break;
+
+			case '-hint':
+				hiddenactions += '('+Tools.escapeHTML(args[1])+')';
+				break;
+
+			default:
+				self.logConsole('Unknown minor: ' + args[0]);
+				if (self.errorCallback) self.errorCallback(self);
+				break;
+			}
+		}
+		if (actions) {
+			self.message('<small>' + actions + '</small>', hiddenactions ? '<small>' + hiddenactions + '</small>' : '');
+		} else if (hiddenactions) {
+			self.message('', '<small>' + hiddenactions + '</small>');
+		}
+	}
+
+	/* this.parseSpriteData = function (name) {
+		var siden = 0,
+			foe = false;
+		while (true) {
+			if (name.substr(0, 6) === 'foeof-') {
+				foe = true;
+				name = name.substr(6);
+			} else if (name.substr(0, 9) === 'switched-') name = name.substr(9);
+			else if (name.substr(0, 9) === 'existing-') name = name.substr(9);
+			else if (name.substr(0, 4) === 'foe-') {
+				siden = self.p2.n;
+				name = name.substr(4);
+			} else if (name.substr(0, 5) === 'ally-') {
+				siden = self.p1.n;
+				name = name.substr(5);
+			} else break;
+		}
+		if (name.substr(name.length - 1) === ')') {
+			var parenIndex = name.lastIndexOf('(');
+			if (parenIndex > 0) {
+				var species = name.substr(parenIndex + 1);
+				name = species.substr(0, species.length - 1);
+			}
+		}
+		if (foe) siden = (siden ? 0 : 1);
+
+		var data = Tools.getTemplate(name);
+		return data.spriteData[siden];
+	} */
+	this.parseDetails = function (name, pokemonid, details, output) {
+		if (!output) output = {};
+		if (!details) details = "";
+		output.details = details;
+		output.name = name;
+		output.species = name;
+		output.level = 100;
+		output.shiny = false;
+		output.gender = '';
+		output.ident = (name?pokemonid:'');
+		output.searchid = (name?(pokemonid + '|' + details):'');
+		var splitDetails = details.split(', ');
+		if (splitDetails[splitDetails.length-1] === 'shiny')
+		{
+			output.shiny = true;
+			splitDetails.pop();
+		}
+		if (splitDetails[splitDetails.length-1] === 'M' || splitDetails[splitDetails.length-1] === 'F')
+		{
+			output.gender = splitDetails[splitDetails.length-1];
+			splitDetails.pop();
+		}
+		if (splitDetails[1])
+		{
+			output.level = parseInt(splitDetails[1].substr(1)) || 100;
+		}
+		if (splitDetails[0])
+		{
+			output.species = splitDetails[0];
+		}
+		return output;
+	};
+	this.getPokemon = function (pokemonid, details) {
+		var siden = -1;
+		var name = pokemonid;
+		var isNew = false; // if yes, don't match any pokemon that already exists (for Team Preview)
+		var isOld = false; // if yes, match only pokemon that have been revealed, and can match fainted pokemon (now default)
+		var isOther = false; // if yes, don't match an active pokemon (for switching)
+		//var position = 0; // todo: use for position in doubles/triples
+		var getfoe = false;
+		var slot; // if there is an explicit slot for this pokemon
+		var slotChart = {a:0,b:1,c:2,d:3,e:4,f:5};
+		if (typeof pokemonid === 'undefined' || name === '??') return null;
+		if (name.substr(0, 5) === 'foe: ') {
+			name = name.substr(5);
+			pokemonid = name;
+			getfoe = true;
+		}
+		if (name.substr(0, 5) === 'new: ') {
+			name = name.substr(5);
+			pokemonid = name;
+			isNew = true;
+			isOther = true;
+		}
+		if (name.substr(0, 7) === 'other: ') {
+			name = name.substr(7);
+			pokemonid = name;
+			isOther = true;
+		}
+		if (name.substr(0, 5) === 'old: ') {
+			name = name.substr(5);
+			pokemonid = name;
+			isOld = true;
+		}
+		if (name.substr(0, 4) === 'p2: ' || name === 'p2') {
+			siden = self.p2.n;
+			name = name.substr(4);
+			species = name;
+		} else if (name.substr(0, 4) === 'p1: ' || name === 'p1') {
+			siden = self.p1.n;
+			name = name.substr(4);
+			species = name;
+		} else if (name.substr(0, 2) === 'p2' && name.substr(3, 2) === ': ') {
+			slot = slotChart[name.substr(2,1)];
+			siden = self.p2.n;
+			name = name.substr(5);
+			pokemonid = 'p2: '+name;
+			species = name;
+		} else if (name.substr(0, 2) === 'p1' && name.substr(3, 2) === ': ') {
+			slot = slotChart[name.substr(2,1)];
+			siden = self.p1.n;
+			name = name.substr(5);
+			pokemonid = 'p1: '+name;
+			species = name;
+		}
+
+		if (!slot) slot = 0;
+
+		if (!details) {
+			if (siden < 0) return null;
+			if (self.sides[siden].active[slot]) return self.sides[siden].active[slot];
+		}
+
+		var species = name;
+		var gender = '';
+		var level = 100;
+		var shiny = false;
+		var searchid = '';
+		if (details) searchid = pokemonid+'|'+details;
+
+		var bestMatchName = null;
+		if (siden !== self.p2.n && !isNew) {
+			if (self.p1.active[slot] && self.p1.active[slot].searchid === searchid && !isOther) {
+				self.p1.active[slot].slot = slot;
+				return self.p1.active[slot];
+			}
+			for (var i = 0; i < self.p1.pokemon.length; i++) {
+				var pokemon = self.p1.pokemon[i];
+				if (pokemon.fainted && (isNew || isOther)) continue;
+				if (isOther) {
+					if (self.p1.active.indexOf(pokemon) >= 0) continue;
+					if (pokemon == self.p1.lastPokemon && !self.p1.active[slot]) continue;
+				}
+				if (pokemon.searchid === searchid || (!pokemon.searchid && pokemon.checkDetails(details)) || (!searchid && pokemon.ident === pokemonid)) {
+					if (!pokemon.searchid)
+					{
+						pokemon.name = name;
+						pokemon.searchid = searchid;
+						pokemon.ident = pokemonid;
+						if (pokemon.needsReplace) {
+							pokemon = self.p1.newPokemon(self.parseDetails(name, pokemonid, details), i);
+						}
+					}
+					pokemon.slot = slot;
+					return pokemon;
+				}
+			}
+		}
+		if (siden !== self.p1.n && !isNew) {
+			if (self.p2.active[slot] && self.p2.active[slot].searchid === searchid && !isOther) {
+				self.p2.active[slot].slot = slot;
+				return self.p2.active[slot];
+			}
+			for (var i = 0; i < self.p2.pokemon.length; i++) {
+				var pokemon = self.p2.pokemon[i];
+				if (pokemon.fainted && (isNew || isOther)) continue;
+				if (isOther) {
+					if (self.p2.active.indexOf(pokemon) >= 0) continue;
+					if (pokemon == self.p2.lastPokemon && !self.p2.active[slot]) continue;
+				}
+				if (pokemon.searchid === searchid || (!pokemon.searchid && pokemon.checkDetails(details)) || (!searchid && pokemon.ident === pokemonid)) {
+					if (!pokemon.searchid)
+					{
+						pokemon.name = name;
+						pokemon.searchid = searchid;
+						pokemon.ident = pokemonid;
+						if (pokemon.needsReplace) {
+							pokemon = self.p2.newPokemon(self.parseDetails(name, pokemonid, details), i);
+						}
+					}
+					pokemon.slot = slot;
+					return pokemon;
+				}
+			}
+		}
+		if (!isNew && !isOther && !details) {
+			return false;
+		}
+		if (siden < 0) siden = self.p1.n;
+		if (details) {
+			var splitDetails = details.split(', ');
+			if (splitDetails[splitDetails.length-1] === 'shiny') {
+				shiny = true;
+				splitDetails.pop();
+			}
+			if (splitDetails[splitDetails.length-1] === 'M' || splitDetails[splitDetails.length-1] === 'F') {
+				gender = splitDetails[splitDetails.length-1];
+				splitDetails.pop();
+			}
+			if (splitDetails[1]) {
+				level = parseInt(splitDetails[1].substr(1)) || 100;
+			}
+			if (splitDetails[0]) {
+				species = splitDetails[0];
+			}
+		}
+		var pokemon = self.sides[siden].newPokemon({
+			species: species,
+			details: details,
+			name: name,
+			ident: (name?pokemonid:''),
+			searchid: (name?(pokemonid + '|' + details):''),
+			level: level,
+			gender: gender,
+			shiny: shiny,
+			slot: slot
+		});
+		return pokemon;
+	}
+	this.getSide = function (sidename) {
+		if (sidename === 'p1' || sidename.substr(0,3)==='p1:') return self.p1;
+		if (sidename === 'p2' || sidename.substr(0,3)==='p2:') return self.p2;
+		if (self.mySide.id == sidename) return self.mySide;
+		if (self.yourSide.id == sidename) return self.yourSide;
+		if (self.mySide.name == sidename) return self.mySide;
+		if (self.yourSide.name == sidename) return self.yourSide;
+		return {
+			name: sidename,
+			id: sidename.replace(/ /g, '')
+		};
+	}
+
+	this.add = function (command, fastForward) {
+		if (self.playbackState === 0) {
+			self.playbackState = 1;
+			self.activityQueue.push(command);
+		} else if (self.playbackState === 4) {
+			self.playbackState = 2;
+			self.paused = false;
+			self.activityQueue.push(command);
+			self.activityQueueActive = true;
+			self.soundStart();
+			if (fastForward) {
+				self.fastForwardTo(-1);
+			} else {
+				self.nextActivity();
+			}
+		} else {
+			self.activityQueue.push(command);
+		}
+	}
+	this.instantAdd = function (command) {
+		self.run(command, true);
+		self.preemptActivityQueue.push(command);
+		self.add(command);
+	}
+	this.teamPreview = function (start) {
+		for (var k = 0; k < 2; k++) {
+			var teamText = '';
+			var text = '';
+			self.spriteElems[k].empty();
+			if (!start) {
+				self.sides[k].updateSprites();
+				continue;
+			}
+			for (var i = 0; i < self.sides[k].pokemon.length; i++) {
+				var pokemon = self.sides[k].pokemon[i];
+
+				var spriteData = Tools.getSpriteData(pokemon, k, {afd: self.tier === "[Seasonal] Fools Festival"});
+				var y = 0;
+				var x = 0;
+				if (k) {
+					y = Math.floor(96-spriteData.h)/2 + 50 + 3 * (i + 6 - self.sides[k].pokemon.length);
+					x = Math.floor(96-spriteData.w)/2 + 180 + 50 * (i + 6 - self.sides[k].pokemon.length);
+				} else {
+					y = Math.floor(96-spriteData.h)/2 + 200 + 3 * i;
+					x = Math.floor(96-spriteData.w)/2 + 100 + 50 * i;
+				}
+				if (teamText) teamText += ' / ';
+				teamText += pokemon.species;
+				text += '<img src="' + spriteData.url + '" width="'+spriteData.w+'" height="'+spriteData.h+'" style="position:absolute;top:' + y + 'px;left:' + x + 'px" />';
+			}
+			self.sides[k].totalPokemon = i;
+			self.sides[k].updateSidebar();
+			if (teamText) {
+				self.log('<div class="chat"><strong>' + Tools.escapeHTML(self.sides[k].name) + '\'s team:</strong> <em style="color:#445566;display:block;">' + Tools.escapeHTML(teamText) + '</em></div>');
+			}
+			self.spriteElems[k].html(text);
+		}
+	};
+	this.runMajor = function(args, kwargs, preempt) {
+		switch (args[0]) {
+		case 'start':
+			self.teamPreview(false);
+			self.mySide.active[0] = null;
+			self.yourSide.active[0] = null;
+			if (self.waitForResult()) return;
+			self.start();
+			break;
+		case 'turn':
+			if (self.endPrevAction()) return;
+			self.setTurn(args[1]);
+			break;
+		case 'tier':
+			if (!args[1]) args[1] = '';
+			for (var i in kwargs) args[1] += '['+i+'] '+kwargs[i];
+			self.log('<div style="padding:5px 0"><small>Format:</small> <br /><strong>' + Tools.escapeHTML(args[1]) + '</strong></div>');
+			self.tier = args[1];
+			break;
+		case 'gametype':
+			self.gameType = args[1];
+			if (args[1] === 'doubles') {
+				if (self.mySide.active.length < 2) self.mySide.active.push(null);
+				if (self.yourSide.active.length < 2) self.yourSide.active.push(null);
+			}
+			if (args[1] === 'triples' || args[1] === 'rotation') {
+				if (self.mySide.active.length < 3) self.mySide.active.push(null);
+				if (self.yourSide.active.length < 3) self.yourSide.active.push(null);
+			}
+			break;
+		case 'variation':
+			self.log('<div><small>Variation: <em>' + Tools.escapeHTML(args[1]) + '</em></small></div>');
+			break;
+		case 'rule':
+			var ruleArgs = args[1].split(': ');
+			self.log('<div><small><em>' + Tools.escapeHTML(ruleArgs[0]) + (ruleArgs[1]?':':'') + '</em> ' + Tools.escapeHTML(ruleArgs[1]||'') + '</div>');
+			break;
+		case 'rated':
+			self.rated = true;
+			self.log('<div class="rated"><strong>Rated battle</strong></div>');
+			break;
+		case 'chat':
+		case 'c':
+			name = args[1];
+			if (self.ignoreSpects && !self.getSide(name).battle) break;
+			args.shift();
+			args.shift();
+			var message = args.join('|');
+			if (message.substr(0,2) === '//') {
+				self.log('<div class="chat"><strong style="' + hashColor(toUserid(name)) + '">' + Tools.escapeHTML(name) + ':</strong> <em>' + Tools.parseMessage(message.substr(1), name) + '</em></div>', preempt);
+			} else if (message.substr(0,4).toLowerCase() === '/me ') {
+				self.log('<div class="chat"><strong style="' + hashColor(toUserid(name)) + '">&bull;</strong> <em>' + Tools.escapeHTML(name) + ' <i>' + Tools.parseMessage(message.substr(4), name) + '</i></em></div>', preempt);
+			} else if (message.substr(0,14).toLowerCase() === '/data-pokemon ') {
+				if (window.Chart) self.log('<div class="chat"><ul class=\"utilichart\">'+Chart.pokemonRow(Tools.getTemplate(message.substr(14)),'',{})+'<li style=\"clear:both\"></li></ul></div>', preempt);
+			} else if (message.substr(0,11).toLowerCase() === '/data-item ') {
+				if (window.Chart) self.log('<div class="chat"><ul class=\"utilichart\">'+Chart.itemRow(Tools.getItem(message.substr(11)),'',{})+'<li style=\"clear:both\"></li></ul></div>', preempt);
+			} else if (message.substr(0,14).toLowerCase() === '/data-ability ') {
+				if (window.Chart) self.log('<div class="chat"><ul class=\"utilichart\">'+Chart.abilityRow(Tools.getAbility(message.substr(14)),'',{})+'<li style=\"clear:both\"></li></ul></div>', preempt);
+			} else if (message.substr(0,11).toLowerCase() === '/data-move ') {
+				if (window.Chart) self.log('<div class="chat"><ul class=\"utilichart\">'+Chart.moveRow(Tools.getMove(message.substr(11)),'',{})+'<li style=\"clear:both\"></li></ul></div>', preempt);
+			} else {
+				self.log('<div class="chat"><strong style="' + hashColor(toUserid(name)) + '" class="username" data-name="'+Tools.escapeHTML(name)+'">' + Tools.escapeHTML(name) + ':</strong> <em>' + Tools.parseMessage(message, name) + '</em></div>', preempt);
+			}
+			break;
+		case 'chatmsg':
+			args.shift();
+			list = args.join('|');
+			self.log('<div class="chat">' + Tools.escapeHTML(list) + '</div>', preempt);
+			break;
+		case 'chatmsg-raw':
+		case 'raw':
+		case 'html':
+			args.shift();
+			list = args.join('|');
+			self.log('<div class="chat">' + Tools.sanitizeHTML(list) + '</div>', preempt);
+			break;
+		case 'pm':
+			self.log('<div class="chat"><strong>' + Tools.escapeHTML(args[1]) + ':</strong> <span class="message-pm"><i style="cursor:pointer" onclick="selectTab(\'lobby\');rooms.lobby.popupOpen(\'' + Tools.escapeHTML(args[2], true) + '\')">(Private to ' + Tools.escapeHTML(args[3]) + ')</i> ' + Tools.parseMessage(args[4], args[1]) + '</span>');
+			break;
+		case 'askreg':
+			self.log('<div class="broadcast-blue"><b>Register an account to protect your ladder rating!</b><br /><button name="register" value="'+Tools.escapeHTML(args[1])+'"><b>Register</b></button></div>');
+			break;
+		case 'inactive':
+			self.kickingInactive = true;
+			args.shift();
+			list = args.join('|');
+			self.log('<div class="chat timer">' + Tools.escapeHTML(list) + '</div>', preempt);
+			break;
+		case 'inactiveoff':
+			self.kickingInactive = false;
+			args.shift();
+			list = args.join('|');
+			self.log('<div class="chat timer">' + Tools.escapeHTML(list) + '</div>', preempt);
+			break;
+		case 'join':
+		case 'j':
+		case 'J':
+			self.log('<div class="chat"><small>' + Tools.escapeHTML(args[1]) + ' joined.</small></div>', preempt);
+			break;
+		case 'leave':
+		case 'l':
+		case 'L':
+			self.log('<div class="chat"><small>' + Tools.escapeHTML(args[1]) + ' left.</small></div>', preempt);
+			break;
+		case 'spectator':
+		case 'spectatorleave':
+			break;
+		case 'player':
+			self.getSide(args[1]).setName(args[2]);
+			self.getSide(args[1]).setSprite(args[3]);
+			break;
+		case 'win':
+			self.winner(args[1]);
+			break;
+		case 'tie':
+			self.winner();
+			break;
+		case 'prematureend':
+			self.prematureEnd();
+			break;
+		case 'clearpoke':
+			self.p1.pokemon = [];
+			self.p2.pokemon = [];
+			for (var i=0; i<self.p1.active.length; i++) {
+				self.p1.active[i] = null;
+				self.p2.active[i] = null;
+			}
+			break;
+		case 'poke':
+			self.getPokemon('new: '+args[1], args[2]);
+			break;
+		case 'teampreview':
+			self.teamPreview(true);
+			self.teamPreviewCount = args[1];
+			break;
+		case 'switch':
+		case 'drag':
+		case 'replace':
+			self.endLastTurn();
+			if (self.waitForResult()) return;
+			var poke = self.getPokemon('other: '+args[1], args[2]);
+			var slot = poke.slot;
+			poke.healthParse(args[3]);
+			if (args[0] === 'switch') {
+				if (poke.side.active[slot])
+				{
+					poke.side.switchOut(poke.side.active[slot]);
+					if (self.waitForResult()) return;
+				}
+				poke.side.switchIn(poke);
+			} else if (args[0] === 'replace') {
+				poke.side.replace(poke);
+			} else {
+				poke.side.dragIn(poke);
+			}
+			break;
+		case 'faint':
+			if (self.waitForResult()) return;
+			var poke = self.getPokemon(args[1]);
+			poke.side.faint(poke);
+			break;
+		case 'move':
+			self.endLastTurn();
+			if (!kwargs.from && self.waitForResult()) return;
+			var poke = self.getPokemon(args[1]);
+			var move = Tools.getMove(args[2]);
+			if (self.checkActive(poke)) return;
+			poke2 = self.getPokemon(args[3]);
+			poke.sprite.beforeMove();
+			self.useMove(poke, move, poke2, kwargs);
+			poke.sprite.afterMove();
+			break;
+		case 'cant':
+			self.endLastTurn();
+			if (self.waitForResult()) return;
+			var poke = self.getPokemon(args[1]);
+			var effect = Tools.getEffect(args[2]);
+			var move = Tools.getMove(args[3]);
+			self.cantUseMove(poke, effect, move, kwargs);
+			break;
+		case 'message':
+			self.message(Tools.escapeHTML(args[1]));
+			break;
+		case 'done':
+		case '':
+			if (self.done || self.endPrevAction()) return;
+			break;
+		case 'error':
+			args.shift();
+			self.message('<strong>Error:</strong> ' + Tools.escapeHTML(args.join('|')));
+			self.message('Bug? Report it to <a href="http://www.smogon.com/forums/showthread.php?t=3453192">the replay viewer\'s Smogon thread</a>');
+			break;
+		case 'warning':
+			args.shift();
+			self.message('<strong>Warning:</strong> ' + Tools.escapeHTML(args.join('|')));
+			self.message('Bug? Report it to <a href="http://www.smogon.com/forums/showthread.php?t=3453192">the replay viewer\'s Smogon thread</a>');
+			self.activityWait(1000);
+			break;
+		case 'gen':
+			self.gen = parseInt(args[1]);
+			self.updateGen();
+			break;
+		case 'callback':
+			args.shift();
+			if (self.customCallback) self.customCallback(self, args[0], args, kwargs);
+			break;
+		case 'debug':
+			args.shift();
+			name = args.join(' ');
+			self.log('<div class="chat"><small style="color:#999">[DEBUG] ' + Tools.escapeHTML(name) + '.</small></div>', preempt);
+			break;
+		case 'unlink':
+			break;
+		default:
+			self.logConsole('unknown command: ' + args[0]);
+			self.log('<div>Unknown command: ' + Tools.escapeHTML(args[0]) + '</div>');
+			if (self.errorCallback) self.errorCallback(self);
+			break;
+		}
+	};
+	this.run = function (str, preempt) {
+		if (self.preemptActivityQueue.length && str === self.preemptActivityQueue[0]) {
+			self.preemptActivityQueue.shift();
+			self.preemptCatchup();
+			return;
+		}
+		str = $.trim(str);
+		if (!str) return;
+		if (str.charAt(0) !== '|' || str.substr(0,2) === '||') {
+			if (str.charAt(0) === '|') str = str.substr(2);
+			self.log('<div class="chat">' + Tools.escapeHTML(str) + '</div>', preempt);
+		} else {
+			var args = ['done'], kwargs = {};
+			str = $.trim(str.substr(1));
+			if (str !== '') {
+				args = str.split('|');
+				for (var i=0,len=args.length; i<len; i++) args[i] = $.trim(args[i]);
+			}
+			while (args[args.length-1] && args[args.length-1].substr(0,1) === '[') {
+				var bracketPos = args[args.length-1].indexOf(']');
+				if (bracketPos <= 0) break;
+				var argstr = args.pop();
+				// default to '.' so it evaluates to boolean true
+				kwargs[argstr.substr(1,bracketPos-1)] = ($.trim(argstr.substr(bracketPos+1)) || '.');
+			}
+
+			// parse the next line if it's a minor: runMinor needs it parsed to determine when to merge minors
+			var nextLine = '', nextArgs = [''], nextKwargs = {};
+			nextLine = self.activityQueue[self.activityStep+1];
+			if (nextLine && nextLine.substr(0,2) === '|-') {
+				nextLine = $.trim(nextLine.substr(1));
+				nextArgs = nextLine.split('|');
+				while (nextArgs[nextArgs.length-1] && nextArgs[nextArgs.length-1].substr(0,1) === '[') {
+					var bracketPos = nextArgs[nextArgs.length-1].indexOf(']');
+					if (bracketPos <= 0) break;
+					var argstr = nextArgs.pop();
+					// default to '.' so it evaluates to boolean true
+					nextKwargs[argstr.substr(1,bracketPos-1)] = ($.trim(argstr.substr(bracketPos+1)) || '.');
+				}
+			}
+
+			if (self.debug) {
+				if (args[0].substr(0,1) === '-') {
+					self.runMinor(args, kwargs, preempt, nextArgs, nextKwargs);
+				} else {
+					self.runMajor(args, kwargs, preempt);
+				}
+			} else try {
+				if (args[0].substr(0,1) === '-') {
+					self.runMinor(args, kwargs, preempt, nextArgs, nextKwargs);
+				} else {
+					self.runMajor(args, kwargs, preempt);
+				}
+			} catch (e) {
+				self.log('<div class="chat">Error parsing: ' + Tools.escapeHTML(str) + '</div>', preempt);
+				if (e.stack) {
+					var stack = ''+e.stack;
+					stack = stack.split("\n").slice(0,2).join("\n");
+					self.log('<div class="chat" style="white-space:pre-wrap">' + Tools.escapeHTML(stack) + '</div>', preempt);
+				} else {
+					self.log('<div class="chat">Error: ' + Tools.escapeHTML(''+e) + '</div>', preempt);
+				}
+				if (self.errorCallback) self.errorCallback(self);
+			}
+		}
+	}
+	this.endPrevAction = function () {
+		if (self.minorQueue.length) {
+			self.runMinor();
+			self.activityStep--;
+			return true;
+		}
+		if (self.resultWaiting || self.messageActive) {
+			self.endAction();
+			self.activityStep--;
+			self.resultWaiting = false;
+			self.multiHitMove = null;
+			return true;
+		}
+		return false;
+	}
+	this.checkActive = function (poke) {
+		if (!poke.side.active[poke.slot]) {
+			// SOMEONE jumped in in the middle of a replay. <_<
+			poke.side.replace(poke);
+		}
+		return false;
+	}
+	this.waitForResult = function () {
+		if (self.endPrevAction()) return true;
+		self.resultWaiting = true;
+		return false;
+	}
+	this.doBeforeThis = function (act) {
+		if (act()) {
+			self.activityStep--;
+			return true;
+		}
+		return false;
+	}
+	this.doAfterThis = function (act) {
+		this.activityAfter = act;
+	}
+
+	// activity queue
+	this.animationDelay = 0;
+	this.activityStep = 0;
+	this.activityDelay = 0;
+	this.activityQueue = [];
+	this.preemptActivityQueue = [];
+	this.activityAfter = null;
+	this.activityAnimations = $();
+	this.activityQueueActive = false;
+	this.fastForward = false;
+	this.minorQueue = [];
+	this.resultWaiting = false;
+	this.multiHitMove = null;
+
+	this.queue1 = function () {
+		if (self.activeQueue === self.queue1) self.nextActivity();
+	};
+	this.queue2 = function () {
+		if (self.activeQueue === self.queue2) self.nextActivity();
+	};
+	this.swapQueues = function () {
+		if (self.activeQueue === self.queue1) self.activeQueue = self.queue2;
+		else self.activeQueue = self.queue2;
+	};
+	this.activeQueue = this.queue1;
+
+	this.pause = function () {
+		self.paused = true;
+		self.playbackState = 3;
+		if (self.resumeButton) {
+			self.frameElem.append('<div class="playbutton"><button data-action="resume"><i class="icon-play"></i> Resume</button></div>');
+			self.frameElem.find('div.playbutton button').click(self.resumeButton);
+		}
+		self.soundPause();
+	}
+	this.play = function () {
+		if (self.fastForward) {
+			self.paused = false;
+			self.playbackState = 5;
+		} else if (self.paused) {
+			self.paused = false;
+			if (self.playbackState === 1) {
+				self.soundStop();
+			}
+			self.playbackState = 2;
+			if (!self.done) {
+				self.soundStart();
+			}
+			self.nextActivity();
+		}
+		self.frameElem.find('div.playbutton').remove();
+	}
+	this.skipTurn = function () {
+		self.fastForwardTo(self.turn + 1);
+	};
+	this.fastForwardTo = function (time) {
+		self.playbackState = 5;
+		if (self.fastForward) return;
+		time = parseInt(time);
+		if (isNaN(time)) return;
+		if (self.activityStep >= self.activityQueue.length - 1 && time >= self.turn + 1 && !self.activityQueueActive) return;
+		if (self.done && time >= self.turn + 1) return;
+		self.messagebarElem.empty().css({
+			opacity: 0,
+			height: 0
+		});
+		if (time <= self.turn && time !== -1) {
+			var paused = self.paused;
+			self.reset();
+			self.activityQueueActive = true;
+			if (paused) self.pause();
+			else self.paused = false;
+			self.fastForward = time;
+			self.elem.append('<div class="seeking"><strong>seeking...</strong></div>');
+			$.fx.off = true;
+			self.swapQueues();
+			self.nextActivity();
+			return;
+		}
+		self.fxElem.empty();
+		self.fastForward = time;
+		self.elem.append('<div class="seeking"><strong>seeking...</strong></div>');
+		$.fx.off = true;
+		if (self.yourSide.active[0] && self.yourSide.active[0].sprite) {
+			self.yourSide.active[0].sprite.animReset();
+		}
+		if (self.mySide.active[0] && self.mySide.active[0].sprite) {
+			self.mySide.active[0].sprite.animReset();
+		}
+		self.swapQueues();
+		self.nextActivity();
+	};
+	this.fastForwardOff = function () {
+		self.fastForward = false;
+		self.elem.find('.seeking').remove();
+		$.fx.off = false;
+		self.playbackState = 2;
+	};
+	this.nextActivity = function () {
+		if (self.paused && !self.fastForward) {
+			return;
+		}
+		self.activityQueueActive = true;
+		self.fxElem.empty();
+		self.animationDelay = 0;
+		while (true) {
+			self.activityAnimations = $();
+			if (self.activityStep == self.activityQueue.length) {
+				self.activityQueueActive = false;
+				self.paused = true;
+				self.fastForwardOff();
+				if (self.done) {
+					self.soundStop();
+				}
+				self.playbackState = 4;
+				if (self.endCallback) self.endCallback(self);
+				return;
+			}
+			var ret;
+			if (self.activityAfter) {
+				ret = self.activityAfter();
+				self.activityAfter = null;
+			}
+			if (self.paused && !self.fastForward) return;
+			if (!ret) {
+				self.run(self.activityQueue[self.activityStep]);
+				self.activityStep++;
+			}
+			if (self.activityDelay) {
+				self.delayElem.delay(self.activityDelay);
+				self.activityWait(self.delayElem);
+				self.activityDelay = 0;
+			}
+			if (self.activityAnimations.length) break;
+		}
+		self.activityAnimations.promise().done(self.activeQueue);
+	}
+	this.activityWait = function (elem) {
+		if (typeof elem === 'number' && elem > self.activityDelay) {
+			self.activityDelay = elem;
+			return;
+		}
+		self.activityAnimations = self.activityAnimations.add(elem);
+	}
+
+	this.newBattle = function () {
+		self.reset();
+		self.activityQueue = [];
+	}
+	this.setQueue = function (queue) {
+		self.reset();
+		self.activityQueue = queue;
+
+		/* for (var i = 0; i < queue.length && i < 20; i++) {
+			if (queue[i].substr(0, 8) === 'pokemon ') {
+				var sp = self.parseSpriteData(queue[i].substr(8));
+				BattleSound.loadEffect(sp.cryurl);
+				self.preloadImage(sp.url);
+				if (sp.url === '/sprites/bwani/meloetta.gif') {
+					self.preloadImage('/sprites/bwani/meloetta-pirouette.gif');
+				}
+				if (sp.url === '/sprites/bwani-back/meloetta.gif') {
+					self.preloadImage('/sprites/bwani-back/meloetta-pirouette.gif');
+				}
+			}
+		} */
+		self.playbackState = 1;
+	}
+
+	// callback
+	this.faintCallback = null;
+	this.switchCallback = null;
+	this.dragCallback = null;
+	this.turnCallback = null;
+	this.startCallback = null;
+	this.stagnateCallback = null;
+	this.endCallback = null;
+	this.customCallback = null;
+	this.errorCallback = null;
+
+	// external
+	this.resumeButton = this.play;
+
+	this.preloadCache = {};
+	this.preloadDone = 0;
+	this.preloadNeeded = 0;
+	this.bgm = null;
+
+	this.mute = false;
+
+	this.preloadImage = function (url) {
+		if (noPreload) return;
+		var token = url.replace(/\.(gif|png)$/, '').replace(/\//g, '-');
+		if (self.preloadCache[token]) {
+			return;
+		}
+		self.preloadNeeded++;
+		self.preloadCache[token] = new Image();
+		self.preloadCache[token].onload = function () {
+			self.preloadDone++;
+			self.preloadCallback(self.preloadNeeded === self.preloadDone, self.preloadDone, self.preloadNeeded);
+		};
+		self.preloadCache[token].src = url;
+	};
+	this.preloadCallback = function () {};
+	this.preloadEffects = function () {
+		if (noPreload) return;
+		for (i in BattleEffects) {
+			if (BattleEffects[i].url) self.preloadImage(BattleEffects[i].url);
+		}
+		self.preloadImage(Tools.resourcePrefix + 'fx/weather-raindance.jpg'); // rain is used often enough to precache
+		self.preloadImage(Tools.resourcePrefix + 'sprites/bw/substitute.png');
+		self.preloadImage(Tools.resourcePrefix + 'sprites/bw-back/substitute.png');
+		//self.preloadImage(Tools.resourcePrefix + 'fx/bg.jpg');
+	};
+	self.bgm = null;
+	this.dogarsCheck = function(pokemon) {
+		if (pokemon.side.n === 1) return;
+
+		if (pokemon.species === 'Koffing' && pokemon.name.match(/dogars/i)) {
+			if (window.forceBgm !== -1) {
+				window.originalBgm = window.bgmNum;
+				window.forceBgm = -1;
+				self.preloadBgm();
+				self.soundStart();
+			}
+		} else if (window.forceBgm === -1) {
+			window.forceBgm = null;
+			if (window.originalBgm || window.originalBgm === 0) {
+				window.forceBgm = window.originalBgm;
+			}
+			self.preloadBgm();
+			self.soundStart();
+		}
+	};
+	this.preloadBgm = function() {
+		var bgmNum = Math.floor(Math.random() * 11);
+
+		if (window.forceBgm || window.forceBgm === 0) bgmNum = window.forceBgm;
+		window.bgmNum = bgmNum;
+		switch (bgmNum) {
+		case -1:
+			BattleSound.loadBgm('audio/bw2-homika-dogars.mp3', 1661, 68131);
+			self.bgm = 'audio/bw2-homika-dogars.mp3';
+			break;
+		case 0:
+			BattleSound.loadBgm('audio/hgss-kanto-trainer.mp3', 13003, 94656);
+			self.bgm = 'audio/hgss-kanto-trainer.mp3';
+			break;
+		case 1:
+			BattleSound.loadBgm('audio/bw-subway-trainer.mp3', 15503, 110984);
+			self.bgm = 'audio/bw-subway-trainer.mp3';
+			break;
+		case 2:
+			BattleSound.loadBgm('audio/bw-trainer.mp3', 14629, 110109);
+			self.bgm = 'audio/bw-trainer.mp3';
+			break;
+		case 3:
+			BattleSound.loadBgm('audio/bw-rival.mp3', 19180, 57373);
+			self.bgm = 'audio/bw-rival.mp3';
+			break;
+		case 4:
+			BattleSound.loadBgm('audio/dpp-trainer.mp3', 13440, 96959);
+			self.bgm = 'audio/dpp-trainer.mp3';
+			break;
+		case 5:
+			BattleSound.loadBgm('audio/hgss-johto-trainer.mp3', 23731, 125086);
+			self.bgm = 'audio/hgss-johto-trainer.mp3';
+			break;
+		case 6:
+			BattleSound.loadBgm('audio/dpp-rival.mp3', 13888, 66352);
+			self.bgm = 'audio/dpp-rival.mp3';
+			break;
+		case 7:
+			BattleSound.loadBgm('audio/bw2-kanto-gym-leader.mp3', 14626, 58986);
+			self.bgm = 'audio/bw2-kanto-gym-leader.mp3';
+			break;
+		case 8:
+			BattleSound.loadBgm('audio/bw2-rival.mp3', 7152, 68708);
+			self.bgm = 'audio/bw2-rival.mp3';
+			break;
+		case 9:
+			BattleSound.loadBgm('audio/xy-trainer.mp3', 7802, 82469);
+			self.bgm = 'audio/xy-trainer.mp3';
+			break;
+		case 10:
+		default:
+			BattleSound.loadBgm('audio/xy-rival.mp3', 7802, 58634);
+			self.bgm = 'audio/xy-rival.mp3';
+			break;
+		}
+	};
+	this.setMute = function (mute) {
+		BattleSound.setMute(mute);
+	};
+	this.soundStart = function () {
+		if (!this.bgm) this.preloadBgm();
+		BattleSound.playBgm(this.bgm);
+	};
+	this.soundStop = function () {
+		BattleSound.stopBgm();
+	};
+	this.soundPause = function () {
+		BattleSound.pauseBgm();
+	};
+
+	this.messageDelay = 8;
+
+	this.preloadEffects();
+
+	self.init();
+}
+
+/*
+
+			self.lastmove = 'healing-wish';
+				Tools.getMove('HealingWish').residualAnim(self, [pokemon.sprite]);
+				pokemon.side.wisher = null;
+
+*/
diff --git a/js/battlescene.js b/js/battlescene.js
new file mode 100644
index 000000000..6bd1de331
--- /dev/null
+++ b/js/battlescene.js
@@ -0,0 +1,14 @@
+/**
+ * Battle Scene library
+ * Pokemon Showdown - http://pokemonshowdown.com/
+ *
+ * @license GPLv2 <http://www.gnu.org/licenses/gpl-2.0.html>
+ */
+
+function BattleScene {
+	//
+}
+
+function BattleSprite {
+	//
+}
diff --git a/js/client-battle.js b/js/client-battle.js
index f4032b3b5..c47794570 100644
--- a/js/client-battle.js
+++ b/js/client-battle.js
@@ -252,7 +252,7 @@
 							choices: [],
 							switchFlags: {}
 						}
-						while (switchables[this.choice.choices.length] && switchables[this.choice.choices.length].fainted) {
+						if (this.choice.choices.length > 1) while (switchables[this.choice.choices.length] && switchables[this.choice.choices.length].fainted) {
 							this.choice.choices.push('pass');
 						}
 					}