--- a/src/ai/ai_squirrel.cpp	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/ai/ai_squirrel.cpp	Fri Apr 25 15:29:44 2008 +0000
@@ -231,6 +231,10 @@
 	SQAIEngineList_Register(this->engine);
 	SQAIError_Register(this->engine);
 	SQAIEvent_Register(this->engine);
+	SQAIEventCompanyBankrupt_Register(this->engine);
+	SQAIEventCompanyInTrouble_Register(this->engine);
+	SQAIEventCompanyMerger_Register(this->engine);
+	SQAIEventCompanyNew_Register(this->engine);
 	SQAIEventController_Register(this->engine);
 	SQAIEventEnginePreview_Register(this->engine);
 	SQAIEventSubsidyAwarded_Register(this->engine);

--- a/src/ai/api/ai_event.hpp	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/ai/api/ai_event.hpp	Fri Apr 25 15:29:44 2008 +0000
@@ -28,6 +28,10 @@
 		AI_ET_SUBSIDY_AWARDED,
 		AI_ET_SUBSIDY_EXPIRED,
 		AI_ET_ENGINE_PREVIEW,
+		AI_ET_COMPANY_NEW,
+		AI_ET_COMPANY_IN_TROUBLE,
+		AI_ET_COMPANY_MERGER,
+		AI_ET_COMPANY_BANKRUPT,
 	};
 
 	/**

--- a/src/ai/api/ai_event.hpp.sq	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/ai/api/ai_event.hpp.sq	Fri Apr 25 15:29:44 2008 +0000
@@ -29,6 +29,10 @@
 	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_SUBSIDY_AWARDED,       "AI_ET_SUBSIDY_AWARDED");
 	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_SUBSIDY_EXPIRED,       "AI_ET_SUBSIDY_EXPIRED");
 	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_ENGINE_PREVIEW,        "AI_ET_ENGINE_PREVIEW");
+	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_NEW,           "AI_ET_COMPANY_NEW");
+	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_IN_TROUBLE,    "AI_ET_COMPANY_IN_TROUBLE");
+	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_MERGER,        "AI_ET_COMPANY_MERGER");
+	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_COMPANY_BANKRUPT,      "AI_ET_COMPANY_BANKRUPT");
 
 	SQAIEvent.DefSQStaticMethod(engine, &AIEvent::GetClassName, "GetClassName", 1, "x");
 

--- a/src/ai/api/ai_event_types.hpp	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/ai/api/ai_event_types.hpp	Fri Apr 25 15:29:44 2008 +0000
@@ -306,4 +306,146 @@
 	EngineID engine;
 };
 
+/**
+ * Event Company New, indicating a new company has been created.
+ */
+class AIEventCompanyNew : public AIEvent {
+public:
+	static const char *GetClassName() { return "AIEventCompanyNew"; }
+
+	/**
+	 * @param owner The new company.
+	 */
+	AIEventCompanyNew(PlayerID owner) :
+		AIEvent(AI_ET_COMPANY_NEW),
+		owner((AICompany::CompanyIndex)(byte)owner)
+	{}
+
+	/**
+	 * Convert an AIEvent to the real instance.
+	 * @param instance The instance to convert.
+	 * @return The converted instance.
+	 */
+	static AIEventCompanyNew *Convert(AIEvent *instance) { return (AIEventCompanyNew *)instance; }
+
+	/**
+	 * Get the CompanyIndex of the company that has been created.
+	 * @return The CompanyIndex of the company.
+	 */
+	AICompany::CompanyIndex GetCompanyIndex() { return owner; }
+
+private:
+	AICompany::CompanyIndex owner;
+};
+
+/**
+ * Event Company In Trouble, indicating a company is in trouble and might go
+ *  bankrupt soon.
+ */
+class AIEventCompanyInTrouble : public AIEvent {
+public:
+	static const char *GetClassName() { return "AIEventCompanyInTrouble"; }
+
+	/**
+	 * @param owner The company that is in trouble.
+	 */
+	AIEventCompanyInTrouble(PlayerID owner) :
+		AIEvent(AI_ET_COMPANY_IN_TROUBLE),
+		owner((AICompany::CompanyIndex)(byte)owner)
+	{}
+
+	/**
+	 * Convert an AIEvent to the real instance.
+	 * @param instance The instance to convert.
+	 * @return The converted instance.
+	 */
+	static AIEventCompanyInTrouble *Convert(AIEvent *instance) { return (AIEventCompanyInTrouble *)instance; }
+
+	/**
+	 * Get the CompanyIndex of the company that is in trouble.
+	 * @return The CompanyIndex of the company in trouble.
+	 */
+	AICompany::CompanyIndex GetCompanyIndex() { return owner; }
+
+private:
+	AICompany::CompanyIndex owner;
+};
+
+/**
+ * Event Company Merger, indicating a company has been bought by another
+ *  company.
+ */
+class AIEventCompanyMerger : public AIEvent {
+public:
+	static const char *GetClassName() { return "AIEventCompanyMerger"; }
+
+	/**
+	 * @param owner The company bought off.
+	 * @param new_owner The company that bougth owner.
+	 */
+	AIEventCompanyMerger(PlayerID old_owner, PlayerID new_owner) :
+		AIEvent(AI_ET_COMPANY_MERGER),
+		old_owner((AICompany::CompanyIndex)(byte)old_owner),
+		new_owner((AICompany::CompanyIndex)(byte)new_owner)
+	{}
+
+	/**
+	 * Convert an AIEvent to the real instance.
+	 * @param instance The instance to convert.
+	 * @return The converted instance.
+	 */
+	static AIEventCompanyMerger *Convert(AIEvent *instance) { return (AIEventCompanyMerger *)instance; }
+
+	/**
+	 * Get the CompanyIndex of the company that has been bought.
+	 * @return The CompanyIndex of the company that has been bought.
+	 * @note: The value below is not valid anymore as CompanyIndex, and
+	 *  AICompany::ResolveCompanyIndex will return INVALID_COMPANY. It's
+	 *  only usefull if you're keeping track of company's yourself.
+	 */
+	AICompany::CompanyIndex GetOldCompanyIndex() { return old_owner; }
+
+	/**
+	 * Get the CompanyIndex of the new owner.
+	 * @return The CompanyIndex of the new owner.
+	 */
+	AICompany::CompanyIndex GetNewCompanyIndex() { return new_owner; }
+
+private:
+	AICompany::CompanyIndex old_owner
+	AICompany::CompanyIndex new_owner;
+};
+
+/**
+ * Event Company Bankrupt, indicating a company has gone bankrupt.
+ */
+class AIEventCompanyBankrupt : public AIEvent {
+public:
+	static const char *GetClassName() { return "AIEventCompanyBankrupt"; }
+
+	/**
+	 * @param owner The company that has gone bankrupt.
+	 */
+	AIEventCompanyBankrupt(PlayerID owner) :
+		AIEvent(AI_ET_COMPANY_BANKRUPT),
+		owner((AICompany::CompanyIndex)(byte)owner)
+	{}
+
+	/**
+	 * Convert an AIEvent to the real instance.
+	 * @param instance The instance to convert.
+	 * @return The converted instance.
+	 */
+	static AIEventCompanyBankrupt *Convert(AIEvent *instance) { return (AIEventCompanyBankrupt *)instance; }
+
+	/**
+	 * Get the CompanyIndex of the company that has gone bankrupt.
+	 * @return The CompanyIndex of the company that has gone bankrupt.
+	 */
+	AICompany::CompanyIndex GetCompanyIndex() { return owner; }
+
+private:
+	AICompany::CompanyIndex owner;
+};
+
 #endif /* AI_EVENT_TYPES_HPP */

