Index: ps/trunk/binaries/data/mods/public/simulation/components/Pack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Pack.js	(revision 19428)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Pack.js	(revision 19429)
@@ -1,141 +1,142 @@
 function Pack() {}
 
 const PACKING_INTERVAL = 250;
 
 Pack.prototype.Schema =
 	"<element name='Entity' a:help='Entity to transform into'>" +
 		"<text/>" +
 	"</element>" +
 	"<element name='Time' a:help='Time required to transform this entity, in milliseconds'>" +
 		"<data type='nonNegativeInteger'/>" +
 	"</element>" +
 	"<element name='State' a:help='Whether this entity is packed or unpacked'>" +
 		"<choice>" +
 			"<value>packed</value>" +
 			"<value>unpacked</value>" +
 		"</choice>" +
 	"</element>";
 
 Pack.prototype.Init = function()
 {
 	this.packed = this.template.State == "packed";
 	this.packing = false;
 	this.elapsedTime = 0;
 	this.timer = undefined;
 };
 
 Pack.prototype.OnDestroy = function()
 {
 	this.CancelTimer();
 };
 
 Pack.prototype.CancelTimer = function()
 {
 	if (this.timer)
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		cmpTimer.CancelTimer(this.timer);
 		this.timer = undefined;
 	}
 };
 
 Pack.prototype.IsPacked = function()
 {
 	return this.packed;
 };
 
 Pack.prototype.IsPacking = function()
 {
 	return this.packing;
 };
 
 Pack.prototype.Pack = function()
 {
 	if (this.IsPacked() || this.IsPacking())
 		return;
 
 	this.packing = true;
 
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	this.timer = cmpTimer.SetInterval(this.entity, IID_Pack, "PackProgress", 0, PACKING_INTERVAL, { "packing": true });
 
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (cmpVisual)
 		cmpVisual.SelectAnimation("packing", true, 1.0, "packing");
 };
 
 Pack.prototype.Unpack = function()
 {
 	if (!this.IsPacked() || this.IsPacking())
 		return;
 
 	this.packing = true;
 
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	this.timer = cmpTimer.SetInterval(this.entity, IID_Pack, "PackProgress", 0, PACKING_INTERVAL, { "packing": false });
 
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (cmpVisual)
 		cmpVisual.SelectAnimation("unpacking", true, 1.0, "unpacking");
 };
 
 Pack.prototype.CancelPack = function()
 {
 	if (!this.IsPacking())
 		return;
 
 	this.CancelTimer();
 	this.packing = false;
 	this.SetElapsedTime(0);
 
 	// Clear animation
 	let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 	if (cmpVisual)
 		cmpVisual.SelectAnimation("idle", false, 1.0, "");
 };
 
 Pack.prototype.GetPackTime = function()
 {
 	let cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
 
 	return ApplyValueModificationsToEntity("Pack/Time", +this.template.Time, this.entity) *
 		cmpPlayer.GetCheatTimeMultiplier();
 };
 
 Pack.prototype.GetElapsedTime = function()
 {
 	return this.elapsedTime;
 };
 
 Pack.prototype.GetProgress = function()
 {
 	return this.elapsedTime / this.GetPackTime();
 };
 
 Pack.prototype.SetElapsedTime = function(time)
 {
 	this.elapsedTime = time;
 	Engine.PostMessage(this.entity, MT_PackProgressUpdate, { "progress": this.elapsedTime });
 };
 
 Pack.prototype.PackProgress = function(data, lateness)
 {
 	if (this.elapsedTime < this.GetPackTime())
 	{
 		this.SetElapsedTime(this.GetElapsedTime() + PACKING_INTERVAL + lateness);
 		return;
 	}
 
 	this.CancelTimer();
 	this.packed = !this.packed;
+	this.packing = false;
 
 	Engine.PostMessage(this.entity, MT_PackFinished, { "packed": this.packed });
 
 	let newEntity = ChangeEntityTemplate(this.entity, this.template.Entity);
 
 	if (newEntity)
 		PlaySound(this.packed ? "packed" : "unpacked", newEntity);
 
 };
 
 Engine.RegisterComponentType(IID_Pack, "Pack", Pack);
