openttd-ottdgrfs: comparison src/station

equal deleted inserted replaced

-:0b2aebc8283e
+:0b8b245a2391
 		do {
 			TileIndex tile = tile_org;
 			int w = plat_len;
 			do {
 				byte layout = *layout_ptr++;
-				MakeRailStation(tile, st->owner, st->index, axis, layout, (RailType)GB(p2, 0, 4));
+				MakeRailStation(tile, st->owner, st->index, axis, layout & ~1, (RailType)GB(p2, 0, 4));
 				SetCustomStationSpecIndex(tile, specindex);
 				SetStationTileRandomBits(tile, GB(Random(), 0, 4));
 				if (statspec != NULL) {
 					/* Use a fixed axis for GetPlatformInfo as our platforms / numtracks are always the right way around */
 					uint32 platinfo = GetPlatformInfo(AXIS_X, 0, plat_len, numtracks_orig, plat_len - w, numtracks_orig - numtracks, false);
 					uint16 callback = GetStationCallback(CBID_STATION_TILE_LAYOUT, platinfo, 0, statspec, st, tile);
-					if (callback != CALLBACK_FAILED && callback < 8) SetStationGfx(tile, callback + axis);
+					if (callback != CALLBACK_FAILED && callback < 8) SetStationGfx(tile, (callback & ~1) + axis);
 				}
 				tile += tile_delta;
 			} while (--w);
 			SetSignalsOnBothDir(tile_org, track);
 /** Remove a single tile from a railroad station.
 * This allows for custom-built station with holes and weird layouts
 * @param tile tile of station piece to remove
 * @param flags operation to perform
-* @param p1 unused
+* @param p1 start_tile
 * @param p2 unused
 */
 int32 CmdRemoveFromRailroadStation(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
+	TileIndex start = p1 == 0 ? tile : p1;
+	/* Count of the number of tiles removed */
+	int quantity = 0;
+	if (tile >= MapSize() || start >= MapSize()) return CMD_ERROR;
+	/* make sure sx,sy are smaller than ex,ey */
+	int ex = TileX(tile);
+	int ey = TileY(tile);
+	int sx = TileX(start);
+	int sy = TileY(start);
+	if (ex < sx) Swap(ex, sx);
+	if (ey < sy) Swap(ey, sy);
+	tile = TileXY(sx, sy);
+	int size_x = ex - sx + 1;
+	int size_y = ey - sy + 1;
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
-	// make sure the specified tile belongs to the current player, and that it is a railroad station.
+	/* Do the action for every tile into the area */
-	if (!IsTileType(tile, MP_STATION) || !IsRailwayStation(tile) || !_patches.nonuniform_stations) return CMD_ERROR;
+	BEGIN_TILE_LOOP(tile2, size_x, size_y, tile) {
-	Station *st = GetStationByTile(tile);
+		/* Make sure the specified tile belongs to the current player, and that it is a railroad station. */
-	if (_current_player != OWNER_WATER && (!CheckOwnership(st->owner) || !EnsureNoVehicle(tile))) return CMD_ERROR;
+		if (!IsTileType(tile2, MP_STATION) || !IsRailwayStation(tile2) || !_patches.nonuniform_stations) {
+			continue;
-	// if we reached here, it means we can actually delete it. do that.
+		}
-	if (flags & DC_EXEC) {
-		uint specindex = GetCustomStationSpecIndex(tile);
+		/* Check ownership of station */
-		Track track = GetRailStationTrack(tile);
+		Station *st = GetStationByTile(tile2);
-		DoClearSquare(tile);
+		if (_current_player != OWNER_WATER && (!CheckOwnership(st->owner) || !EnsureNoVehicle(tile2))) {
-		st->rect.AfterRemoveTile(st, tile);
+			continue;
-		SetSignalsOnBothDir(tile, track);
+		}
-		YapfNotifyTrackLayoutChange(tile, track);
+		/* If we reached here, the tile is valid so increase the quantity of tiles we will remove */
-		DeallocateSpecFromStation(st, specindex);
+		quantity++;
-		// now we need to make the "spanned" area of the railway station smaller if we deleted something at the edges.
+		if (flags & DC_EXEC) {
-		// we also need to adjust train_tile.
+			uint specindex = GetCustomStationSpecIndex(tile2);
-		MakeRailwayStationAreaSmaller(st);
+			Track track = GetRailStationTrack(tile2);
-		st->MarkTilesDirty();
+			DoClearSquare(tile2);
-		UpdateStationSignCoord(st);
+			st->rect.AfterRemoveTile(st, tile2);
+			SetSignalsOnBothDir(tile2, track);
-		// if we deleted the whole station, delete the train facility.
+			YapfNotifyTrackLayoutChange(tile2, track);
-		if (st->train_tile == 0) {
-			st->facilities &= ~FACIL_TRAIN;
+			DeallocateSpecFromStation(st, specindex);
-			UpdateStationVirtCoordDirty(st);
-			DeleteStationIfEmpty(st);
+			// now we need to make the "spanned" area of the railway station smaller if we deleted something at the edges.
-		}
+			// we also need to adjust train_tile.
-	}
+			MakeRailwayStationAreaSmaller(st);
-	return _eco->GetPrice(CEconomy::REMOVE_RAIL_STATION);
+			st->MarkTilesDirty();
+			UpdateStationSignCoord(st);
+			// if we deleted the whole station, delete the train facility.
+			if (st->train_tile == 0) {
+				st->facilities &= ~FACIL_TRAIN;
+				UpdateStationVirtCoordDirty(st);
+				DeleteStationIfEmpty(st);
+			}
+		}
+	} END_TILE_LOOP(tile2, size_x, size_y, tile)
+	/* If we've not removed any tiles, give an error */
+	if (quantity == 0) return CMD_ERROR;
+	return _eco->GetPrice(CEconomy::REMOVE_RAIL_STATION) * quantity;
 }
 static int32 RemoveRailroadStation(Station *st, TileIndex tile, uint32 flags)
 {
 * @param tile tile to build the stop at
 * @param flags operation to perform
 * @param p1 entrance direction (DiagDirection)
 * @param p2 bit 0: 0 for Bus stops, 1 for truck stops
 *           bit 1: 0 for normal, 1 for drive-through
+*           bit 2..4: the roadtypes
 */
 int32 CmdBuildRoadStop(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	bool type = HASBIT(p2, 0);
 	bool is_drive_through = HASBIT(p2, 1);
 	bool build_over_road  = is_drive_through && IsTileType(tile, MP_STREET) && GetRoadTileType(tile) == ROAD_TILE_NORMAL;
 	bool town_owned_road  = build_over_road && IsTileOwner(tile, OWNER_TOWN);
 	Owner cur_owner = _current_player;
+	RoadTypes rts = (RoadTypes)GB(p2, 2, 3);
+	if (rts == ROADTYPES_NONE || HASBIT(rts, ROADTYPE_HWAY)) return CMD_ERROR;
 	/* Saveguard the parameters */
 	if (!IsValidDiagDirection((DiagDirection)p1)) return CMD_ERROR;
 	/* If it is a drive-through stop check for valid axis */
 	if (is_drive_through && !IsValidAxis((Axis)p1)) return CMD_ERROR;
 	/* Road bits in the wrong direction */
-	if (build_over_road && (GetRoadBits(tile) & ((Axis)p1 == AXIS_X ? ROAD_Y : ROAD_X)) != 0) return_cmd_error(STR_DRIVE_THROUGH_ERROR_DIRECTION);
+	if (build_over_road && (GetAllRoadBits(tile) & ((Axis)p1 == AXIS_X ? ROAD_Y : ROAD_X)) != 0) return_cmd_error(STR_DRIVE_THROUGH_ERROR_DIRECTION);
 	/* Not allowed to build over this road */
 	if (build_over_road) {
 		if (IsTileOwner(tile, OWNER_TOWN) && !_patches.road_stop_on_town_road) return_cmd_error(STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD);
-		if (!IsTileOwner(tile, OWNER_TOWN) && !CheckOwnership(GetTileOwner(tile))) return CMD_ERROR;
+		if (GetRoadTileType(tile) != ROAD_TILE_NORMAL) return CMD_ERROR;
+		if (!IsTileOwner(tile, OWNER_TOWN) && !CheckOwnership(GetRoadOwner(tile, ROADTYPE_ROAD)) && !CheckOwnership(GetRoadOwner(tile, ROADTYPE_TRAM))) return CMD_ERROR;
+		/* Do not remove roadtypes! */
+		if (rts != GetRoadTypes(tile) && rts != ROADTYPES_ROADTRAM) return CMD_ERROR;
 	}
 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
 	if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile))
 		st->rect.BeforeAddTile(tile, StationRect::ADD_TRY);
 		RoadStop::Type rs_type = type ? RoadStop::TRUCK : RoadStop::BUS;
 		if (is_drive_through) {
-			MakeDriveThroughRoadStop(tile, st->owner, st->index, rs_type, (Axis)p1, town_owned_road);
+			MakeDriveThroughRoadStop(tile, st->owner, st->index, rs_type, rts, (Axis)p1, town_owned_road);
 		} else {
-			MakeRoadStop(tile, st->owner, st->index, rs_type, (DiagDirection)p1);
+			MakeRoadStop(tile, st->owner, st->index, rs_type, rts, (DiagDirection)p1);
 		}
 		UpdateStationVirtCoordDirty(st);
 		UpdateStationAcceptance(st, false);
 		RebuildStationLists();
 	/* Make sure the specified tile is a road stop of the correct type */
 	if (!IsTileType(tile, MP_STATION) || !IsRoadStop(tile) || (uint32)GetRoadStopType(tile) != p2) return CMD_ERROR;
 	Station *st = GetStationByTile(tile);
 	/* Save the stop info before it is removed */
 	bool is_drive_through = IsDriveThroughStopTile(tile);
-	RoadBits road_bits = GetAnyRoadBits(tile);
+	RoadTypes rts = GetRoadTypes(tile);
+	RoadBits road_bits = IsDriveThroughStopTile(tile) ?
+			((GetRoadStopDir(tile) == DIAGDIR_NE) ? ROAD_X : ROAD_Y) :
+			DiagDirToRoadBits(GetRoadStopDir(tile));
 	bool is_towns_road = is_drive_through && GetStopBuiltOnTownRoad(tile);
 	int32 ret = RemoveRoadStop(st, flags, tile);
 	/* If the stop was a drive-through stop replace the road */
 		if (is_towns_road) {
 			index = ClosestTownFromTile(tile, (uint)-1)->index;
 			_current_player = OWNER_TOWN;
 		}
-		DoCommand(tile, road_bits, index, DC_EXEC, CMD_BUILD_ROAD);
+		if (HASBIT(rts, ROADTYPE_ROAD)) {
+			DoCommand(tile, ROADTYPE_ROAD << 4 | road_bits, index, DC_EXEC, CMD_BUILD_ROAD);
+		}
+		if (HASBIT(rts, ROADTYPE_TRAM)) {
+			DoCommand(tile, ROADTYPE_TRAM << 4 | road_bits, index, DC_EXEC, CMD_BUILD_ROAD);
+		}
 		_current_player = cur_owner;
 	}
 	return ret;
 }
 {
 	/* The road can always be cleared if it was not a town-owned road */
 	if (!GetStopBuiltOnTownRoad(tile)) return true;
 	bool edge_road;
-	return CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile), OWNER_TOWN, &edge_road);
+	return CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile, ROADTYPE_ROAD), OWNER_TOWN, &edge_road, ROADTYPE_ROAD) &&
+				CheckAllowRemoveRoad(tile, GetAnyRoadBits(tile, ROADTYPE_TRAM), OWNER_TOWN, &edge_road, ROADTYPE_TRAM);
 }
 static int32 ClearTile_Station(TileIndex tile, byte flags)
 {
 	if (flags & DC_AUTO) {

branch	gamebalance
changeset 9911	0b8b245a2391
parent 9910	0b2aebc8283e
child 9912	1ac8aac92385