--- a/src/ai/api/ai_event_types.hpp.sq	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/ai/api/ai_event_types.hpp.sq	Fri Apr 25 15:29:44 2008 +0000
@@ -15,7 +15,6 @@
 void SQAIEventTest_Register(Squirrel *engine) {
 	DefSQClass <AIEventTest> SQAIEventTest("AIEventTest");
 	SQAIEventTest.PreRegister(engine, "AIEvent");
-	SQAIEventTest.AddConstructor<void (AIEventTest::*)(uint test), 2>(engine, "xi");
 
 	SQAIEventTest.DefSQStaticMethod(engine, &AIEventTest::GetClassName, "GetClassName", 1, "x");
 	SQAIEventTest.DefSQStaticMethod(engine, &AIEventTest::Convert,      "Convert",      2, "xx");
@@ -37,7 +36,6 @@
 void SQAIEventVehicleCrash_Register(Squirrel *engine) {
 	DefSQClass <AIEventVehicleCrash> SQAIEventVehicleCrash("AIEventVehicleCrash");
 	SQAIEventVehicleCrash.PreRegister(engine, "AIEvent");
-	SQAIEventVehicleCrash.AddConstructor<void (AIEventVehicleCrash::*)(VehicleID vehicle, TileIndex crash_site), 3>(engine, "xii");
 
 	SQAIEventVehicleCrash.DefSQStaticMethod(engine, &AIEventVehicleCrash::GetClassName, "GetClassName", 1, "x");
 	SQAIEventVehicleCrash.DefSQStaticMethod(engine, &AIEventVehicleCrash::Convert,      "Convert",      2, "xx");
@@ -61,7 +59,6 @@
 void SQAIEventSubsidyOffer_Register(Squirrel *engine) {
 	DefSQClass <AIEventSubsidyOffer> SQAIEventSubsidyOffer("AIEventSubsidyOffer");
 	SQAIEventSubsidyOffer.PreRegister(engine, "AIEvent");
-	SQAIEventSubsidyOffer.AddConstructor<void (AIEventSubsidyOffer::*)(SubsidyID subsidy_id), 2>(engine, "xi");
 
 	SQAIEventSubsidyOffer.DefSQStaticMethod(engine, &AIEventSubsidyOffer::GetClassName, "GetClassName", 1, "x");
 	SQAIEventSubsidyOffer.DefSQStaticMethod(engine, &AIEventSubsidyOffer::Convert,      "Convert",      2, "xx");
@@ -83,7 +80,6 @@
 void SQAIEventSubsidyOfferExpired_Register(Squirrel *engine) {
 	DefSQClass <AIEventSubsidyOfferExpired> SQAIEventSubsidyOfferExpired("AIEventSubsidyOfferExpired");
 	SQAIEventSubsidyOfferExpired.PreRegister(engine, "AIEvent");
-	SQAIEventSubsidyOfferExpired.AddConstructor<void (AIEventSubsidyOfferExpired::*)(SubsidyID subsidy_id), 2>(engine, "xi");
 
 	SQAIEventSubsidyOfferExpired.DefSQStaticMethod(engine, &AIEventSubsidyOfferExpired::GetClassName, "GetClassName", 1, "x");
 	SQAIEventSubsidyOfferExpired.DefSQStaticMethod(engine, &AIEventSubsidyOfferExpired::Convert,      "Convert",      2, "xx");
@@ -105,7 +101,6 @@
 void SQAIEventSubsidyAwarded_Register(Squirrel *engine) {
 	DefSQClass <AIEventSubsidyAwarded> SQAIEventSubsidyAwarded("AIEventSubsidyAwarded");
 	SQAIEventSubsidyAwarded.PreRegister(engine, "AIEvent");
-	SQAIEventSubsidyAwarded.AddConstructor<void (AIEventSubsidyAwarded::*)(SubsidyID subsidy_id), 2>(engine, "xi");
 
 	SQAIEventSubsidyAwarded.DefSQStaticMethod(engine, &AIEventSubsidyAwarded::GetClassName, "GetClassName", 1, "x");
 	SQAIEventSubsidyAwarded.DefSQStaticMethod(engine, &AIEventSubsidyAwarded::Convert,      "Convert",      2, "xx");
@@ -127,7 +122,6 @@
 void SQAIEventSubsidyExpired_Register(Squirrel *engine) {
 	DefSQClass <AIEventSubsidyExpired> SQAIEventSubsidyExpired("AIEventSubsidyExpired");
 	SQAIEventSubsidyExpired.PreRegister(engine, "AIEvent");
-	SQAIEventSubsidyExpired.AddConstructor<void (AIEventSubsidyExpired::*)(SubsidyID subsidy_id), 2>(engine, "xi");
 
 	SQAIEventSubsidyExpired.DefSQStaticMethod(engine, &AIEventSubsidyExpired::GetClassName, "GetClassName", 1, "x");
 	SQAIEventSubsidyExpired.DefSQStaticMethod(engine, &AIEventSubsidyExpired::Convert,      "Convert",      2, "xx");
@@ -149,7 +143,6 @@
 void SQAIEventEnginePreview_Register(Squirrel *engine) {
 	DefSQClass <AIEventEnginePreview> SQAIEventEnginePreview("AIEventEnginePreview");
 	SQAIEventEnginePreview.PreRegister(engine, "AIEvent");
-	SQAIEventEnginePreview.AddConstructor<void (AIEventEnginePreview::*)(EngineID engine), 2>(engine, "xi");
 
 	SQAIEventEnginePreview.DefSQStaticMethod(engine, &AIEventEnginePreview::GetClassName, "GetClassName", 1, "x");
 	SQAIEventEnginePreview.DefSQStaticMethod(engine, &AIEventEnginePreview::Convert,      "Convert",      2, "xx");
@@ -165,3 +158,88 @@
 
 	SQAIEventEnginePreview.PostRegister(engine);
 }
+
+namespace SQConvert {
+	/* Allow AIEventCompanyNew to be used as Squirrel parameter */
+	template <> AIEventCompanyNew *GetParam(ForceType<AIEventCompanyNew *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyNew *)instance; }
+	template <> AIEventCompanyNew &GetParam(ForceType<AIEventCompanyNew &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyNew *)instance; }
+	template <> const AIEventCompanyNew *GetParam(ForceType<const AIEventCompanyNew *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyNew *)instance; }
+	template <> const AIEventCompanyNew &GetParam(ForceType<const AIEventCompanyNew &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyNew *)instance; }
+	template <> int Return<AIEventCompanyNew *>(HSQUIRRELVM vm, AIEventCompanyNew *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyNew", res, NULL, DefSQDestructorCallback<AIEventCompanyNew>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEventCompanyNew_Register(Squirrel *engine) {
+	DefSQClass <AIEventCompanyNew> SQAIEventCompanyNew("AIEventCompanyNew");
+	SQAIEventCompanyNew.PreRegister(engine, "AIEvent");
+
+	SQAIEventCompanyNew.DefSQStaticMethod(engine, &AIEventCompanyNew::GetClassName, "GetClassName", 1, "x");
+	SQAIEventCompanyNew.DefSQStaticMethod(engine, &AIEventCompanyNew::Convert,      "Convert",      2, "xx");
+
+	SQAIEventCompanyNew.DefSQMethod(engine, &AIEventCompanyNew::GetCompanyIndex, "GetCompanyIndex", 1, "x");
+
+	SQAIEventCompanyNew.PostRegister(engine);
+}
+
+namespace SQConvert {
+	/* Allow AIEventCompanyInTrouble to be used as Squirrel parameter */
+	template <> AIEventCompanyInTrouble *GetParam(ForceType<AIEventCompanyInTrouble *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyInTrouble *)instance; }
+	template <> AIEventCompanyInTrouble &GetParam(ForceType<AIEventCompanyInTrouble &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyInTrouble *)instance; }
+	template <> const AIEventCompanyInTrouble *GetParam(ForceType<const AIEventCompanyInTrouble *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyInTrouble *)instance; }
+	template <> const AIEventCompanyInTrouble &GetParam(ForceType<const AIEventCompanyInTrouble &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyInTrouble *)instance; }
+	template <> int Return<AIEventCompanyInTrouble *>(HSQUIRRELVM vm, AIEventCompanyInTrouble *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyInTrouble", res, NULL, DefSQDestructorCallback<AIEventCompanyInTrouble>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEventCompanyInTrouble_Register(Squirrel *engine) {
+	DefSQClass <AIEventCompanyInTrouble> SQAIEventCompanyInTrouble("AIEventCompanyInTrouble");
+	SQAIEventCompanyInTrouble.PreRegister(engine, "AIEvent");
+
+	SQAIEventCompanyInTrouble.DefSQStaticMethod(engine, &AIEventCompanyInTrouble::GetClassName, "GetClassName", 1, "x");
+	SQAIEventCompanyInTrouble.DefSQStaticMethod(engine, &AIEventCompanyInTrouble::Convert,      "Convert",      2, "xx");
+
+	SQAIEventCompanyInTrouble.DefSQMethod(engine, &AIEventCompanyInTrouble::GetCompanyIndex, "GetCompanyIndex", 1, "x");
+
+	SQAIEventCompanyInTrouble.PostRegister(engine);
+}
+
+namespace SQConvert {
+	/* Allow AIEventCompanyMerger to be used as Squirrel parameter */
+	template <> AIEventCompanyMerger *GetParam(ForceType<AIEventCompanyMerger *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyMerger *)instance; }
+	template <> AIEventCompanyMerger &GetParam(ForceType<AIEventCompanyMerger &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyMerger *)instance; }
+	template <> const AIEventCompanyMerger *GetParam(ForceType<const AIEventCompanyMerger *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyMerger *)instance; }
+	template <> const AIEventCompanyMerger &GetParam(ForceType<const AIEventCompanyMerger &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyMerger *)instance; }
+	template <> int Return<AIEventCompanyMerger *>(HSQUIRRELVM vm, AIEventCompanyMerger *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyMerger", res, NULL, DefSQDestructorCallback<AIEventCompanyMerger>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEventCompanyMerger_Register(Squirrel *engine) {
+	DefSQClass <AIEventCompanyMerger> SQAIEventCompanyMerger("AIEventCompanyMerger");
+	SQAIEventCompanyMerger.PreRegister(engine, "AIEvent");
+
+	SQAIEventCompanyMerger.DefSQStaticMethod(engine, &AIEventCompanyMerger::GetClassName, "GetClassName", 1, "x");
+	SQAIEventCompanyMerger.DefSQStaticMethod(engine, &AIEventCompanyMerger::Convert,      "Convert",      2, "xx");
+
+	SQAIEventCompanyMerger.DefSQMethod(engine, &AIEventCompanyMerger::GetOldCompanyIndex, "GetOldCompanyIndex", 1, "x");
+	SQAIEventCompanyMerger.DefSQMethod(engine, &AIEventCompanyMerger::GetNewCompanyIndex, "GetNewCompanyIndex", 1, "x");
+
+	SQAIEventCompanyMerger.PostRegister(engine);
+}
+
+namespace SQConvert {
+	/* Allow AIEventCompanyBankrupt to be used as Squirrel parameter */
+	template <> AIEventCompanyBankrupt *GetParam(ForceType<AIEventCompanyBankrupt *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyBankrupt *)instance; }
+	template <> AIEventCompanyBankrupt &GetParam(ForceType<AIEventCompanyBankrupt &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyBankrupt *)instance; }
+	template <> const AIEventCompanyBankrupt *GetParam(ForceType<const AIEventCompanyBankrupt *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventCompanyBankrupt *)instance; }
+	template <> const AIEventCompanyBankrupt &GetParam(ForceType<const AIEventCompanyBankrupt &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventCompanyBankrupt *)instance; }
+	template <> int Return<AIEventCompanyBankrupt *>(HSQUIRRELVM vm, AIEventCompanyBankrupt *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventCompanyBankrupt", res, NULL, DefSQDestructorCallback<AIEventCompanyBankrupt>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEventCompanyBankrupt_Register(Squirrel *engine) {
+	DefSQClass <AIEventCompanyBankrupt> SQAIEventCompanyBankrupt("AIEventCompanyBankrupt");
+	SQAIEventCompanyBankrupt.PreRegister(engine, "AIEvent");
+
+	SQAIEventCompanyBankrupt.DefSQStaticMethod(engine, &AIEventCompanyBankrupt::GetClassName, "GetClassName", 1, "x");
+	SQAIEventCompanyBankrupt.DefSQStaticMethod(engine, &AIEventCompanyBankrupt::Convert,      "Convert",      2, "xx");
+
+	SQAIEventCompanyBankrupt.DefSQMethod(engine, &AIEventCompanyBankrupt::GetCompanyIndex, "GetCompanyIndex", 1, "x");
+
+	SQAIEventCompanyBankrupt.PostRegister(engine);
+}

