openttd-mini: comparison order

equal deleted inserted replaced

-:a4ba0fbbf018
+:02df8a1b7f33
 */
 int32 CmdInsertOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v = &_vehicles[p1 & 0xFFFF];
 	int sel = p1 >> 16;
-	int t;
+	Order new_order = UnpackOrder(p2);
 	if (sel > v->num_orders) return_cmd_error(STR_EMPTY);
 	if (_ptr_to_next_order == endof(_order_array)) return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);
 	if (v->num_orders >= 40) return_cmd_error(STR_8832_TOO_MANY_ORDERS);
 	// for ships, make sure that the station is not too far away from the previous destination.
 	if (v->type == VEH_Ship && IS_HUMAN_PLAYER(v->owner) &&
-			sel != 0 && ((t=v->schedule_ptr[sel-1])&OT_MASK) == OT_GOTO_STATION) {
+			sel != 0 && v->schedule_ptr[sel - 1].type == OT_GOTO_STATION) {
-		int dist = GetTileDist(DEREF_STATION(t >> 8)->xy, DEREF_STATION(p2 >> 8)->xy);
+		int dist = GetTileDist(
+			DEREF_STATION(v->schedule_ptr[sel - 1].station)->xy,
+			DEREF_STATION(new_order.station)->xy
+		);
 		if (dist >= 130)
 			return_cmd_error(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO);
 	}
 	if (flags & DC_EXEC) {
-		uint16 *s1, *s2;
+		Order *s1;
+		Order *s2;
 		Vehicle *u;
 		s1 = &v->schedule_ptr[sel];
 		s2 = _ptr_to_next_order++;
 		do s2[1] = s2[0]; while (--s2 >= s1);
-		s1[0] = (uint16)p2;
+		*s1 = new_order;
 		s1 = v->schedule_ptr;
 		FOR_ALL_VEHICLES(u) {
 			if (u->type != 0 && u->schedule_ptr != NULL) {
 	if (flags & DC_EXEC) {
 		DeleteVehicleSchedule(dst);
 		dst->num_orders = 0;
-		*(dst->schedule_ptr = _ptr_to_next_order++) = 0;
+		_ptr_to_next_order->type = OT_NOTHING;
+		_ptr_to_next_order->flags = 0;
+		dst->schedule_ptr = _ptr_to_next_order++;
 		InvalidateWindow(WC_VEHICLE_ORDERS, dst->index);
 	}
 	return 0;
 }
 	_error_message = STR_EMPTY;
 	if (sel >= v->num_orders)
 		return DecloneOrder(v, flags);
 	if (flags & DC_EXEC) {
-		uint16 *s1;
+		Order *s1 = &v->schedule_ptr[sel];
-		s1 = &v->schedule_ptr[sel];
 		// copy all orders to get rid of the hole
 		do s1[0] = s1[1]; while (++s1 != _ptr_to_next_order);
 		_ptr_to_next_order--;
 				} else if (s1 == u->schedule_ptr) {// handle shared orders
 					u->num_orders--;
 					if ((byte)sel < u->cur_order_index)
 						u->cur_order_index--;
-					if ((byte)sel == u->cur_order_index && (u->next_order&(OT_MASK|OF_NON_STOP)) == (OT_LOADING|OF_NON_STOP))
+					if ((byte)sel == u->cur_order_index &&
-						u->next_order = OT_LOADING;
+							u->current_order.type == OT_LOADING &&
+							u->current_order.flags & OF_NON_STOP) {
+						u->current_order.flags = 0;
+					}
 					InvalidateWindow(WC_VEHICLE_VIEW, u->index);
 					InvalidateWindow(WC_VEHICLE_ORDERS, u->index);
 				}
 			}
 			if (v->type == VEH_Train)
 				v->u.rail.days_since_order_progr = 0;
 		}
