openttd-mini: comparison src/order

equal deleted inserted replaced

-:8fa962d90b63
+:f6f1ea3d7e93
 	this->flags = 0;
 	this->dest  = 0;
 	this->next  = NULL;
 }
+void Order::MakeGoToStation(StationID destination)
+{
+	this->type = OT_GOTO_STATION;
+	this->flags = 0;
+	this->dest = destination;
+}
+void Order::MakeGoToDepot(DepotID destination, bool order)
+{
+	this->type = OT_GOTO_DEPOT;
+	this->flags = order ? OFB_PART_OF_ORDERS : OFB_NON_STOP;
+	this->dest = destination;
+	this->refit_cargo = CT_NO_REFIT;
+	this->refit_subtype = 0;
+}
+void Order::MakeGoToWaypoint(WaypointID destination)
+{
+	this->type = OT_GOTO_WAYPOINT;
+	this->flags = 0;
+	this->dest = destination;
+}
+void Order::MakeLoading()
+{
+	this->type = OT_LOADING;
+}
+void Order::MakeLeaveStation()
+{
+	this->type = OT_LEAVESTATION;
+	this->flags = 0;
+}
+void Order::MakeDummy()
+{
+	this->type = OT_DUMMY;
+	this->flags = 0;
+}
 void Order::FreeChain()
 {
 	if (next != NULL) next->FreeChain();
 	delete this;
 }
 /**
 *
 * Unpacks a order from savegames with version 4 and lower
 *
 */