--- a/src/ai/api/squirrel_export.awk	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/ai/api/squirrel_export.awk	Fri Apr 25 15:29:44 2008 +0000
@@ -178,7 +178,7 @@
 	} else {
 		print "	SQ" cls ".PreRegister(engine, \"" super_cls "\");"
 	}
-	if (virtual_class == "false") {
+	if (virtual_class == "false" && super_cls != "AIEvent") {
 		print "	SQ" cls ".AddConstructor<void (" cls "::*)(" cls_param[0] "), " cls_param[1]">(engine, \"" cls_param[2] "\");"
 	}
 	print ""

--- a/src/economy.cpp	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/economy.cpp	Fri Apr 25 15:29:44 2008 +0000
@@ -515,6 +515,9 @@
 		case 2:
 			AddNewsItem((StringID)(owner | NB_BTROUBLE),
 				NM_CALLBACK, NF_NONE, NT_COMPANY_INFO, DNC_BANKRUPCY, 0, 0);
+			for (PlayerID i = PLAYER_FIRST; i < MAX_PLAYERS; i++) {
+				AI_Event(i, new AIEventCompanyInTrouble(owner));
+			}
 			break;
 		case 3: {
 			/* XXX - In multiplayer, should we ask other players if it wants to take
@@ -563,6 +566,12 @@
 			p->is_active = false;
 
 			if (!IsHumanPlayer(owner)) AI_PlayerDied(owner);
+
+			/* If the player keeps playing, don't inform the ai of the bankrupt, since
+			 * it might get confused. */
+			for (PlayerID i = PLAYER_FIRST; i < MAX_PLAYERS; i++) {
+				AI_Event(i, new AIEventCompanyBankrupt(owner));
+			}
 		}
 	}
 }
