7 #include "ai_list.hpp"

    13 #include "../../settings_type.h"

    14 #include "../../squirrel_helper_type.hpp"

    85 

    86 /* Helper functions for AIRoad::CanBuildConnectedRoadParts(). */

    87 

    88 /**

    89  * Check whether the given existing bits the start and end part can be build.

    90  *  As the function assumes the bits being build on a slope that does not

    91  *  allow level foundations all of the existing parts will always be in

    92  *  a straight line. This also needs to hold for the start and end parts,

    93  *  otherwise it is for sure not valid. Finally a check will be done to

    94  *  determine whether the existing road parts match the to-be-build parts.

    95  *  As they can only be placed in one direction, just checking the start

    96  *  part with the first existing part is enough.

    97  * @param existing The existing road parts.

    98  * @param start The part that should be build first.

    99  * @param end The part that will be build second.

   100  * @return True if and only if the road bits can be build.

   101  */

   102 static bool CheckAutoExpandedRoadBits(const Array *existing, int32 start, int32 end)

   103 {

   104 	return (start + end == 0) && (existing->size == 0 || existing->array[0] == start || existing->array[0] == end);

   105 }

   106 

   107 /**

   108  * Lookup function for building road parts when building on slopes is disabled.

   109  * @param slope The slope of the tile to examine.

   110  * @param existing The existing road parts.

   111  * @param start The part that should be build first.

   112  * @param end The part that will be build second.

   113  * @return 0 when the build parts do not connect, 1 when they do connect once

   114  *         they are build or 2 when building the first part automatically

   115  *         builds the second part.

   116  */

   117 static int32 LookupWithoutBuildOnSlopes(::Slope slope, const Array *existing, int32 start, int32 end)

   118 {

   119 	switch (slope) {

   120 		/* Flat slopes can always be build. */

   121 		case SLOPE_FLAT:

   122 			return 1;

   123 

   124 		/* Only 4 of the slopes can be build upon. Testing the existing bits is

   125 		 * necessary because these bits can be something else when the settings

   126 		 * in the game have been changed.

   127 		 */

   128 		case SLOPE_NE: case SLOPE_SW:

   129 			return (CheckAutoExpandedRoadBits(existing, start, end) && (start == 1 || end == 1)) ? (existing->size == 0 ? 2 : 1) : 0;

   130 		case SLOPE_SE: case SLOPE_NW:

   131 			return (CheckAutoExpandedRoadBits(existing, start, end) && (start != 1 && end != 1)) ? (existing->size == 0 ? 2 : 1) : 0;

   132 

   133 		/* Any other tile cannot be built on. */

   134 		default:

   135 			return 0;

   136 	}

   137 }

   138 

   139 /**

   140  * Rotate a neighbour bit a single time clockwise.

   141  * @param neighbour The neighbour.

   142  * @return The rotate neighbour data.

   143  */

   144 static int32 RotateNeighbour(int32 neighbour)

   145 {

   146 	switch (neighbour) {

   147 		case -2: return -1;

   148 		case -1: return  2;

   149 		case  1: return -2;

   150 		case  2: return  1;

   151 		default: NOT_REACHED();

   152 	}

   153 }

   154 

   155 /**

   156  * Convert a neighbour to a road bit representation for easy internal use.

   157  * @param neighbour The neighbour.

   158  * @return The bits representing the direction.

   159  */

   160 static RoadBits NeighbourToRoadBits(int32 neighbour)

   161 {

   162 	switch (neighbour) {

   163 		case -2: return ROAD_NW;

   164 		case -1: return ROAD_NE;

   165 		case  2: return ROAD_SE;

   166 		case  1: return ROAD_SW;

   167 		default: NOT_REACHED();

   168 	}

   169 }

   170 

   171 /**

   172  * Lookup function for building road parts when building on slopes is enabled.

   173  * @param slope The slope of the tile to examine.

   174  * @param existing The existing neighbours.

   175  * @param start The part that should be build first.

   176  * @param end The part that will be build second.

   177  * @return 0 when the build parts do not connect, 1 when they do connect once

   178  *         they are build or 2 when building the first part automatically

   179  *         builds the second part.

   180  */

   181 static int32 LookupWithBuildOnSlopes(::Slope slope, Array *existing, int32 start, int32 end)

   182 {

   183 	if (::IsSteepSlope(slope)) {

   184 		switch (slope) {

   185 			/* On steep slopes one can only build straight roads that will be

   186 			 * automatically expanded to a straight road. Just check that the existing

   187 			 * road parts are in the same direction. */

   188 			case SLOPE_STEEP_S:

   189 			case SLOPE_STEEP_W:

   190 			case SLOPE_STEEP_N:

   191 			case SLOPE_STEEP_E:

   192 				return CheckAutoExpandedRoadBits(existing, start, end) ? (existing->size == 0 ? 2 : 1) : 0;

   193 

   194 			/* All other slopes are invalid slopes!. */

   195 			default:

   196 				return -1;

   197 		}

   198 	}

   199 

   200 	/* The slope is not steep. Furthermore lots of slopes are generally the

   201 	 * same but are only rotated. So to reduce the amount of lookup work that

   202 	 * needs to be done the data is made uniform. This means rotating the

   203 	 * existing parts and updating the slope. */

   204 	static const ::Slope base_slopes[] = {

   205 		SLOPE_FLAT, SLOPE_W,   SLOPE_W,   SLOPE_SW,

   206 		SLOPE_W,    SLOPE_EW,  SLOPE_SW,  SLOPE_WSE,

   207 		SLOPE_W,    SLOPE_SW,  SLOPE_EW,  SLOPE_WSE,

   208 		SLOPE_SW,   SLOPE_WSE, SLOPE_WSE};

   209 	static const byte base_rotates[] = {0, 0, 1, 0, 2, 0, 1, 0, 3, 3, 2, 3, 2, 2, 1};

   210 

   211 	if (slope >= (::Slope)lengthof(base_slopes)) {

   212 		/* This slope is an invalid slope, so ignore it. */

   213 		return -1;

   214 	}

   215 	byte base_rotate = base_rotates[slope];

   216 	slope = base_slopes[slope];

   217 

   218 	/* Some slopes don't need rotating, so return early when we know we do

   219 	 * not need to rotate. */

   220 	switch (slope) {

   221 		case SLOPE_FLAT:

   222 			/* Flat slopes can always be build. */

   223 			return 1;

   224 

   225 		case SLOPE_EW:

   226 		case SLOPE_WSE:

   227 			/* A slope similar to a SLOPE_EW or SLOPE_WSE will always cause

   228 			 * foundations which makes them accessible from all sides. */

   229 			return 1;

   230 

   231 		case SLOPE_W:

   232 		case SLOPE_SW:

   233 			/* A slope for which we need perform some calculations. */

   234 			break;

   235 

   236 		default:

   237 			/* An invalid slope. */

   238 			return -1;

   239 	}

   240 

   241 	/* Now perform the actual rotation. */

   242 	for (int j = 0; j < base_rotate; j++) {

   243 		for (int i = 0; i < existing->size; i++) {

   244 			existing->array[i] = RotateNeighbour(existing->array[i]);

   245 		}

   246 		start = RotateNeighbour(start);

   247 		end   = RotateNeighbour(end);

   248 	}

   249 

   250 	/* Create roadbits out of the data for easier handling. */

   251 	RoadBits start_roadbits    = NeighbourToRoadBits(start);

   252 	RoadBits new_roadbits      = start_roadbits | NeighbourToRoadBits(end);

   253 	RoadBits existing_roadbits = ROAD_NONE;

   254 	for (int i = 0; i < existing->size; i++) {

   255 		existing_roadbits |= NeighbourToRoadBits(existing->array[i]);

   256 	}

   257 

   258 	switch (slope) {

   259 		case SLOPE_W:

   260 			/* A slope similar to a SLOPE_W. */

   261 			switch (new_roadbits) {

   262 				case  6: // ROAD_SE | ROAD_SW:

   263 				case  9: // ROAD_NE | ROAD_NW:

   264 				case 12: // ROAD_NE | ROAD_SE:

   265 					/* Cannot build anything with a turn from the low side. */

   266 					return 0;

   267 

   268 				case  5: // ROAD_SE | ROAD_NW:

   269 				case 10: // ROAD_NE | ROAD_SW:

   270 					/* A 'sloped' tile is going to be build. */

   271 					if ((existing_roadbits | new_roadbits) != new_roadbits) {

   272 						/* There is already a foundation on the tile, or at least

   273 						 * another slope that is not compatible with the new one. */

   274 						return 0;

   275 					}

   276 					/* If the start is in the low part, it is automatically

   277 					 * building the second part too. */

   278 					return ((start_roadbits & (ROAD_NE | ROAD_SE)) && !(existing_roadbits & (ROAD_SW | ROAD_NW))) ? 2 : 1;

   279 

   280 				default:

   281 					/* Roadbits causing a foundation are going to be build.

   282 					 * When the existing roadbits are slopes (the lower bits

   283 					 * are used), this cannot be done. */

   284 					if ((existing_roadbits | new_roadbits) == new_roadbits) return 1;

   285 					return (existing_roadbits & (ROAD_NE | ROAD_SE)) ? 0 : 1;

   286 			}

   287 

   288 		case SLOPE_SW:

   289 			/* A slope similar to a SLOPE_SW. */

   290 			switch (new_roadbits) {

   291 				case  9: // ROAD_NE | ROAD_NW:

   292 				case 12: // ROAD_NE | ROAD_SE:

   293 					/* Cannot build anything with a turn from the low side. */

   294 					return 0;

   295 

   296 				case 10: // ROAD_NE | ROAD_SW:

   297 					/* A 'sloped' tile is going to be build. */

   298 					if ((existing_roadbits | new_roadbits) != new_roadbits) {

   299 						/* There is already a foundation on the tile, or at least

   300 						 * another slope that is not compatible with the new one. */

   301 						return 0;

   302 					}

   303 					/* If the start is in the low part, it is automatically

   304 					 * building the second part too. */

   305 					return ((start_roadbits & ROAD_NE) && !(existing_roadbits & ROAD_SW)) ? 2 : 1;

   306 

   307 				default:

   308 					/* Roadbits causing a foundation are going to be build.

   309 					 * When the existing roadbits are slopes (the lower bits

   310 					 * are used), this cannot be done. */

   311 					return (existing_roadbits & ROAD_NE) ? 0 : 1;

   312 			}

   313 

   314 		default:

   315 			NOT_REACHED();

   316 	}

   317 }

   318 

   319 /**

   320  * Normalise all input data so we can easily handle it without needing

   321  * to call the API lots of times or create large if-elseif-elseif-else

   322  * constructs.

   323  * In this case it means that a TileXY(0, -1) becomes -2 and TileXY(0, 1)

   324  * becomes 2. TileXY(-1, 0) and TileXY(1, 0) stay respectively -1 and 1.

   325  * Any other value means that it is an invalid tile offset.

   326  * @param tile The tile to normalise.

   327  * @return True if and only if the tile offset is valid.

   328  */

   329 static bool NormaliseTileOffset(int32 *tile)

   330 {

   331 		if (*tile == 1 || *tile == -1) return true;

   332 		if (*tile == ::TileDiffXY(0, -1)) {

   333 			*tile = -2;

   334 			return true;

   335 		}

   336 		if (*tile == ::TileDiffXY(0, 1)) {

   337 			*tile = 2;

   338 			return true;

   339 		}

   340 		return false;

   341 }

   342 

   343 /* static */ int32 AIRoad::CanBuildConnectedRoadParts(AITile::Slope slope_, Array *existing, TileIndex start_, TileIndex end_)

   344 {

   345 	::Slope slope = (::Slope)slope_;

   346 	int32 start = start_;

   347 	int32 end = end_;

   348 

   349 	/* The start tile and end tile cannot be the same tile either. */

   350 	if (start == end) return -1;

   351 

   352 	for (int i = 0; i < existing->size; i++) {

   353 		if (!NormaliseTileOffset(&existing->array[i])) return -1;

   354 	}

   355 

   356 	if (!NormaliseTileOffset(&start)) return -1;

   357 	if (!NormaliseTileOffset(&end)) return -1;

   358 

   359 	/* Without build on slopes the characteristics are vastly different, so use

   360 	 * a different helper function (one that is much simpler). */

   361 	return _settings_game.construction.build_on_slopes ? LookupWithBuildOnSlopes(slope, existing, start, end) : LookupWithoutBuildOnSlopes(slope, existing, start, end);

   362 }

   363 

   364 /* static */ int32 AIRoad::CanBuildConnectedRoadPartsHere(TileIndex tile, TileIndex start, TileIndex end)

   365 {

   366 	if (!::IsValidTile(tile) || !::IsValidTile(start) || !::IsValidTile(end)) return -1;

   367 	if (::DistanceManhattan(tile, start) != 1 || ::DistanceManhattan(tile, end) != 1) return -1;

   368 

   369 	static const TileIndex neighbours[] = {::TileDiffXY(-1, 0), ::TileDiffXY(1, 0), ::TileDiffXY(0, -1), ::TileDiffXY(0, 1)};

   370 	Array *existing = (Array*)alloca(sizeof(Array) + lengthof(neighbours) * sizeof(int32));

   371 	existing->size = 0;

   372 

   373 	for (uint i = 0; i < lengthof(neighbours); i++) {

   374 		if (AIRoad::AreRoadTilesConnected(tile, tile + neighbours[i])) existing->array[existing->size++] = neighbours[i];

   375 	}

   376 

   377 	return AIRoad::CanBuildConnectedRoadParts(AITile::GetSlope(tile), existing, start - tile, end - tile);

   378 }

   379