(svn r15359) -Add [NoAI]: AIEventVehicleCrashed::CRASH_RV_UFO, AIEventDisasterZeppelinerCrashed and AIEventDisasterZeppelinerCleared as aliens accepted NoAIs as competing life-form.

src/ai/ai_instance.cpp

@@ -173,6 +173,8 @@ void AIInstance::RegisterAPI()
 	SQAIEventCompanyMerger_Register(this->engine);
 	SQAIEventCompanyNew_Register(this->engine);
 	SQAIEventController_Register(this->engine);
+	SQAIEventDisasterZeppelinerCleared_Register(this->engine);
+	SQAIEventDisasterZeppelinerCrashed_Register(this->engine);
 	SQAIEventEngineAvailable_Register(this->engine);
 	SQAIEventEnginePreview_Register(this->engine);
 	SQAIEventIndustryClose_Register(this->engine);

src/ai/api/ai_event.hpp

@@ -39,6 +39,8 @@ public:
 		AI_ET_INDUSTRY_CLOSE,
 		AI_ET_ENGINE_AVAILABLE,
 		AI_ET_STATION_FIRST_VEHICLE,
+		AI_ET_DISASTER_ZEPPELINER_CRASHED,
+		AI_ET_DISASTER_ZEPPELINER_CLEARED,
 	};
 
 	/**

src/ai/api/ai_event.hpp.sq

@@ -40,6 +40,8 @@ void SQAIEvent_Register(Squirrel *engine) {
 	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_INDUSTRY_CLOSE,              "AI_ET_INDUSTRY_CLOSE");
 	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_ENGINE_AVAILABLE,            "AI_ET_ENGINE_AVAILABLE");
 	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_STATION_FIRST_VEHICLE,       "AI_ET_STATION_FIRST_VEHICLE");
+	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_DISASTER_ZEPPELINER_CRASHED, "AI_ET_DISASTER_ZEPPELINER_CRASHED");
+	SQAIEvent.DefSQConst(engine, AIEvent::AI_ET_DISASTER_ZEPPELINER_CLEARED, "AI_ET_DISASTER_ZEPPELINER_CLEARED");
 
 	SQAIEvent.DefSQStaticMethod(engine, &AIEvent::GetClassName, "GetClassName", 1, "x");
 

src/ai/api/ai_event_types.hpp

@@ -29,6 +29,7 @@ public:
 	enum CrashReason {
 		CRASH_TRAIN,                ///< Two trains collided
 		CRASH_RV_LEVEL_CROSSING,    ///< Road vehicle got under a train
+		CRASH_RV_UFO,               ///< Road vehicle got under a landing ufo
 		CRASH_PLANE_LANDING,        ///< Plane crashed on landing
 		CRASH_AIRCRAFT_NO_AIRPORT,  ///< Aircraft crashed after it found not a single airport for landing
 	};
@@ -668,4 +669,68 @@ private:
 	VehicleID vehicle;
 };
 
+/**
+ * Event Disaster Zeppeliner Crashed, indicating a zeppeliner has crashed on an airport and is blocking the runway.
+ */
+class AIEventDisasterZeppelinerCrashed : public AIEvent {
+public:
+	static const char *GetClassName() { return "AIEventDisasterZeppelinerCrashed"; }
+
+	/**
+	 * @param station The station containing the affected airport
+	 */
+	AIEventDisasterZeppelinerCrashed(StationID station) :
+		AIEvent(AI_ET_DISASTER_ZEPPELINER_CRASHED),
+		station(station)
+	{}
+
+	/**
+	 * Convert an AIEvent to the real instance.
+	 * @param instance The instance to convert.
+	 * @return The converted instance.
+	 */
+	static AIEventDisasterZeppelinerCrashed *Convert(AIEvent *instance) { return (AIEventDisasterZeppelinerCrashed *)instance; }
+
+	/**
+	 * Get the StationID of the station containing the affected airport.
+	 * @return The StationID of the station containing the affected airport.
+	 */
+	StationID GetStationID() { return station; }
+
+private:
+	StationID station;
+};
+
+/**
+ * Event Disaster Zeppeliner Cleared, indicating a previously crashed zeppeliner has been remvoed, and the airport is operating again.
+ */
+class AIEventDisasterZeppelinerCleared : public AIEvent {
+public:
+	static const char *GetClassName() { return "AIEventDisasterZeppelinerCleared"; }
+
+	/**
+	 * @param station The station containing the affected airport
+	 */
+	AIEventDisasterZeppelinerCleared(StationID station) :
+		AIEvent(AI_ET_DISASTER_ZEPPELINER_CLEARED),
+		station(station)
+	{}
+
+	/**
+	 * Convert an AIEvent to the real instance.
+	 * @param instance The instance to convert.
+	 * @return The converted instance.
+	 */
+	static AIEventDisasterZeppelinerCleared *Convert(AIEvent *instance) { return (AIEventDisasterZeppelinerCleared *)instance; }
+
+	/**
+	 * Get the StationID of the station containing the affected airport.
+	 * @return The StationID of the station containing the affected airport.
+	 */
+	StationID GetStationID() { return station; }
+
+private:
+	StationID station;
+};
+
 #endif /* AI_EVENT_TYPES_HPP */

