openttd-ottdgrfs: comparison src/aircraft

equal deleted inserted replaced

-:3998f2e73dda
+:6404afe43575
 				case LANDING:
 				case HELILANDING:
 				case FLYING:     x = MKIT(24, 24, -1, -1); break;
 				default:         x = MKIT( 2,  2, -1, -1); break;
 			}
-			this->z_height = 5;
+			this->z_extent = 5;
 			break;
-		case AIR_SHADOW:     this->z_height = 1; x = MKIT(2,  2,  0,  0); break;
+		case AIR_SHADOW:     this->z_extent = 1; x = MKIT(2,  2,  0,  0); break;
-		case AIR_ROTOR:      this->z_height = 1; x = MKIT(2,  2, -1, -1); break;
+		case AIR_ROTOR:      this->z_extent = 1; x = MKIT(2,  2, -1, -1); break;
 	}
 #undef MKIT
 	this->x_offs        = GB(x,  0, 8);
 	this->y_offs        = GB(x,  8, 8);
-	this->sprite_width  = GB(x, 16, 8);
+	this->x_extent      = GB(x, 16, 8);
-	this->sprite_height = GB(x, 24, 8);
+	this->y_extent      = GB(x, 24, 8);
 }
 /** this maps the terminal to its corresponding state and block flag
 *  currently set for 10 terms, 4 helipads */
 	Vehicle *v = GetVehicle(p1);
 	if (v->type != VEH_AIRCRAFT || !CheckOwnership(v->owner) || v->IsInDepot()) return CMD_ERROR;
