openttd-ottdgrfs: comparison src/order

equal deleted inserted replaced

-:4bf29d14edba
+:c30fe89622df
 	order.refit_subtype = 0;
 	order.index = 0; // avoid compiler warning
 	// Sanity check
 	// TTD stores invalid orders as OT_NOTHING with non-zero flags/station
-	if (order.type == OT_NOTHING && (order.flags != 0 || order.dest != 0)) {
+	if (!order.IsValid() && (order.flags != 0 || order.dest != 0)) {
 		order.type = OT_DUMMY;
 		order.flags = 0;
 	}
 	return order;
 * Allocate a new order
 *
 * @return Order* if a free space is found, else NULL.
 *
 */
-static Order *AllocateOrder(void)
+static Order *AllocateOrder()
 {
 	Order *order;
 	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
 	 * TODO - This is just a temporary stage, this will be removed. */
 	for (order = GetOrder(0); order != NULL; order = (order->index + 1U < GetOrderPoolSize()) ? GetOrder(order->index + 1U) : NULL) {
-		if (!IsValidOrder(order)) {
+		if (!order->IsValid()) {
 			OrderID index = order->index;
 			memset(order, 0, sizeof(*order));
 			order->index = index;
 			order->next = NULL;
 			if (st->owner != OWNER_NONE && !CheckOwnership(st->owner)) {
 				return CMD_ERROR;
 			}
 			switch (v->type) {
-				case VEH_Train:
+				case VEH_TRAIN:
 					if (!(st->facilities & FACIL_TRAIN)) return CMD_ERROR;
 					break;
-				case VEH_Road:
+				case VEH_ROAD:
 					if (v->cargo_type == CT_PASSENGERS) {
 						if (!(st->facilities & FACIL_BUS_STOP)) return CMD_ERROR;
 					} else {
 						if (!(st->facilities & FACIL_TRUCK_STOP)) return CMD_ERROR;
 					}
 					break;
-				case VEH_Ship:
+				case VEH_SHIP:
 					if (!(st->facilities & FACIL_DOCK)) return CMD_ERROR;
 					break;
-				case VEH_Aircraft:
+				case VEH_AIRCRAFT:
 					if (!(st->facilities & FACIL_AIRPORT)) return CMD_ERROR;
 					break;
 				default: return CMD_ERROR;
 			}
 				case OF_NON_STOP | OF_FULL_LOAD:
 				case OF_NON_STOP | OF_FULL_LOAD | OF_TRANSFER:
 				case OF_NON_STOP | OF_UNLOAD:
 				case OF_NON_STOP | OF_UNLOAD | OF_TRANSFER:
 				case OF_NON_STOP | OF_TRANSFER:
-					if (v->type != VEH_Train) return CMD_ERROR;
+					if (v->type != VEH_TRAIN) return CMD_ERROR;
 					break;
 				default: return CMD_ERROR;
 			}
 			break;
 		}
 		case OT_GOTO_DEPOT: {
-			if (v->type == VEH_Aircraft) {
+			if (v->type == VEH_AIRCRAFT) {
 				const Station* st;
 				if (!IsValidStationID(new_order.dest)) return CMD_ERROR;
 				st = GetStation(new_order.dest);
 				dp = GetDepot(new_order.dest);
 				if (!CheckOwnership(GetTileOwner(dp->xy))) return CMD_ERROR;
 				switch (v->type) {
-					case VEH_Train:
+					case VEH_TRAIN:
 						if (!IsTileDepotType(dp->xy, TRANSPORT_RAIL)) return CMD_ERROR;
 						break;
-					case VEH_Road:
+					case VEH_ROAD:
 						if (!IsTileDepotType(dp->xy, TRANSPORT_ROAD)) return CMD_ERROR;
 						break;
-					case VEH_Ship:
+					case VEH_SHIP:
 						if (!IsTileDepotType(dp->xy, TRANSPORT_WATER)) return CMD_ERROR;
 						break;
 					default: return CMD_ERROR;
 				}
 				case OF_PART_OF_ORDERS | OF_HALT_IN_DEPOT:
 					break;
 				case OF_NON_STOP | OF_PART_OF_ORDERS:
 				case OF_NON_STOP | OF_PART_OF_ORDERS | OF_HALT_IN_DEPOT:
-					if (v->type != VEH_Train) return CMD_ERROR;
+					if (v->type != VEH_TRAIN) return CMD_ERROR;
 					break;
 				default: return CMD_ERROR;
 			}
 			break;
 		}
 		case OT_GOTO_WAYPOINT: {
 			const Waypoint* wp;
-			if (v->type != VEH_Train) return CMD_ERROR;
+			if (v->type != VEH_TRAIN) return CMD_ERROR;
 			if (!IsValidWaypointID(new_order.dest)) return CMD_ERROR;
 			wp = GetWaypoint(new_order.dest);
 			if (!CheckOwnership(GetTileOwner(wp->xy))) return CMD_ERROR;
 			 * non-stop orders (if any) are only valid for trains */
 			switch (new_order.flags) {
 				case 0: break;
 				case OF_NON_STOP:
-					if (v->type != VEH_Train) return CMD_ERROR;
+					if (v->type != VEH_TRAIN) return CMD_ERROR;
 					break;
 				default: return CMD_ERROR;
 			}
 			break;
 	/* XXX - This limit is only here because the backuppedorders can't
 	 * handle any more then this.. */
 	if (v->num_orders >= MAX_BACKUP_ORDER_COUNT) return_cmd_error(STR_8832_TOO_MANY_ORDERS);
-	if (v->type == VEH_Ship &&
+	if (v->type == VEH_SHIP &&
 			IsHumanPlayer(v->owner) &&
 			!_patches.new_pathfinding_all) {
 		// Make sure the new destination is not too far away from the previous
 		const Order *prev = NULL;
 		uint n = 0;
 		} else {
 			GetVehicleOrder(v, sel_ord - 1)->next = order->next;
 		}
 		/* Give the item free */
-		order->type = OT_NOTHING;
+		order->Free();
-		order->next = NULL;
 		u = GetFirstVehicleFromSharedList(v);
 		DeleteOrderWarnings(u);
 		for (; u != NULL; u = u->next_shared) {
 			u->num_orders--;
 		VehicleOrderID b = v->cur_order_index + 1;
 		if (b >= v->num_orders) b = 0;
 		v->cur_order_index = b;
-		if (v->type == VEH_Train) v->u.rail.days_since_order_progr = 0;
+		if (v->type == VEH_TRAIN) v->u.rail.days_since_order_progr = 0;
-		if (v->type == VEH_Road) ClearSlot(v);
+		if (v->type == VEH_ROAD) ClearSlot(v);
 		/* NON-stop flag is misused to see if a train is in a station that is
 		 * on his order list or not */
 		if (v->current_order.type == OT_LOADING && HASBIT(v->current_order.flags, OFB_NON_STOP))
 			v->current_order.flags = 0;
 		InvalidateVehicleOrder(v);
 	}
 	/* We have an aircraft/ship, they have a mini-schedule, so update them all */
-	if (v->type == VEH_Aircraft) InvalidateWindowClasses(WC_AIRCRAFT_LIST);
+	if (v->type == VEH_AIRCRAFT) InvalidateWindowClasses(WC_AIRCRAFT_LIST);
-	if (v->type == VEH_Ship) InvalidateWindowClasses(WC_SHIPS_LIST);
+	if (v->type == VEH_SHIP) InvalidateWindowClasses(WC_SHIPS_LIST);
 	return 0;
 }
 			/* Sanity checks */
 			if (!CheckOwnership(src->owner) || dst->type != src->type || dst == src)
 				return CMD_ERROR;
 			/* Trucks can't share orders with busses (and visa versa) */
-			if (src->type == VEH_Road) {
+			if (src->type == VEH_ROAD) {
 				if (src->cargo_type != dst->cargo_type && (src->cargo_type == CT_PASSENGERS || dst->cargo_type == CT_PASSENGERS))
 					return CMD_ERROR;
 			}
 			/* Is the vehicle already in the shared list? */
 			/* Sanity checks */
 			if (!CheckOwnership(src->owner) || dst->type != src->type || dst == src)
 				return CMD_ERROR;
 			/* Trucks can't copy all the orders from busses (and visa versa) */
-			if (src->type == VEH_Road) {
+			if (src->type == VEH_ROAD) {
 				const Order *order;
 				TileIndex required_dst = INVALID_TILE;
 				FOR_VEHICLE_ORDERS(src, order) {
 					if (order->type == OT_GOTO_STATION) {
 		/* Copy the orders */
 		FOR_VEHICLE_ORDERS(v, order) {
 			*dest = *order;
 			dest++;
 		}
-		/* End the list with an OT_NOTHING */
+		/* End the list with an empty order */
-		dest->type = OT_NOTHING;
+		dest->Free();
-		dest->next = NULL;
 	}
 }
 /**
 *
 	/* CMD_NO_TEST_IF_IN_NETWORK is used here, because CMD_INSERT_ORDER checks if the
 	 *  order number is one more than the current amount of orders, and because
 	 *  in network the commands are queued before send, the second insert always
 	 *  fails in test mode. By bypassing the test-mode, that no longer is a problem. */
-	for (i = 0; bak->order[i].type != OT_NOTHING; i++) {
+	for (i = 0; bak->order[i].IsValid(); i++) {
 		if (!DoCommandP(0, v->index + (i << 16), PackOrder(&bak->order[i]), NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK))
 			break;
 	}
 	/* Restore vehicle order-index and service interval */
 static TileIndex GetStationTileForVehicle(const Vehicle* v, const Station* st)
 {
 	switch (v->type) {
 		default: NOT_REACHED();
-		case VEH_Train:     return st->train_tile;
+		case VEH_TRAIN:     return st->train_tile;
-		case VEH_Aircraft:  return st->airport_tile;
+		case VEH_AIRCRAFT:  return st->airport_tile;
-		case VEH_Ship:      return st->dock_tile;
+		case VEH_SHIP:      return st->dock_tile;
-		case VEH_Road:
+		case VEH_ROAD:
 			if (v->cargo_type == CT_PASSENGERS) {
 				return (st->bus_stops != NULL) ? st->bus_stops->xy : 0;
 			} else {
 				return (st->truck_stops != NULL) ? st->truck_stops->xy : 0;
 			}
 		if (v->last_station_visited == destination && type == OT_GOTO_STATION) {
 			v->last_station_visited = INVALID_STATION;
 		}
 		order = &v->current_order;
-		if ((v->type == VEH_Aircraft && order->type == OT_GOTO_DEPOT ? OT_GOTO_STATION : order->type) == type &&
+		if ((v->type == VEH_AIRCRAFT && order->type == OT_GOTO_DEPOT ? OT_GOTO_STATION : order->type) == type &&
 				v->current_order.dest == destination) {
 			order->type = OT_DUMMY;
 			order->flags = 0;
 			InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 		}
 		/* Clear the order from the order-list */
 		invalidate = false;
 		FOR_VEHICLE_ORDERS(v, order) {
-			if ((v->type == VEH_Aircraft && order->type == OT_GOTO_DEPOT ? OT_GOTO_STATION : order->type) == type &&
+			if ((v->type == VEH_AIRCRAFT && order->type == OT_GOTO_DEPOT ? OT_GOTO_STATION : order->type) == type &&
 					order->dest == destination) {
 				order->type = OT_DUMMY;
 				order->flags = 0;
 				invalidate = true;
 			}
 * Delete all orders from a vehicle
 *
 */
 void DeleteVehicleOrders(Vehicle *v)
 {
-	Order *cur, *next;
 	DeleteOrderWarnings(v);
 	/* If we have a shared order-list, don't delete the list, but just
 	    remove our pointer */
 	if (IsOrderListShared(v)) {
 		InvalidateVehicleOrder(u);
 		return;
 	}
 	/* Remove the orders */
-	cur = v->orders;
+	Order *cur = v->orders;
 	v->orders = NULL;
 	v->num_orders = 0;
 	if (cur != NULL) {
 		/* Delete the vehicle list of shared orders, if any */
 		WindowClass window_class = WC_NONE;
 		switch (v->type) {
 			default: NOT_REACHED();
-			case VEH_Train:    window_class = WC_TRAINS_LIST;   break;
+			case VEH_TRAIN:    window_class = WC_TRAINS_LIST;   break;
-			case VEH_Road:     window_class = WC_ROADVEH_LIST;  break;
+			case VEH_ROAD:     window_class = WC_ROADVEH_LIST;  break;
-			case VEH_Ship:     window_class = WC_SHIPS_LIST;    break;
+			case VEH_SHIP:     window_class = WC_SHIPS_LIST;    break;
-			case VEH_Aircraft: window_class = WC_AIRCRAFT_LIST; break;
+			case VEH_AIRCRAFT: window_class = WC_AIRCRAFT_LIST; break;
 		}
 		DeleteWindowById(window_class, (cur->index << 16) | (v->type << 11) | VLW_SHARED_ORDERS | v->owner);
-	}
+		cur->FreeChain(); // Free the orders.
-	while (cur != NULL) {
-		next = cur->next;
-		DeleteOrder(cur);
-		cur = next;
 	}
 }
 /**
 *
 	FOR_VEHICLE_ORDERS(v, order) if (order->type != OT_DUMMY) return true;
 	return false;
 }
-void InitializeOrders(void)
+void InitializeOrders()
 {
 	CleanPool(&_Order_pool);
 	AddBlockToPool(&_Order_pool);
 	_backup_orders_tile = 0;
 	 * We will never use those free bytes, but we have to keep this line to allow loading of old savegames */
 	SLE_CONDNULL(10, 5, 35),
 	SLE_END()
 };
-static void Save_ORDR(void)
+static void Save_ORDR()
 {
 	Order *order;
 	FOR_ALL_ORDERS(order) {
 		SlSetArrayIndex(order->index);
 		SlObject(order, _order_desc);
 	}
 }
-static void Load_ORDR(void)
+static void Load_ORDR()
 {
 	if (CheckSavegameVersionOldStyle(5, 2)) {
 		/* Version older than 5.2 did not have a ->next pointer. Convert them
 		    (in the old days, the orderlist was 5000 items big) */
 		uint len = SlGetFieldLength();
 		}
 		/* Update all the next pointer */
 		for (i = 1; i < len; ++i) {
 			/* The orders were built like this:
-			 *   Vehicle one had order[0], and as long as order++.type was not
+			 *   While the order is valid, set the previous will get it's next pointer set
-			 *   OT_NOTHING, it was part of the order-list of that vehicle */
+			 *   We start with index 1 because no order will have the first in it's next pointer */
-			if (GetOrder(i)->type != OT_NOTHING)
+			if (GetOrder(i)->IsValid())
 				GetOrder(i - 1)->next = GetOrder(i);
 		}
 	} else {
 		int index;

branch	cpp_gui
changeset 6298	c30fe89622df
parent 6268	4b5241e5dd10
child 6303	84c215fc8eb8