src/ai/api/ai_event_types.hpp.sq

@@ -22,6 +22,7 @@ void SQAIEventVehicleCrashed_Register(Squirrel *engine) {
 
 	SQAIEventVehicleCrashed.DefSQConst(engine, AIEventVehicleCrashed::CRASH_TRAIN,               "CRASH_TRAIN");
 	SQAIEventVehicleCrashed.DefSQConst(engine, AIEventVehicleCrashed::CRASH_RV_LEVEL_CROSSING,   "CRASH_RV_LEVEL_CROSSING");
+	SQAIEventVehicleCrashed.DefSQConst(engine, AIEventVehicleCrashed::CRASH_RV_UFO,              "CRASH_RV_UFO");
 	SQAIEventVehicleCrashed.DefSQConst(engine, AIEventVehicleCrashed::CRASH_PLANE_LANDING,       "CRASH_PLANE_LANDING");
 	SQAIEventVehicleCrashed.DefSQConst(engine, AIEventVehicleCrashed::CRASH_AIRCRAFT_NO_AIRPORT, "CRASH_AIRCRAFT_NO_AIRPORT");
 
@@ -380,3 +381,45 @@ void SQAIEventStationFirstVehicle_Register(Squirrel *engine) {
 
 	SQAIEventStationFirstVehicle.PostRegister(engine);
 }
+
+namespace SQConvert {
+	/* Allow AIEventDisasterZeppelinerCrashed to be used as Squirrel parameter */
+	template <> AIEventDisasterZeppelinerCrashed *GetParam(ForceType<AIEventDisasterZeppelinerCrashed *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventDisasterZeppelinerCrashed *)instance; }
+	template <> AIEventDisasterZeppelinerCrashed &GetParam(ForceType<AIEventDisasterZeppelinerCrashed &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventDisasterZeppelinerCrashed *)instance; }
+	template <> const AIEventDisasterZeppelinerCrashed *GetParam(ForceType<const AIEventDisasterZeppelinerCrashed *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventDisasterZeppelinerCrashed *)instance; }
+	template <> const AIEventDisasterZeppelinerCrashed &GetParam(ForceType<const AIEventDisasterZeppelinerCrashed &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventDisasterZeppelinerCrashed *)instance; }
+	template <> int Return<AIEventDisasterZeppelinerCrashed *>(HSQUIRRELVM vm, AIEventDisasterZeppelinerCrashed *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventDisasterZeppelinerCrashed", res, NULL, DefSQDestructorCallback<AIEventDisasterZeppelinerCrashed>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEventDisasterZeppelinerCrashed_Register(Squirrel *engine) {
+	DefSQClass <AIEventDisasterZeppelinerCrashed> SQAIEventDisasterZeppelinerCrashed("AIEventDisasterZeppelinerCrashed");
+	SQAIEventDisasterZeppelinerCrashed.PreRegister(engine, "AIEvent");
+
+	SQAIEventDisasterZeppelinerCrashed.DefSQStaticMethod(engine, &AIEventDisasterZeppelinerCrashed::GetClassName, "GetClassName", 1, "x");
+	SQAIEventDisasterZeppelinerCrashed.DefSQStaticMethod(engine, &AIEventDisasterZeppelinerCrashed::Convert,      "Convert",      2, "xx");
+
+	SQAIEventDisasterZeppelinerCrashed.DefSQMethod(engine, &AIEventDisasterZeppelinerCrashed::GetStationID, "GetStationID", 1, "x");
+
+	SQAIEventDisasterZeppelinerCrashed.PostRegister(engine);
+}
+
+namespace SQConvert {
+	/* Allow AIEventDisasterZeppelinerCleared to be used as Squirrel parameter */
+	template <> AIEventDisasterZeppelinerCleared *GetParam(ForceType<AIEventDisasterZeppelinerCleared *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventDisasterZeppelinerCleared *)instance; }
+	template <> AIEventDisasterZeppelinerCleared &GetParam(ForceType<AIEventDisasterZeppelinerCleared &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventDisasterZeppelinerCleared *)instance; }
+	template <> const AIEventDisasterZeppelinerCleared *GetParam(ForceType<const AIEventDisasterZeppelinerCleared *>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEventDisasterZeppelinerCleared *)instance; }
+	template <> const AIEventDisasterZeppelinerCleared &GetParam(ForceType<const AIEventDisasterZeppelinerCleared &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEventDisasterZeppelinerCleared *)instance; }
+	template <> int Return<AIEventDisasterZeppelinerCleared *>(HSQUIRRELVM vm, AIEventDisasterZeppelinerCleared *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEventDisasterZeppelinerCleared", res, NULL, DefSQDestructorCallback<AIEventDisasterZeppelinerCleared>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEventDisasterZeppelinerCleared_Register(Squirrel *engine) {
+	DefSQClass <AIEventDisasterZeppelinerCleared> SQAIEventDisasterZeppelinerCleared("AIEventDisasterZeppelinerCleared");
+	SQAIEventDisasterZeppelinerCleared.PreRegister(engine, "AIEvent");
+
+	SQAIEventDisasterZeppelinerCleared.DefSQStaticMethod(engine, &AIEventDisasterZeppelinerCleared::GetClassName, "GetClassName", 1, "x");
+	SQAIEventDisasterZeppelinerCleared.DefSQStaticMethod(engine, &AIEventDisasterZeppelinerCleared::Convert,      "Convert",      2, "xx");
+
+	SQAIEventDisasterZeppelinerCleared.DefSQMethod(engine, &AIEventDisasterZeppelinerCleared::GetStationID, "GetStationID", 1, "x");
+
+	SQAIEventDisasterZeppelinerCleared.PostRegister(engine);
+}