-	if (v->current_order.type == OT_GOTO_DEPOT && !(p2 & DEPOT_LOCATE_HANGAR)) {
+	if (v->current_order.IsType(OT_GOTO_DEPOT) && !(p2 & DEPOT_LOCATE_HANGAR)) {
-		if (!!(p2 & DEPOT_SERVICE) == HasBit(v->current_order.flags, OF_HALT_IN_DEPOT)) {
+		bool halt_in_depot = HasBit(v->current_order.GetDepotActionType(), OF_HALT_IN_DEPOT);
+		if (!!(p2 & DEPOT_SERVICE) == halt_in_depot) {
 			/* We called with a different DEPOT_SERVICE setting.
 			 * Now we change the setting to apply the new one and let the vehicle head for the same hangar.
 			 * Note: the if is (true for requesting service == true for ordered to stop in hangar) */
 			if (flags & DC_EXEC) {
-				ClrBit(v->current_order.flags, OF_PART_OF_ORDERS);
+				v->current_order.SetDepotOrderType(OFB_MANUAL_ORDER);
-				ToggleBit(v->current_order.flags, OF_HALT_IN_DEPOT);
+				v->current_order.SetDepotActionType(halt_in_depot ? OFB_NORMAL_ACTION : OFB_HALT_IN_DEPOT);
 				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 			}
 			return CommandCost();
 		}
 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of hangar orders
 		if (flags & DC_EXEC) {
-			if (v->current_order.flags & OFB_UNLOAD) v->cur_order_index++;
+			/* If the orders to 'goto depot' are in the orders list (forced servicing),
-			v->current_order.type = OT_DUMMY;
+			 * then skip to the next order; effectively cancelling this forced service */
-			v->current_order.flags = 0;
+			if (v->current_order.GetDepotOrderType() & OFB_PART_OF_ORDERS) v->cur_order_index++;
+			v->current_order.MakeDummy();
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 	} else {
 		bool next_airport_has_hangar = true;
 		StationID next_airport_index = v->u.air.targetairport;
 			if (station == INVALID_STATION) return CMD_ERROR;
 			next_airport_index = station;
 		}
 		if (flags & DC_EXEC) {
-			if (v->current_order.type == OT_LOADING) v->LeaveStation();
+			if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
-			v->current_order.type = OT_GOTO_DEPOT;
+			v->current_order.MakeGoToDepot(next_airport_index, false);
-			v->current_order.flags = OFB_NON_STOP;
+			if (!(p2 & DEPOT_SERVICE)) v->current_order.SetDepotActionType(OFB_HALT_IN_DEPOT);
-			if (!(p2 & DEPOT_SERVICE)) SetBit(v->current_order.flags, OF_HALT_IN_DEPOT);
-			v->current_order.refit_cargo = CT_INVALID;
-			v->current_order.dest = next_airport_index;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 			if (v->u.air.state == FLYING && !next_airport_has_hangar) {
 				/* The aircraft is now heading for a different hangar than the next in the orders */
 				AircraftNextAirportPos_and_Order(v);
 			}
 	if (v->IsInDepot()) {
 		VehicleServiceInDepot(v);
 		return;
 	}
-	const Station *st = GetStation(v->current_order.dest);
+	const Station *st = GetStation(v->current_order.GetDestination());
 	/* only goto depot if the target airport has terminals (eg. it is airport) */
 	if (st->IsValid() && st->airport_tile != 0 && st->Airport()->terminals != NULL) {
 //		printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);
 //		v->u.air.targetairport = st->index;
-		v->current_order.type = OT_GOTO_DEPOT;
+		v->current_order.MakeGoToDepot(0, false);
-		v->current_order.flags = OFB_NON_STOP;
 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
-	} else if (v->current_order.type == OT_GOTO_DEPOT) {
+	} else if (v->current_order.IsType(OT_GOTO_DEPOT)) {
-		v->current_order.type = OT_DUMMY;
+		v->current_order.MakeDummy();
-		v->current_order.flags = 0;
 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 	}
 }
 void Aircraft::OnNewDay()
 	if (u->vehstatus & VS_HIDDEN) return;
 	/* if true, helicopter rotors do not rotate. This should only be the case if a helicopter is
 	 * loading/unloading at a terminal or stopped */
-	if (v->current_order.type == OT_LOADING || (v->vehstatus & VS_STOPPED)) {
+	if (v->current_order.IsType(OT_LOADING) || (v->vehstatus & VS_STOPPED)) {
 		if (u->cur_speed != 0) {
 			u->cur_speed++;
 			if (u->cur_speed >= 0x80 && u->u.air.state == HRS_ROTOR_MOVING_3) {
 				u->cur_speed = 0;
 			}
 		tile = st->xy;
 		/* Jump into our "holding pattern" state machine if possible */
 		if (v->u.air.pos >= afc->nofelements) {
 			v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, afc);
-		} else if (v->u.air.targetairport != v->current_order.dest) {
+		} else if (v->u.air.targetairport != v->current_order.GetDestination()) {
 			/* If not possible, just get out of here fast */
 			v->u.air.state = FLYING;
 			UpdateAircraftCache(v);
 			AircraftNextAirportPos_and_Order(v);
 			/* get aircraft back on running altitude */
 			EV_SMOKE
 		);
 	}
 }
-static void ProcessAircraftOrder(Vehicle *v)
+void HandleMissingAircraftOrders(Vehicle *v)
 {
-	switch (v->current_order.type) {
+	/*
-		case OT_GOTO_DEPOT:
+	 * We do not have an order. This can be divided into two cases:
-			if (!(v->current_order.flags & OFB_PART_OF_ORDERS)) return;
+	 * 1) we are heading to an invalid station. In this case we must
-			if (v->current_order.flags & OFB_SERVICE_IF_NEEDED &&
+	 *    find another airport to go to. If there is nowhere to go,
-					!VehicleNeedsService(v)) {
+	 *    we will destroy the aircraft as it otherwise will enter
-				UpdateVehicleTimetable(v, true);
+	 *    the holding pattern for the first airport, which can cause
-				v->cur_order_index++;
+	 *    the plane to go into an undefined state when building an
-			}
+	 *    airport with the same StationID.
-			break;
+	 * 2) we are (still) heading to a (still) valid airport, then we
+	 *    can continue going there. This can happen when you are
-		case OT_LOADING: return;
+	 *    changing the aircraft's orders while in-flight or in for
+	 *    example a depot. However, when we have a current order to
-		default: break;
+	 *    go to a depot, we have to keep that order so the aircraft
-	}
+	 *    actually stops.
+	 */
-	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
+	const Station *st = GetStation(v->u.air.targetairport);
+	if (!st->IsValid() || st->airport_tile == 0) {
-	const Order *order = GetVehicleOrder(v, v->cur_order_index);
+		CommandCost ret;
+		PlayerID old_player = _current_player;
-	if (order == NULL|| (order->type == OT_DUMMY && !CheckForValidOrders(v))) {
-		/*
+		_current_player = v->owner;
-		 * We do not have an order. This can be divided into two cases:
+		ret = DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR);
-		 * 1) we are heading to an invalid station. In this case we must
+		_current_player = old_player;
-		 *    find another airport to go to. If there is nowhere to go,
-		 *    we will destroy the aircraft as it otherwise will enter
+		if (CmdFailed(ret)) CrashAirplane(v);
-		 *    the holding pattern for the first airport, which can cause
+	} else if (!v->current_order.IsType(OT_GOTO_DEPOT)) {
-		 *    the plane to go into an undefined state when building an
+		v->current_order.Free();
-		 *    airport with the same StationID.
+	}
-		 * 2) we are (still) heading to a (still) valid airport, then we
+}
-		 *    can continue going there. This can happen when you are
-		 *    changing the aircraft's orders while in-flight or in for
-		 *    example a depot. However, when we have a current order to
+TileIndex Aircraft::GetOrderStationLocation(StationID station)
-		 *    go to a depot, we have to keep that order so the aircraft
+{
-		 *    actually stops.
+	/* Orders are changed in flight, ensure going to the right station. */
-		 */
+	if (this->u.air.state == FLYING) {
-		const Station *st = GetStation(v->u.air.targetairport);
+		AircraftNextAirportPos_and_Order(this);
-		if (!st->IsValid() || st->airport_tile == 0) {
+	}
-			CommandCost ret;
-			PlayerID old_player = _current_player;
+	/* Aircraft do not use dest-tile */
+	return 0;
-			_current_player = v->owner;
-			ret = DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_SEND_AIRCRAFT_TO_HANGAR);
-			_current_player = old_player;
-			if (CmdFailed(ret)) CrashAirplane(v);
-		} else if (v->current_order.type != OT_GOTO_DEPOT) {
-			v->current_order.Free();
-		}
-		return;
-	}
-	if (order->type  == v->current_order.type  &&
-			order->flags == v->current_order.flags &&
-			order->dest  == v->current_order.dest)
-		return;
-	v->current_order = *order;
-	/* orders are changed in flight, ensure going to the right station */
-	if (order->type == OT_GOTO_STATION && v->u.air.state == FLYING) {
-		AircraftNextAirportPos_and_Order(v);
-	}
-	InvalidateVehicleOrder(v);
-	InvalidateWindowClasses(WC_AIRCRAFT_LIST);
 }
 void Aircraft::MarkDirty()
 {
 		this->cur_image = this->GetImage(this->direction);
 }
 /** we've landed and just arrived at a terminal */
 static void AircraftEntersTerminal(Vehicle *v)
 {
-	if (v->current_order.type == OT_GOTO_DEPOT) return;
+	if (v->current_order.IsType(OT_GOTO_DEPOT)) return;
 	Station *st = GetStation(v->u.air.targetairport);
 	v->last_station_visited = v->u.air.targetairport;
 	/* Check if station was ever visited before */
 /** set the right pos when heading to other airports after takeoff */
 static void AircraftNextAirportPos_and_Order(Vehicle *v)
 {
-	if (v->current_order.type == OT_GOTO_STATION ||
+	if (v->current_order.IsType(OT_GOTO_STATION) ||
-			v->current_order.type == OT_GOTO_DEPOT)
+			v->current_order.IsType(OT_GOTO_DEPOT))
-		v->u.air.targetairport = v->current_order.dest;
+		v->u.air.targetairport = v->current_order.GetDestination();
 	const AirportFTAClass *apc = GetStation(v->u.air.targetairport)->Airport();
 	v->u.air.pos = v->u.air.previous_pos = AircraftGetEntryPoint(v, apc);
 }
 		AircraftEventHandler_EnterHangar(v, apc);
 		return;
 	}
 	/* if we were sent to the depot, stay there */
-	if (v->current_order.type == OT_GOTO_DEPOT && (v->vehstatus & VS_STOPPED)) {
+	if (v->current_order.IsType(OT_GOTO_DEPOT) && (v->vehstatus & VS_STOPPED)) {
 		v->current_order.Free();
 		return;
 	}
-	if (v->current_order.type != OT_GOTO_STATION &&
+	if (!v->current_order.IsType(OT_GOTO_STATION) &&
-			v->current_order.type != OT_GOTO_DEPOT)
+			!v->current_order.IsType(OT_GOTO_DEPOT))
 		return;
 	/* if the block of the next position is busy, stay put */
 	if (AirportHasBlock(v, &apc->layout[v->u.air.pos], apc)) return;
 	/* We are already at the target airport, we need to find a terminal */
-	if (v->current_order.dest == v->u.air.targetairport) {
+	if (v->current_order.GetDestination() == v->u.air.targetairport) {
 		/* FindFreeTerminal:
 		 * 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal */
 		if (v->subtype == AIR_HELICOPTER) {
 			if (!AirportFindFreeHelipad(v, apc)) return; // helicopter
 		} else {
 	if (AirportHasBlock(v, &apc->layout[v->u.air.pos], apc)) return;
 	/* airport-road is free. We either have to go to another airport, or to the hangar
 	 * ---> start moving */
-	switch (v->current_order.type) {
+	switch (v->current_order.GetType()) {
 		case OT_GOTO_STATION: // ready to fly to another airport
 			/* airplane goto state takeoff, helicopter to helitakeoff */
 			v->u.air.state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
 			break;
 		case OT_GOTO_DEPOT:   // visit hangar for serivicing, sale, etc.
-			if (v->current_order.dest == v->u.air.targetairport) {
+			if (v->current_order.GetDestination() == v->u.air.targetairport) {
 				v->u.air.state = HANGAR;
 			} else {
 				v->u.air.state = (v->subtype == AIR_HELICOPTER) ? HELITAKEOFF : TAKEOFF;
 			}
 			break;
 	/* if going to terminal (OT_GOTO_STATION) choose one
 	 * 1. in case all terminals are busy AirportFindFreeTerminal() returns false or
 	 * 2. not going for terminal (but depot, no order),
 	 * --> get out of the way to the hangar. */
-	if (v->current_order.type == OT_GOTO_STATION) {
+	if (v->current_order.IsType(OT_GOTO_STATION)) {
 		if (AirportFindFreeTerminal(v, apc)) return;
 	}
 	v->u.air.state = HANGAR;
 }
 	 * 2. not going for terminal (but depot, no order),
 	 * --> get out of the way to the hangar IF there are terminals on the airport.
 	 * --> else TAKEOFF
 	 * the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes
 	 * must go to a hangar. */
-	if (v->current_order.type == OT_GOTO_STATION) {
+	if (v->current_order.IsType(OT_GOTO_STATION)) {
 		if (AirportFindFreeHelipad(v, apc)) return;
 	}
 	v->u.air.state = (apc->nof_depots != 0) ? HANGAR : HELITAKEOFF;
 }
 			v->breakdown_ctr--;
 		}
 	}
 	HandleAircraftSmoke(v);
-	ProcessAircraftOrder(v);
+	ProcessOrders(v);
 	v->HandleLoading(loop != 0);
-	if (v->current_order.type >= OT_LOADING) return;
+	if (v->current_order.IsType(OT_LOADING) || v->current_order.IsType(OT_LEAVESTATION)) return;
 	AirportGoToNextPosition(v);
 }
 void Aircraft::Tick()

branch	noai
changeset 9869	6404afe43575
parent 9837	c9ec4f82e0d0
child 10142	56ee7da4ad56