Index: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Pack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Pack.js	(revision 19428)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Pack.js	(revision 19429)
@@ -1,158 +1,158 @@
 Engine.LoadHelperScript("Player.js");
 Engine.LoadHelperScript("Sound.js");
 Engine.LoadHelperScript("Transform.js");
 Engine.LoadHelperScript("ValueModification.js");
 Engine.LoadComponentScript("interfaces/TechnologyManager.js");
 Engine.LoadComponentScript("interfaces/AuraManager.js");
 Engine.LoadComponentScript("interfaces/Capturable.js");
 Engine.LoadComponentScript("interfaces/GarrisonHolder.js");
 Engine.LoadComponentScript("interfaces/Guard.js");
 Engine.LoadComponentScript("interfaces/Health.js");
 Engine.LoadComponentScript("interfaces/Pack.js");
 Engine.LoadComponentScript("interfaces/Player.js");
 Engine.LoadComponentScript("interfaces/Sound.js");
 Engine.LoadComponentScript("interfaces/Timer.js");
 Engine.LoadComponentScript("interfaces/UnitAI.js");
 Engine.LoadComponentScript("Pack.js");
 Engine.RegisterGlobal("MT_EntityRenamed", "entityRenamed");
 
 const ent = 170;
 const newEnt = 171;
 const PACKING_INTERVAL = 250;
 let timerActivated = false;
 
 AddMock(ent, IID_Visual, {
 	"SelectAnimation": (name, once, speed, soundgroup) => name
 });
 
 AddMock(ent, IID_Ownership, {
 	"GetOwner": () => 1
 });
 
 AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
 	"GetPlayerByID": id => 11
 });
 
 AddMock(11, IID_Player, {
 	"GetCheatTimeMultiplier": () => 1
 });
 
 AddMock(ent, IID_Sound, {
 	"PlaySoundGroup": name => {}
 });
 
 AddMock(SYSTEM_ENTITY, IID_Timer, {
 	"CancelTimer": id => { timerActivated = false; return; },
 	"SetInterval": (ent, iid, funcname, time, repeattime, data) => { timerActivated = true; return 7; }
 });
 
 Engine.AddEntity = function(template) {
 	TS_ASSERT_EQUALS(template, "finalTemplate");
 	return true;
 };
 
 // Test Packing
 
 let template = {
 	"Entity": "finalTemplate",
 	"Time": "2000",
 	"State": "unpacked"
 };
 let cmpPack = ConstructComponent(ent, "Pack", template);
 
 // Check internals
 TS_ASSERT(!cmpPack.packed);
 TS_ASSERT(!cmpPack.packing);
 TS_ASSERT_EQUALS(cmpPack.elapsedTime, 0);
 TS_ASSERT_EQUALS(cmpPack.timer, undefined);
 
 TS_ASSERT(!cmpPack.IsPacked());
 TS_ASSERT(!cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetProgress(), 0);
 
 // Pack
 cmpPack.Pack();
 TS_ASSERT_EQUALS(cmpPack.timer, 7);
 TS_ASSERT(cmpPack.IsPacking());
 
 // Listen to destroy message
 cmpPack.OnDestroy();
 TS_ASSERT(!cmpPack.timer);
 TS_ASSERT(!timerActivated);
 
 // Test UnPacking
 
 template = {
 	"Entity": "finalTemplate",
 	"Time": "2000",
 	"State": "packed"
 };
 
 cmpPack = ConstructComponent(ent, "Pack", template);
 
 // Check internals
 TS_ASSERT(cmpPack.packed);
 TS_ASSERT(!cmpPack.packing);
 TS_ASSERT_EQUALS(cmpPack.elapsedTime, 0);
 TS_ASSERT_EQUALS(cmpPack.timer, undefined);
 
 TS_ASSERT(cmpPack.IsPacked());
 TS_ASSERT(!cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetProgress(), 0);
 
 // Unpack
 cmpPack.Unpack();
 TS_ASSERT(cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.timer, 7);
 
 // Unpack progress
 cmpPack.elapsedTime = 400;
 cmpPack.PackProgress({}, 100);
 
 TS_ASSERT(cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetElapsedTime(), 400 + 100 + PACKING_INTERVAL);
 TS_ASSERT_EQUALS(cmpPack.GetProgress(), (400 + 100 + PACKING_INTERVAL) / 2000);
 
 // Try to Pack or Unpack while packing, nothing happen
 cmpPack.elapsedTime = 400;
 
 cmpPack.Unpack();
 TS_ASSERT(cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetElapsedTime(), 400);
 TS_ASSERT_EQUALS(cmpPack.timer, 7);
 TS_ASSERT(timerActivated);
 
 cmpPack.Pack();
 TS_ASSERT(cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetElapsedTime(), 400);
 TS_ASSERT_EQUALS(cmpPack.timer, 7);
 TS_ASSERT(timerActivated);
 
 // Cancel 
 cmpPack.CancelPack();
 
 TS_ASSERT(!cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetElapsedTime(), 0)
 TS_ASSERT_EQUALS(cmpPack.GetProgress(), 0);
 TS_ASSERT_EQUALS(cmpPack.timer, undefined);
 TS_ASSERT(!timerActivated);
 
 // Progress until completing
 cmpPack.Unpack();
 cmpPack.elapsedTime = 1800;
 cmpPack.PackProgress({}, 100);
 
 TS_ASSERT(cmpPack.IsPacking());
 TS_ASSERT_EQUALS(cmpPack.GetElapsedTime(), 1800 + 100 + PACKING_INTERVAL);
 TS_ASSERT_EQUALS(cmpPack.GetProgress(), (1800 + 100 + PACKING_INTERVAL) / 2000); // Shouldn't we cap at 1?
 TS_ASSERT_EQUALS(cmpPack.timer, 7);
 TS_ASSERT(timerActivated);
 
 // Unpack completing
 cmpPack.Unpack();
 cmpPack.elapsedTime = 2100;
 cmpPack.PackProgress({}, 100);
 
-TS_ASSERT(cmpPack.IsPacking()); // It should be reset? (See StatusBars)
+TS_ASSERT(!cmpPack.IsPacking());
 TS_ASSERT(!cmpPack.timer);
 TS_ASSERT(!timerActivated);