@@ -1838,13 +1847,16 @@
 	Player *owner;
 	int i;
 	Money value;
+	PlayerID pi = p->index;
 
 	SetDParam(0, p->index);
 	SetDParam(1, p->bankrupt_value);
 	AddNewsItem((StringID)(_current_player | NB_BMERGER), NM_CALLBACK, NF_NONE, NT_COMPANY_INFO, DNC_BANKRUPCY, 0, 0);
+	for (PlayerID i = PLAYER_FIRST; i < MAX_PLAYERS; i++) {
+		AI_Event(i, new AIEventCompanyMerger(pi, _current_player));
+	}
 
 	/* original code does this a little bit differently */
-	PlayerID pi = p->index;
 	ChangeNetworkOwner(pi, _current_player);
 	ChangeOwnershipOfPlayerItems(pi, _current_player);
 

--- a/src/players.cpp	Fri Apr 25 15:20:48 2008 +0000
+++ b/src/players.cpp	Fri Apr 25 15:29:44 2008 +0000
@@ -337,6 +337,9 @@
 			SetDParam(0, t->index);
 			AddNewsItem((StringID)(p->index | NB_BNEWCOMPANY), NM_CALLBACK, NF_TILE, NT_COMPANY_INFO, DNC_BANKRUPCY, p->last_build_coordinate, 0);
 		}
+		for (PlayerID i = PLAYER_FIRST; i < MAX_PLAYERS; i++) {
+			if (i != p->index) AI_Event(i, new AIEventCompanyNew(p->index));
+		}
 		return;
 	}
 bad_town_name:;
@@ -913,6 +916,10 @@
 		p->is_active = false;
 		if (!IsHumanPlayer(p->index)) AI_PlayerDied(p->index);
 
+		for (PlayerID i = PLAYER_FIRST; i < MAX_PLAYERS; i++) {
+			AI_Event(i, new AIEventCompanyBankrupt(p->index));
+		}
+
 		RemoveAllEngineReplacementForPlayer(p);
 		RemoveAllGroupsForPlayer(p->index);