21 #include "town.h"

    32 #include "newgrf_house.h"

    36 #include "table/town_land.h"

    73 

    74 /* Set if there are any newhouses loaded. */

    75 bool _have_newhouses = false;

   236 /** Used when setting an object's property to map to the GRF's strings

   237  * while taking in consideration the "drift" between TTDPatch string system and OpenTTD's one

   238  * @param str StringID that we want to have the equivalent in OoenTTD

   239  * @return the properly adjusted StringID

   240  */

   241 static StringID MapGRFStringID(StringID str)

   242 {

   243 	/* 0xD0 and 0xDC stand for all the TextIDs in the range

   244 	*  of 0xD000 (misc graphics texts) and 0xDC00 (misc persistent texts).

   245 	 * These strings are unique to each grf file, and thus require to be used with the

   246 	 * grfid in which they are declared */

   247 	if (GB(str, 8, 8) == 0xD0 || GB(str, 8, 8) == 0xDC) {

   248 		return GetGRFStringID(_cur_grffile->grfid, str);

   249 	}

   250 

   251 	/* Map building names according to our lang file changes

   252 	 * 0x200F = Tall Office Block, first house name in the original data, the one that TTDPatch stil uses

   253 	 * 0x201F = Old houses is the last house name.

   254 	 * OpenTTD does not have exactly the same order aymore, so, the code below allows

   255 	 * to compensate for the difference */

   256 	if (str >= 0x200F && str <= 0x201F) return str + (STR_200F_TALL_OFFICE_BLOCK - 0x200F);

   257 

   258 	return str;

   259 }

   260 

   261 

  1203 static bool TownHouseChangeInfo(uint hid, int numinfo, int prop, byte **bufp, int len)

  1204 {

  1205 	HouseSpec **housespec;

  1206 	byte *buf = *bufp;

  1207 	int i;

  1208 	bool ret = false;

  1209 

  1210 	if (hid + numinfo >= HOUSE_MAX) {

  1211 		grfmsg(1, "TownHouseChangeInfo: Too many houses loaded (%u), max (%u). Ignoring.", hid + numinfo, HOUSE_MAX-1);

  1212 		return false;

  1213 	}

  1214 

  1215 	/* Allocate house specs if they haven't been allocated already. */

  1216 	if (_cur_grffile->housespec == NULL) {

  1217 		_cur_grffile->housespec = CallocT<HouseSpec*>(HOUSE_MAX);

  1218 

  1219 		/* Reset any overrides that have been set. */

  1220 		ResetHouseOverrides();

  1221 	}

  1222 

  1223 	housespec = &_cur_grffile->housespec[hid];

  1224 

  1225 	if (prop != 0x08) {

  1226 		/* Check that all the houses being modified have been defined. */

  1227 		FOR_EACH_OBJECT {

  1228 			if (housespec[i] == NULL) {

  1229 				grfmsg(2, "TownHouseChangeInfo: Attempt to modify undefined house %u. Ignoring.", hid + i);

  1230 				return false;

  1231 			}

  1232 		}

  1233 	}

  1234 

  1235 	switch (prop) {

  1236 		case 0x08: // Substitute building type, and definition of a new house

  1237 			FOR_EACH_OBJECT {

  1238 				byte subs_id = grf_load_byte(&buf);

  1239 

  1240 				if (subs_id == 0xFF) {

  1241 					/* Instead of defining a new house, a substitute house id

  1242 					 * of 0xFF disables the old house with the current id. */

  1243 					_house_specs[hid + i].enabled = false;

  1244 					continue;

  1245 				} else if (subs_id >= NEW_HOUSE_OFFSET) {

  1246 					/* The substitute id must be one of the original houses. */

  1247 					grfmsg(2, "TownHouseChangeInfo: Attempt to use new house %u as substitute house for %u. Ignoring.", subs_id, hid + i);

  1248 					return false;

  1249 				}

  1250 

  1251 				/* Allocate space for this house. */

  1252 				if (housespec[i] == NULL) housespec[i] = CallocT<HouseSpec>(1);

  1253 

  1254 				memcpy(housespec[i], &_house_specs[subs_id], sizeof(_house_specs[subs_id]));

  1255 

  1256 				housespec[i]->enabled = true;

  1257 				housespec[i]->local_id = hid + i;

  1258 				housespec[i]->substitute_id = subs_id;

  1259 				housespec[i]->random_colour[0] = 0x04;  // those 4 random colours are the base colour

  1260 				housespec[i]->random_colour[1] = 0x08;  // for all new houses

  1261 				housespec[i]->random_colour[2] = 0x0C;  // they stand for red, blue, orange and green

  1262 				housespec[i]->random_colour[3] = 0x06;

  1263 

  1264 				/* New houses do not (currently) expect to have a default start

  1265 				 * date before 1930, as this breaks the build date stuff. See

  1266 				 * FinaliseHouseArray() for more details. */

  1267 				if (housespec[i]->min_date < 1930) housespec[i]->min_date = 1930;

  1268 			}

  1269 			_have_newhouses = true;

  1270 			break;

  1271 

  1272 		case 0x09: // Building flags

  1273 			FOR_EACH_OBJECT {

  1274 				byte state = grf_load_byte(&buf);

  1275 				housespec[i]->building_flags = (BuildingFlags)state;

  1276 			}

  1277 			break;

  1278 

  1279 		case 0x0A: // Availability years

  1280 			FOR_EACH_OBJECT {

  1281 				uint16 years = grf_load_word(&buf);

  1282 				housespec[i]->min_date = GB(years, 0, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 0, 8);

  1283 				housespec[i]->max_date = GB(years, 8, 8) > 150 ? MAX_YEAR : ORIGINAL_BASE_YEAR + GB(years, 8, 8);

  1284 			}

  1285 			break;

  1286 

  1287 		case 0x0B: // Population

  1288 			FOR_EACH_OBJECT housespec[i]->population = grf_load_byte(&buf);

  1289 			break;

  1290 

  1291 		case 0x0C: // Mail generation multiplier

  1292 			FOR_EACH_OBJECT housespec[i]->mail_generation = grf_load_byte(&buf);

  1293 			break;

  1294 

  1295 		case 0x0D: // Passenger acceptance

  1296 			FOR_EACH_OBJECT housespec[i]->passenger_acceptance = grf_load_byte(&buf);

  1297 			break;

  1298 

  1299 		case 0x0E: // Mail acceptance

  1300 			FOR_EACH_OBJECT housespec[i]->mail_acceptance = grf_load_byte(&buf);

  1301 			break;

  1302 

  1303 		case 0x0F: // Goods, food or fizzy drinks acceptance

  1304 			FOR_EACH_OBJECT {

  1305 				int8 goods = grf_load_byte(&buf);

  1306 				if (goods > 0) {

  1307 					housespec[i]->goods_acceptance = goods;

  1308 				} else {

  1309 					housespec[i]->food_acceptance = -goods;

  1310 				}

  1311 			}

  1312 			break;

  1313 

  1314 		case 0x10: // Local authority rating decrease on removal

  1315 			FOR_EACH_OBJECT housespec[i]->remove_rating_decrease = grf_load_word(&buf);

  1316 			break;

  1317 

  1318 		case 0x11: // Removal cost multiplier

  1319 			FOR_EACH_OBJECT housespec[i]->removal_cost = grf_load_byte(&buf);

  1320 			break;

  1321 

  1322 		case 0x12: // Building name ID

  1323 			FOR_EACH_OBJECT housespec[i]->building_name = MapGRFStringID(grf_load_word(&buf));

  1324 			break;

  1325 

  1326 		case 0x13: // Building availability mask

  1327 			FOR_EACH_OBJECT {

  1328 				uint16 avail = grf_load_word(&buf);

  1329 				housespec[i]->building_availability = (HouseZones)avail;

  1330 			}

  1331 			break;

  1332 

  1333 		case 0x14: // House callback flags

  1334 			FOR_EACH_OBJECT housespec[i]->callback_mask = grf_load_byte(&buf);

  1335 			break;

  1336 

  1337 		case 0x15: // House override byte

  1338 			FOR_EACH_OBJECT {

  1339 				byte override = grf_load_byte(&buf);

  1340 

  1341 				/* The house being overridden must be an original house. */

  1342 				if (override >= NEW_HOUSE_OFFSET) {

  1343 					grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid);

  1344 					return false;

  1345 				}

  1346 

  1347 				AddHouseOverride(hid, override);

  1348 			}

  1349 			break;

  1350 

  1351 		case 0x16: // Periodic refresh multiplier

  1352 			FOR_EACH_OBJECT housespec[i]->processing_time = grf_load_byte(&buf);

  1353 			break;

  1354 

  1355 		case 0x17: // Four random colours to use

  1356 			FOR_EACH_OBJECT {

  1357 				uint j;

  1358 				for (j = 0; j < 4; j++)	housespec[i]->random_colour[j] = grf_load_byte(&buf);

  1359 			}

  1360 			break;

  1361 

  1362 		case 0x18: // Relative probability of appearing

  1363 			FOR_EACH_OBJECT housespec[i]->probability = grf_load_byte(&buf);

  1364 			break;

  1365 

  1366 		case 0x19: // Extra flags

  1367 			FOR_EACH_OBJECT {

  1368 				byte flags = grf_load_byte(&buf);

  1369 				housespec[i]->extra_flags = (HouseExtraFlags)flags;

  1370 			}

  1371 			break;

  1372 

  1373 		case 0x1A: // Animation frames

  1374 			FOR_EACH_OBJECT housespec[i]->animation_frames = grf_load_byte(&buf);

  1375 			break;

  1376 

  1377 		case 0x1B: // Animation speed

  1378 			FOR_EACH_OBJECT housespec[i]->animation_speed = clamp(grf_load_byte(&buf), 2, 16);

  1379 			break;

  1380 

  1381 		case 0x1C: // Class of the building type

  1382 			FOR_EACH_OBJECT housespec[i]->class_id = AllocateHouseClassID(grf_load_byte(&buf), _cur_grffile->grfid);

  1383 			break;

  1384 

  1385 		case 0x1D: // Callback flags 2

  1386 			FOR_EACH_OBJECT housespec[i]->callback_mask |= (grf_load_byte(&buf) << 8);

  1387 			break;

  1388 

  1389 		case 0x1E: // Accepted cargo types

  1390 			FOR_EACH_OBJECT grf_load_dword(&buf);

  1391 			ret = true;

  1392 			break;

  1393 

  1394 		default:

  1395 			ret = true;

  1396 			break;

  1397 	}

  1398 

  1399 	*bufp = buf;

  1400 	return ret;

  1401 }

  1402 

  2084 

  2085 					break;

  2086 				}

  2087 

  2088 				case GSF_TOWNHOUSE: {

  2089 					byte sprites     = _cur_grffile->spriteset_numents;

  2090 					byte num_sprites = max((uint8)1, type);

  2091 					uint i;

  2092 

  2093 					group = AllocateSpriteGroup();

  2094 					group->type = SGT_TILELAYOUT;

  2095 					group->g.layout.num_sprites = sprites;

  2096 					group->g.layout.dts = CallocT<DrawTileSprites>(1);

  2097 

  2098 					/* Groundsprite */

  2099 					group->g.layout.dts->ground_sprite = grf_load_word(&buf);

  2100 					group->g.layout.dts->ground_pal    = grf_load_word(&buf);

  2101 					/* Remap transparent/colour modifier bits */

  2102 					if (HASBIT(group->g.layout.dts->ground_sprite, 14)) {

  2103 						CLRBIT(group->g.layout.dts->ground_sprite, 14);

  2104 						SETBIT(group->g.layout.dts->ground_sprite, PALETTE_MODIFIER_TRANSPARENT);

  2105 					}

  2106 					if (HASBIT(group->g.layout.dts->ground_sprite, 15)) {

  2107 						CLRBIT(group->g.layout.dts->ground_sprite, 15);

  2108 						SETBIT(group->g.layout.dts->ground_sprite, PALETTE_MODIFIER_COLOR);

  2109 					}

  2110 					if (HASBIT(group->g.layout.dts->ground_pal, 14)) {

  2111 						CLRBIT(group->g.layout.dts->ground_pal, 14);

  2112 						SETBIT(group->g.layout.dts->ground_sprite, SPRITE_MODIFIER_OPAQUE);

  2113 					}

  2114 					if (HASBIT(group->g.layout.dts->ground_pal, 15)) {

  2115 						/* Bit 31 set means this is a custom sprite, so rewrite it to the

  2116 						 * last spriteset defined. */

  2117 						SpriteID sprite = _cur_grffile->spriteset_start + GB(group->g.layout.dts->ground_sprite, 0, 14) * sprites;

  2118 						SB(group->g.layout.dts->ground_sprite, 0, SPRITE_WIDTH, sprite);

  2119 						CLRBIT(group->g.layout.dts->ground_pal, 15);

  2120 					}

  2121 

  2122 					group->g.layout.dts->seq = CallocT<DrawTileSeqStruct>(num_sprites + 1);

  2123 

  2124 					for (i = 0; i < num_sprites; i++) {

  2125 						DrawTileSeqStruct *seq = (DrawTileSeqStruct*)&group->g.layout.dts->seq[i];

  2126 

  2127 						seq->image = grf_load_word(&buf);

  2128 						seq->pal   = grf_load_word(&buf);

  2129 						seq->delta_x = grf_load_byte(&buf);

  2130 						seq->delta_y = grf_load_byte(&buf);

  2131 

  2132 						if (HASBIT(seq->image, 14)) {

  2133 							CLRBIT(seq->image, 14);

  2134 							SETBIT(seq->image, PALETTE_MODIFIER_TRANSPARENT);

  2135 						}

  2136 						if (HASBIT(seq->image, 15)) {

  2137 							CLRBIT(seq->image, 15);

  2138 							SETBIT(seq->image, PALETTE_MODIFIER_COLOR);

  2139 						}

  2140 						if (HASBIT(seq->pal, 14)) {

  2141 							CLRBIT(seq->pal, 14);

  2142 							SETBIT(seq->image, SPRITE_MODIFIER_OPAQUE);

  2143 						}

  2144 						if (HASBIT(seq->pal, 15)) {

  2145 							/* Bit 31 set means this is a custom sprite, so rewrite it to the

  2146 							 * last spriteset defined. */

  2147 							SpriteID sprite = _cur_grffile->spriteset_start + GB(seq->image, 0, 14) * sprites;

  2148 							SB(seq->image, 0, SPRITE_WIDTH, sprite);

  2149 							CLRBIT(seq->pal, 15);

  2150 						}

  2151 

  2152 						if (type > 0) {

  2153 							seq->delta_z = grf_load_byte(&buf);

  2154 							if ((byte)seq->delta_z == 0x80) continue;

  2155 						}

  2156 

  2157 						seq->size_x = grf_load_byte(&buf);

  2158 						seq->size_y = grf_load_byte(&buf);

  2159 						seq->size_z = grf_load_byte(&buf);

  2160 					}

  2161 

  2162 					/* Set the terminator value. */

  2163 					((DrawTileSeqStruct*)group->g.layout.dts->seq)[i].delta_x = (byte)0x80;

  2299 		}

  2300 		return;

  2301 	} else if (feature == GSF_TOWNHOUSE) {

  2302 		byte *bp = &buf[4 + idcount + cidcount * 3];

  2303 		uint16 groupid = grf_load_word(&bp);

  2304 

  2305 		if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {

  2306 			grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping.",

  2307 			       groupid, _cur_grffile->spritegroups_count);

  2308 			return;

  2309 		}

  2310 

  2311 		for (uint i = 0; i < idcount; i++) {

  2312 			uint8 hid = buf[3 + i];

  2313 			HouseSpec *hs = _cur_grffile->housespec[hid];

  2314 

  2315 			if (hs == NULL) {

  2316 				grfmsg(1, "FeatureMapSpriteGroup: Too many houses defined, skipping");

  2317 				return;

  2318 			}

  2319 

  2320 			hs->spritegroup = _cur_grffile->spritegroups[groupid];

  2321 			hs->grffile = _cur_grffile;

  2486 				case GSF_TOWNHOUSE:

  3896 static void ResetCustomHouses()

  3897 {

  3898 	GRFFile *file;

  3899 	uint i;

  3900 

  3901 	for (file = _first_grffile; file != NULL; file = file->next) {

  3902 		if (file->housespec == NULL) continue;

  3903 		for (i = 0; i < HOUSE_MAX; i++) free(file->housespec[i]);

  3904 

  3905 		free(file->housespec);

  3906 		file->housespec = NULL;

  3907 	}

  3908 }

  3909 

  3970 	/* Reset the house array */

  3971 	ResetCustomHouses();

  3972 	ResetHouses();

  3973 

  3999 	_have_newhouses = false;

  4199 		}

  4200 	}

  4201 }

  4202 

  4203 /** Add all new houses to the house array. House properties can be set at any

  4204  * time in the GRF file, so we can only add a house spec to the house array

  4205  * after the file has finished loading. We also need to check the dates, due to

  4206  * the TTDPatch behaviour described below that we need to emulate. */

  4207 static void FinaliseHouseArray()

  4208 {

  4209 	/* If there are no houses with start dates before 1930, then all houses

  4210 	 * with start dates of 1930 have them reset to 0. This is in order to be

  4211 	 * compatible with TTDPatch, where if no houses have start dates before

  4212 	 * 1930 and the date is before 1930, the game pretends that this is 1930.

  4213 	 * If there have been any houses defined with start dates before 1930 then

  4214 	 * the dates are left alone. */

  4215 	bool reset_dates = true;

  4216 

  4217 	for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {

  4218 		if (file->housespec == NULL) continue;

  4219 

  4220 		for (int i = 0; i < HOUSE_MAX; i++) {

  4221 			HouseSpec *hs = file->housespec[i];

  4222 			if (hs != NULL) {

  4223 				SetHouseSpec(hs);

  4224 				if (hs->min_date < 1930) reset_dates = false;

  4225 			}

  4226 		}

  4227 	}

  4228 

  4229 	if (reset_dates) {

  4230 		for (int i = NEW_HOUSE_OFFSET; i < HOUSE_MAX; i++) {

  4231 			HouseSpec *hs = GetHouseSpecs(i);

  4232 

  4233 			if (hs->enabled && hs->min_date == 1930) hs->min_date = 0;

  4403 static void AfterLoadGRFs()

  4404 {

  4405 	/* Pre-calculate all refit masks after loading GRF files. */

  4406 	CalculateRefitMasks();

  4407 

  4408 	/* Set the block size in the depot windows based on vehicle sprite sizes */

  4409 	InitDepotWindowBlockSizes();

  4410 

  4411 	/* Add all new houses to the house array. */

  4412 	FinaliseHouseArray();

  4413 }

  4414