src/disaster_cmd.cpp

@@ -33,6 +33,7 @@
 #include "sound_func.h"
 #include "effectvehicle_func.h"
 #include "roadveh.h"
+#include "ai/ai.hpp"
 
 #include "table/strings.h"
 #include "table/sprites.h"
@@ -215,8 +216,7 @@ static void DisasterTick_Zeppeliner(Vehicle *v)
 
 			if (IsValidTile(tile) &&
 					IsTileType(tile, MP_STATION) &&
-					IsAirport(tile) &&
+					IsAirport(tile)) {
-					IsHumanCompany(GetTileOwner(tile))) {
 				v->current_order.SetDestination(1);
 				v->age = 0;
 
@@ -225,6 +225,7 @@ static void DisasterTick_Zeppeliner(Vehicle *v)
 					NS_ACCIDENT_VEHICLE,
 					v->index,
 					0);
+				AI::NewEvent(GetTileOwner(tile), new AIEventDisasterZeppelinerCrashed(GetStationIndex(tile)));
 			}
 		}
 
@@ -239,10 +240,10 @@ static void DisasterTick_Zeppeliner(Vehicle *v)
 
 		if (IsValidTile(tile) &&
 				IsTileType(tile, MP_STATION) &&
-				IsAirport(tile) &&
+				IsAirport(tile)) {
-				IsHumanCompany(GetTileOwner(tile))) {
 			st = GetStationByTile(tile);
 			CLRBITS(st->airport_flags, RUNWAY_IN_block);
+			AI::NewEvent(GetTileOwner(tile), new AIEventDisasterZeppelinerCleared(st->index));
 		}
 
 		SetDisasterVehiclePos(v, v->x_pos, v->y_pos, v->z_pos);
@@ -280,8 +281,7 @@ static void DisasterTick_Zeppeliner(Vehicle *v)
 	tile = v->tile;
 	if (IsValidTile(tile) &&
 			IsTileType(tile, MP_STATION) &&
-			IsAirport(tile) &&
+			IsAirport(tile)) {
-			IsHumanCompany(GetTileOwner(tile))) {
 		st = GetStationByTile(tile);
 		SETBITS(st->airport_flags, RUNWAY_IN_block);
 	}
@@ -318,7 +318,7 @@ static void DisasterTick_Ufo(Vehicle *v)
 		v->current_order.SetDestination(1);
 
 		FOR_ALL_VEHICLES(u) {
-			if (u->type == VEH_ROAD && IsRoadVehFront(u) && IsHumanCompany(u->owner)) {
+			if (u->type == VEH_ROAD && IsRoadVehFront(u)) {
 				v->dest_tile = u->index;
 				v->age = 0;
 				return;
@@ -358,6 +358,8 @@ static void DisasterTick_Ufo(Vehicle *v)
 					u->index,
 					0);
 
+				AI::NewEvent(u->owner, new AIEventVehicleCrashed(u->index, u->tile, AIEventVehicleCrashed::CRASH_RV_UFO));
+
 				for (Vehicle *w = u; w != NULL; w = w->Next()) {
 					w->vehstatus |= VS_CRASHED;
 					MarkSingleVehicleDirty(w);
@@ -756,9 +758,7 @@ static void Disaster_Zeppeliner_Init()
 	int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
 
 	FOR_ALL_STATIONS(st) {
-		if (st->airport_tile != INVALID_TILE &&
+		if (st->airport_tile != INVALID_TILE && (st->airport_type == AT_SMALL || st->airport_type == AT_LARGE)) {
-				st->airport_type <= 1 &&
-				IsHumanCompany(st->owner)) {
 			x = (TileX(st->airport_tile) + 2) * TILE_SIZE;
 			break;
 		}