-		if ((v->next_order&(OT_MASK|OF_NON_STOP)) == (OT_LOADING|OF_NON_STOP))
+		if (v->current_order.type == OT_LOADING &&
-			v->next_order = OT_LOADING;
+				v->current_order.flags & OF_NON_STOP) {
+			v->current_order.flags = 0;
+		}
 		InvalidateWindow(WC_VEHICLE_ORDERS, v->index);
 	}
 	return 0;
 }
 */
 int32 CmdModifyOrder(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v = &_vehicles[p1];
 	byte sel = (byte)p2;
-	uint16 *sched;
+	Order *sched;
 	if (sel >= v->num_orders)
 		return CMD_ERROR;
 	sched = &v->schedule_ptr[sel];
-	if (!((*sched & OT_MASK) == OT_GOTO_STATION ||
+	if (sched->type != OT_GOTO_STATION &&
-			((*sched & OT_MASK) == OT_GOTO_DEPOT &&  (p2>>8) != 1)))
+			(sched->type != OT_GOTO_DEPOT || (p2 >> 8) == 1))
 		return CMD_ERROR;
 	if (flags & DC_EXEC) {
-		switch(p2 >> 8) {
+		switch (p2 >> 8) {
 		case 0: // full load
-			*sched ^= OF_FULL_LOAD;
+			sched->flags ^= OF_FULL_LOAD;
-			if ((*sched & OT_MASK) != OT_GOTO_DEPOT)
+			if (sched->type != OT_GOTO_DEPOT) sched->flags &= ~OF_UNLOAD;
-				*sched &= ~OF_UNLOAD;
 			break;
 		case 1: // unload
-			*sched ^= OF_UNLOAD;
+			sched->flags ^= OF_UNLOAD;
-			*sched &= ~OF_FULL_LOAD;
+			sched->flags &= ~OF_FULL_LOAD;
 			break;
 		case 2: // non stop
-			*sched ^= OF_NON_STOP;
+			sched->flags ^= OF_NON_STOP;
 			break;
 		}
 		sched = v->schedule_ptr;
 		FOR_ALL_VEHICLES(v) {
 		if (!(src->owner == _current_player && dst->type == src->type && dst != src))
 			return CMD_ERROR;
 		// let's see what happens with road vehicles
 		if (src->type == VEH_Road) {
-			uint16 ord;
+			const Order *i;
-			int i;
-			Station *st;
 			TileIndex required_dst;
-			for (i=0; (ord = src->schedule_ptr[i]) != 0; i++) {
+			for (i = src->schedule_ptr; i->type != OT_NOTHING; ++i) {
-				if ( ( ord & OT_MASK ) == OT_GOTO_STATION ) {
+				if (i->type == OT_GOTO_STATION) {
-					st = DEREF_STATION(ord >> 8);
+					const Station *st = DEREF_STATION(i->station);
 					required_dst = (dst->cargo_type == CT_PASSENGERS) ? st->bus_tile : st->lorry_tile;
 					if ( !required_dst )
 						return CMD_ERROR;
 				}
 			}
 }
 void BackupVehicleOrders(Vehicle *v, BackuppedOrders *bak)
 {
 	Vehicle *u = IsScheduleShared(v);
-	uint16 *sched, ord, *os;
 	bak->orderindex = v->cur_order_index;
 	bak->service_interval = v->service_interval;
 	if ((v->string_id & 0xF800) != 0x7800) {
 		bak->name[0] = 0;
 	} else {
 		GetName(v->string_id & 0x7FF, bak->name);
 	}
-	os = bak->order;
 	// stored shared orders in this special way?
-	if (u) {
+	if (u != NULL) {
-		os[0] = 0xFFFF;
+		bak->clone = u->index;
-		os[1] = u->index;
+	} else {
-		return;
+		Order *sched = v->schedule_ptr;
-	}
+		Order *os = bak->order;
-	sched = v->schedule_ptr;
+		bak->clone = INVALID_VEHICLE;
-	do {
-		ord = *sched++;
+		do {
-		*os++ = ord;
+			*os++ = *sched++;
-	} while (ord != 0);
+		} while (sched->type != OT_NOTHING);
+	}
 }
 void RestoreVehicleOrders(Vehicle *v, BackuppedOrders *bak)
 {
-	uint16 ord, *os;
+	int i;
-	int ind;
 	if (bak->name[0]) {
 		strcpy((char*)_decode_parameters, bak->name);
 		DoCommandP(0, v->index, 0, NULL, CMD_NAME_VEHICLE);
 	}
 	DoCommandP(0, v->index, bak->orderindex|(bak->service_interval<<16) , NULL, CMD_RESTORE_ORDER_INDEX);
-	os = bak->order;
+	if (bak->clone != INVALID_VEHICLE) {
-	if (os[0] == 0xFFFF) {
+		DoCommandP(0, v->index | bak->clone << 16, 0, NULL, CMD_CLONE_ORDER);
-		DoCommandP(0, v->index | os[1]<<16, 0, NULL, CMD_CLONE_ORDER);
 		return;
 	}
 	// CMD_NO_TEST_IF_IN_NETWORK is used here, because CMD_INSERT_ORDER checks if the
 	//  order number is one more then 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.
-	ind = 0;
+	for (i = 0; bak->order[i].type != OT_NOTHING; ++i)
-	while ((ord = *os++) != 0) {
+		if (!DoCommandP(0, v->index + (i << 16), PackOrder(&bak->order[i]), NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK))
-		if (!DoCommandP(0, v->index + (ind << 16), ord, NULL, CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK))
 			break;
-		ind++;
-	}
 }
 /*	p1 = vehicle
 *	upper 16 bits p2 = service_interval
 *	lower 16 bits p2 = cur_order_index
 	if ( (_patches.order_review_system == 1) && (v->vehstatus & VS_STOPPED) )
 		return 0;
 	/* only check every 20 days, so that we don't flood the message log */
 	if ( ( ( v->day_counter % 20) == 0 ) && (v->owner == _local_player) ) {
+		Order order;
-		uint16 order, old_order;
+		Order old_order;
 		int i, n_st, problem_type = -1;
 		Station *st;
 		int message=0;
 		TileIndex required_tile=-1;
 		/* check the order list */
 		order = v->schedule_ptr[0];
 		n_st = 0;
-		for (old_order = i = 0; order!=0; i++ ) {
+		old_order.type = OT_NOTHING;
+		old_order.flags = 0;
+		for (i = 0; order.type != OT_NOTHING; i++) {
 			order = v->schedule_ptr[i];
-			if (order == old_order) {
+			if (order.type == old_order.type &&
+					order.flags == old_order.flags &&
+					order.station == old_order.station) {
 				problem_type = 2;
 				break;
 			}
-			if ( (order & OT_MASK) == OT_DUMMY ) {
+			if (order.type == OT_DUMMY) {
 				problem_type = 1;
 				break;
 			}
-			if ( ( (order & OT_MASK) == OT_GOTO_STATION ) /*&& (order != old_order) */) {
+			if (order.type == OT_GOTO_STATION /*&& (order != old_order) */) {
 				//I uncommented this in order not to get two error messages
 				//when two identical entries are in the list
 				n_st++;
-				st = DEREF_STATION(order >> 8);
+				st = DEREF_STATION(order.station);
 				required_tile = GetStationTileForVehicle(v,st);
 				if (!required_tile) problem_type = 3;
 			}
 			old_order = order; //store the old order
 		}
 		//Now, check the last and the first order
 		//as the last order is the end of order marker, jump back 2
-		if ( (v->schedule_ptr[0] == v->schedule_ptr[i-2]) && ( i-2 != 0 ) ) {
+		if (i > 2 &&
+				v->schedule_ptr[0].type == v->schedule_ptr[i - 2].type &&
+				v->schedule_ptr[0].flags == v->schedule_ptr[i - 2].flags &&
+				v->schedule_ptr[0].station == v->schedule_ptr[i - 2].station)
 			problem_type = 2;
-		}
 		if ( (n_st < 2) && (problem_type == -1) ) problem_type = 0;
 		SetDParam(0, v->unitnumber);

changeset 555	02df8a1b7f33
parent 543	946badd71033
child 588	03521b270f62