-static Order UnpackVersion4Order(uint16 packed)
+Order UnpackVersion4Order(uint16 packed)
 {
 	Order order;
 	order.type  = (OrderType)GB(packed, 0, 4);
 	order.flags = GB(packed, 4, 4);
 	order.dest  = GB(packed, 8, 8);
 }
 static TileIndex GetOrderLocation(const Order& o)
 {
-	switch (o.type) {
+	switch (o.GetType()) {
 		default: NOT_REACHED();
 		case OT_GOTO_STATION: return GetStation(o.dest)->xy;
 		case OT_GOTO_DEPOT:   return GetDepot(o.dest)->xy;
 	}
 }
 	if (!CheckOwnership(v->owner)) return CMD_ERROR;
 	/* Check if the inserted order is to the correct destination (owner, type),
 	 * and has the correct flags if any */
-	switch (new_order.type) {
+	switch (new_order.GetType()) {
 		case OT_GOTO_STATION: {
 			const Station *st;
 			if (!IsValidStationID(new_order.dest)) return CMD_ERROR;
 			st = GetStation(new_order.dest);
 		/* Find the last goto station or depot order before the insert location.
 		 * If the order is to be inserted at the beginning of the order list this
 		 * finds the last order in the list. */
 		for (const Order *o = v->orders; o != NULL; o = o->next) {
-			if (o->type == OT_GOTO_STATION || o->type == OT_GOTO_DEPOT) prev = o;
+			if (o->IsType(OT_GOTO_STATION) || o->IsType(OT_GOTO_DEPOT)) prev = o;
 			if (++n == sel_ord && prev != NULL) break;
 		}
 		if (prev != NULL) {
 			uint dist = DistanceManhattan(
 				GetOrderLocation(*prev),
 			assert(v->orders == u->orders);
 			/* NON-stop flag is misused to see if a train is in a station that is
 			 * on his order list or not */
-			if (sel_ord == u->cur_order_index && u->current_order.type == OT_LOADING &&
+			if (sel_ord == u->cur_order_index && u->current_order.IsType(OT_LOADING) &&
 					HasBit(u->current_order.flags, OF_NON_STOP)) {
 				u->current_order.flags = 0;
 			}
 			/* Update any possible open window of the vehicle */
 	if (flags & DC_EXEC) {
 		v->cur_order_index = sel_ord;
 		if (v->type == VEH_ROAD) ClearSlot(v);
-		if (v->current_order.type == OT_LOADING) {
+		if (v->current_order.IsType(OT_LOADING)) {
 			v->LeaveStation();
 			/* NON-stop flag is misused to see if a train is in a station that is
 			 * on his order list or not */
 			if (HasBit(v->current_order.flags, OF_NON_STOP)) v->current_order.flags = 0;
 		}
 	/* Is it a valid order? */
 	if (sel_ord >= v->num_orders) return CMD_ERROR;
 	order = GetVehicleOrder(v, sel_ord);
-	if ((order->type != OT_GOTO_STATION  || GetStation(order->dest)->IsBuoy()) &&
+	if ((!order->IsType(OT_GOTO_STATION)  || GetStation(order->dest)->IsBuoy()) &&
-			(order->type != OT_GOTO_DEPOT    || p2 == OF_UNLOAD) &&
+			(!order->IsType(OT_GOTO_DEPOT)    || p2 == OF_UNLOAD) &&
-			(order->type != OT_GOTO_WAYPOINT || p2 != OF_NON_STOP)) {
+			(!order->IsType(OT_GOTO_WAYPOINT) || p2 != OF_NON_STOP)) {
 		return CMD_ERROR;
 	}
 	if (flags & DC_EXEC) {
 		switch (p2) {
 		case OF_FULL_LOAD:
 			ToggleBit(order->flags, OF_FULL_LOAD);
-			if (order->type != OT_GOTO_DEPOT) ClrBit(order->flags, OF_UNLOAD);
+			if (!order->IsType(OT_GOTO_DEPOT)) ClrBit(order->flags, OF_UNLOAD);
 			break;
 		case OF_UNLOAD:
 			ToggleBit(order->flags, OF_UNLOAD);
 			ClrBit(order->flags, OF_FULL_LOAD);
 			break;
 				 * other cases for the OrderTypeByte the flags are not used,
 				 * so do not care and those orders should not be active
 				 * when this function is called.
 				 */
 				if (sel_ord == u->cur_order_index &&
-						u->current_order.type != OT_GOTO_DEPOT &&
+						!u->current_order.IsType(OT_GOTO_DEPOT) &&
 						HasBit(u->current_order.flags, OF_FULL_LOAD) != HasBit(order->flags, OF_FULL_LOAD)) {
 					ToggleBit(u->current_order.flags, OF_FULL_LOAD);
 				}
 				InvalidateVehicleOrder(u);
 			}
 			if (src->type == VEH_ROAD) {
 				const Order *order;
 				TileIndex required_dst = INVALID_TILE;
 				FOR_VEHICLE_ORDERS(src, order) {
-					if (order->type == OT_GOTO_STATION) {
+					if (order->IsType(OT_GOTO_STATION)) {
 						const Station *st = GetStation(order->dest);
 						if (IsCargoInClass(dst->cargo_type, CC_PASSENGERS)) {
 							if (st->bus_stops != NULL) required_dst = st->bus_stops->xy;
 						} else {
 							if (st->truck_stops != NULL) required_dst = st->truck_stops->xy;
 		/* Check the order list */
 		n_st = 0;
 		FOR_VEHICLE_ORDERS(v, order) {
 			/* Dummy order? */
-			if (order->type == OT_DUMMY) {
+			if (order->IsType(OT_DUMMY)) {
 				problem_type = 1;
 				break;
 			}
 			/* Does station have a load-bay for this vehicle? */
-			if (order->type == OT_GOTO_STATION) {
+			if (order->IsType(OT_GOTO_STATION)) {
 				const Station* st = GetStation(order->dest);
 				TileIndex required_tile = GetStationTileForVehicle(v, st);
 				n_st++;
 				if (required_tile == 0) problem_type = 3;
 		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->IsType(OT_GOTO_DEPOT) ? OT_GOTO_STATION : order->GetType()) == type &&
 				v->current_order.dest == destination) {
-			order->type = OT_DUMMY;
+			order->MakeDummy();
-			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->IsType(OT_GOTO_DEPOT) ? OT_GOTO_STATION : order->GetType()) == type &&
 					order->dest == destination) {
-				order->type = OT_DUMMY;
+				order->MakeDummy();
-				order->flags = 0;
 				invalidate = true;
 			}
 		}
 		/* Only invalidate once, and if needed */
 bool VehicleHasDepotOrders(const Vehicle *v)
 {
 	const Order *order;
 	FOR_VEHICLE_ORDERS(v, order) {
-		if (order->type == OT_GOTO_DEPOT)
+		if (order->IsType(OT_GOTO_DEPOT))
 			return true;
 	}
 	return false;
 }
 */
 static bool CheckForValidOrders(const Vehicle *v)
 {
 	const Order *order;
-	FOR_VEHICLE_ORDERS(v, order) if (order->type != OT_DUMMY) return true;
+	FOR_VEHICLE_ORDERS(v, order) if (!order->IsType(OT_DUMMY)) return true;
 	return false;
 }
 /**
 * @return true *if* the vehicle is eligible for reversing
 *              (basically only when leaving a station).
 */
 bool ProcessOrders(Vehicle *v)
 {
-	switch (v->current_order.type) {
+	switch (v->current_order.GetType()) {
 		case OT_GOTO_DEPOT:
 			/* Let a depot order in the orderlist interrupt. */
 			if (!(v->current_order.flags & OFB_PART_OF_ORDERS)) return false;
 			if ((v->current_order.flags & OFB_SERVICE_IF_NEEDED) && !VehicleNeedsService(v)) {
 	 * station (and the difficulty setting to allowed, of course)
 	 * this can be detected because only after OT_LEAVESTATION, current_order
 	 * will be reset to nothing. (That also happens if no order, but in that case
 	 * it won't hit the point in code where may_reverse is checked)
 	 */
-	bool may_reverse = v->current_order.type == OT_NOTHING;
+	bool may_reverse = v->current_order.IsType(OT_NOTHING);
 	/* Check if we've reached the waypoint? */
-	if (v->current_order.type == OT_GOTO_WAYPOINT && v->tile == v->dest_tile) {
+	if (v->current_order.IsType(OT_GOTO_WAYPOINT) && v->tile == v->dest_tile) {
 		UpdateVehicleTimetable(v, true);
 		v->cur_order_index++;
 	}
 	/* Check if we've reached a non-stop station while TTDPatch nonstop is enabled.. */
 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
 	const Order *order = GetVehicleOrder(v, v->cur_order_index);
 	/* If no order, do nothing. */
-	if (order == NULL || (v->type == VEH_AIRCRAFT && order->type == OT_DUMMY && !CheckForValidOrders(v))) {
+	if (order == NULL || (v->type == VEH_AIRCRAFT && order->IsType(OT_DUMMY) && !CheckForValidOrders(v))) {
 		if (v->type == VEH_AIRCRAFT) {
 			/* Aircraft do something vastly different here, so handle separately */
 			extern void HandleMissingAircraftOrders(Vehicle *v);
 			HandleMissingAircraftOrders(v);
 			return false;
 		return false;
 	}
 	/* If it is unchanged, keep it. */
 	if (order->Equals(v->current_order) &&
-			(v->type != VEH_SHIP || order->type != OT_GOTO_STATION || GetStation(order->dest)->dock_tile != 0)) {
+			(v->type != VEH_SHIP || !order->IsType(OT_GOTO_STATION) || GetStation(order->dest)->dock_tile != 0)) {
 		return false;
 	}
 	/* Otherwise set it, and determine the destination tile. */
 	v->current_order = *order;
 		case VEH_SHIP:
 			InvalidateWindowClasses(v->GetVehicleListWindowClass());
 			break;
 	}
-	switch (order->type) {
+	switch (order->GetType()) {
 		case OT_GOTO_STATION:
 			v->dest_tile = v->GetOrderStationLocation(order->dest);
 			break;
 		case OT_GOTO_DEPOT:
 	_Order_pool.AddBlockToPool();
 	_backup_orders_tile = 0;
 }
+const SaveLoad *GetOrderDescription() {
 static const SaveLoad _order_desc[] = {
 	SLE_VAR(Order, type,  SLE_UINT8),
 	SLE_VAR(Order, flags, SLE_UINT8),
 	SLE_VAR(Order, dest,  SLE_UINT16),
 	SLE_REF(Order, next,  REF_ORDER),
 	/* Leftover from the minor savegame version stuff
 	 * 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()
 };
+	return _order_desc;
+}
 static void Save_ORDR()
 {
 	Order *order;
 	FOR_ALL_ORDERS(order) {
 		SlSetArrayIndex(order->index);
-		SlObject(order, _order_desc);
+		SlObject(order, GetOrderDescription());
 	}
 }
 static void Load_ORDR()
 {
 	} else {
 		int index;
 		while ((index = SlIterateArray()) != -1) {
 			Order *order = new (index) Order();
-			SlObject(order, _order_desc);
+			SlObject(order, GetOrderDescription());
 		}
 	}
 }
 extern const ChunkHandler _order_chunk_handlers[] = {

changeset 8836	f6f1ea3d7e93
parent 8835	8fa962d90b63
child 8838	068d63397dc3