openttd-mini: comparison town

equal deleted inserted replaced

-:614bba52258d
+:0a7025304867
 	/* Add a house on top of the ground? */
 	if ((image = dcts->sprite_2) != 0) {
 		if (!(_display_opt & DO_TRANS_BUILDINGS))
 			image = (image & 0x3FFF) | 0x3224000;
 		AddSortableSpriteToDraw(image,
 			ti->x | (dcts->subtile_xy>>4),
 			ti->y | (dcts->subtile_xy&0xF),
 			(dcts->width_height>>4)+1,
 			(dcts->width_height&0xF)+1,
 			dcts->dz,
 static uint GetSlopeZ_Town(TileInfo *ti)
 {
 	uint z = GetPartialZ(ti->x&0xF, ti->y&0xF, ti->tileh) + ti->z;
 	if (ti->tileh != 0) z = (z & ~7) + 4;
 	return (uint16) z;
 }
 static uint GetSlopeTileh_Town(TileInfo *ti)
 {
 	return ti->tileh;
 	if (a == b) {
 		_map5[tile] &= 0x40;
 		_map_owner[tile] &= 0x7F;
 		DeleteAnimatedTile(tile);
 	}
 	MarkTileDirtyByTile(tile);
 }
 static void UpdateTownRadius(Town *t);
 }
 static void MakeSingleHouseBigger(uint tile)
 {
 	byte b;
 	assert(IS_TILETYPE(tile, MP_HOUSE));
 	b = _map5[tile];
 	if (b & 0x80)
 		return;
 	_map5[tile] = (b & 0xC0) | ((b+1)&7);
 	_map3_lo[tile] = _map3_lo[tile] + 0x40;
 	if ( (_map3_lo[tile] & 0xC0) == 0xC0) {
 		Town *t = ClosestTownFromTile(tile, (uint)-1);
 		ChangePopulation(t, _housetype_population[_map2[tile]]);
 	}
 	MarkTileDirtyByTile(tile);
 }
 static void MakeTownHouseBigger(uint tile)
 {
 	uint flags = _house_more_flags[_map2[tile]];
 	if (flags & 8) MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 0));
 	if (flags & 4) MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 1));
 	if (flags & 2) MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 0));
 	if (flags & 1) MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 1));
 }
 		t->time_until_rebuild = (r & 63) + 130;
 		_current_player = OWNER_TOWN;
 		ClearTownHouse(t, tile);
 		// rebuild with another house?
 		if ( (byte) (r >> 8) >= 12) {
 			DoBuildTownHouse(t, tile);
 		}
 	}
 	cost = _price.remove_house * _housetype_remove_cost[house] >> 8;
 	rating = _housetype_remove_ratingmod[house];
 	_cleared_town_rating += rating;
 	_cleared_town = t = ClosestTownFromTile(tile, (uint)-1);
 	if (_current_player < MAX_PLAYERS) {
 		if (rating > t->ratings[_current_player] && !(flags & DC_NO_TOWN_RATING) && !_cheats.magic_bulldozer.value) {
 			SET_DPARAM16(0, t->index);
 			return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
 		}
 	}
 	if (flags & DC_EXEC) {
 		ChangeTownRating(t, -rating, -1000);
 		ClearTownHouse(t, tile);
 }
 static void GetAcceptedCargo_Town(uint tile, AcceptedCargo *ac)
 {
 	int type = _map2[tile];
 	ac->type_1 = CT_PASSENGERS;
 	ac->amount_1 = _housetype_cargo_passengers[type];
 	ac->type_2 = CT_GOODS;
 	ac->amount_2 = _housetype_cargo_goods[type];
 static const TileIndexDiff _roadblock_tileadd[4+3] = {
 	TILE_XY(0,-1),
 	TILE_XY(1,0),
 	TILE_XY(0,1),
 	TILE_XY(-1,0),
 	// Store the first 3 elements again.
 	// Lets us rotate without using &3.
 	TILE_XY(0,-1),
 	TILE_XY(1,0),
 	TILE_XY(0,1),
 		int i = t->grow_counter - 1;
 		if (i < 0) {
 			if (GrowTown(t)) {
 				i = t->growth_rate;
 			} else {
 				i = 0;
 			}
 		}
 		t->grow_counter = i;
 	}
 	uint slope;
 	// If this assertion fails, it might be because the world contains
 	//  land at the edges. This is not ok.
 	TILE_ASSERT(tile);
 	for(;;) {
 		// Check if there already is a road at this point?
 		if (GetRoadBitsByTile(tile) == 0) {
 			// No, try to build one in the direction.
 			// if that fails clear the land, and if that fails exit.
 			if (HASBIT(GetTownRoadMask(TILE_ADD(tile, _roadblock_tileadd[dir+1])), dir^2) ||
 					HASBIT(GetTownRoadMask(TILE_ADD(tile, _roadblock_tileadd[dir+3])), dir^2) ||
 					HASBIT(GetTownRoadMask(TILE_ADD(tile, _roadblock_tileadd[dir+1] + _roadblock_tileadd[dir+2])), dir) ||
 					HASBIT(GetTownRoadMask(TILE_ADD(tile, _roadblock_tileadd[dir+3] + _roadblock_tileadd[dir+2])), dir))
 				return false;
 			// Otherwise allow
 			return true;
 		}
 		// If the tile is not a slope in the right direction, then
 		// maybe terraform some.
 		if ((k = (dir&1)?0xC:0x9) != slope && (k^0xF) != slope) {
 			uint32 r = Random();
 }
 static bool TerraformTownTile(uint tile, int edges, int dir)
 {
 	int32 r;
 	TILE_ASSERT(tile);
 	r = DoCommandByTile(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
 	if (r == CMD_ERROR || r >= 126*16)
 		return false;
 	TILE_ASSERT(tile);
 	if (mask == 0) {
 		// Tile has no road. First reset the status counter
 		// to say that this is the last iteration.
 		_grow_town_result = 0;
 		// Then check if the tile we are at belongs to the town,
 		// if not, bail out.
 		t2 = ClosestTownFromTile(tile, (uint)-1);
 		if (!IsRoadAllowedHere(TILE_ADD(tile,_roadblock_tileadd[a]), a)) {
 			// A road is not allowed to continue the randomized road,
 			//   return if the road we're trying to build is curved.
 			if ( a != (b^2))
 				return;
 			// Return if neither side of the new road is a house
 			if (!IS_TILETYPE(TILE_ADD(tile,_roadblock_tileadd[a+1]), MP_HOUSE) &&
 					!IS_TILETYPE(TILE_ADD(tile,_roadblock_tileadd[a+3]), MP_HOUSE))
 				return;
 		if (IS_TILETYPE(tile, MP_TUNNELBRIDGE) && (_map5[tile]&~3)==4) {
 			FindLengthOfTunnelResult flotr = FindLengthOfTunnel(tile, _map5[tile]&3);
 			*tile_ptr = flotr.tile;
 			return;
 		}
 		// For any other kind of tunnel/bridge, bail out.
 		if (IS_TILETYPE(tile, MP_TUNNELBRIDGE))
 			return;
 		// Possibly extend the road in a direction.
 		if (HASBIT(mask, i))
 			return;
 		// This is the tile we will reach if we extend to this direction.
 		tmptile = TILE_ADD(tile,_roadblock_tileadd[i]);
 		// Don't do it if it reaches to water.
 		if (IS_WATER_TILE(tmptile))
 			return;
 		// If the new tile belongs to another town,
 		if (ClosestTownFromTile(tmptile, (uint)-1) != t1) {
 			_grow_town_result = 0;
 			return;
 		}
 		// Build a house at the edge. 60% chance or
 		//  always ok if no road allowed.
 		if (!IsRoadAllowedHere(tmptile, i) || CHANCE16(6,10)) {
 			// But not if there already is a house there.
 			if (!IS_TILETYPE(tmptile, MP_HOUSE)) {
 				// Level the land if possible
 	do {
 		if (GetRoadBitsByTile(tile) != 0) {
 			return GrowTownAtRoad(t, tile);
 		}
 		offs = *ptr++;
 		tile = TILE_ADD(tile, offs);
 	} while (offs);
 	// No road available, try to build a random road block by
 	// clearing some land and then building a road there.
 	tile = t->xy;
 	ptr = _town_coord_mod;
 	do {
 		FindLandscapeHeightByTile(&ti, tile);
 		// Only work with plain land that not already has a house with map5=0
 		if (ti.tileh == 0 && !(ti.type==MP_HOUSE && ti.map5==0)) {
 			if (DoCommandByTile(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR) != CMD_ERROR) {
 				DoCommandByTile(tile, GenRandomRoadBits(), 0, DC_EXEC | DC_AUTO, CMD_BUILD_ROAD);
 				return true;
 restart:
 		r = Random();
 		SET_DPARAM32(0, r);
 		GetString(buf1, t1->townnametype);
 		// Check size and width
 		if (strlen(buf1) >= 31 || GetStringWidth(buf1) > 130)
 			continue;
 		FOR_ALL_TOWNS(t2) {
 				if (str_eq(buf1, buf2))
 					goto restart;
 			}
 		}
 		t1->townnameparts = r;
 		return;
 	}
 }
 static void UpdateTownMaxPass(Town *t)
 	t->exclusivity = (byte)-1;
 	t->exclusive_counter = 0;
 	t->statues = 0;
 	CreateTownName(t);
 	UpdateTownVirtCoord(t);
 	_town_sort_dirty = true;
 	x = (Random() & 0xF) + 8;
 	if (_game_mode == GM_EDITOR)
 int32 CmdBuildTown(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 {
 	uint tile = TILE_FROM_XY(x,y);
 	TileInfo ti;
 	Town *t;
 	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	// Check if too close to the edge of map
 	if (!CheckDistanceFromEdge(tile, 12))
 		return_cmd_error(STR_0237_TOO_CLOSE_TO_EDGE_OF_MAP);
 		return_cmd_error(STR_0238_TOO_CLOSE_TO_ANOTHER_TOWN);
 	// Allocate town struct
 	t = AllocateTown();
 	if (t == NULL)
 		return_cmd_error(STR_023A_TOO_MANY_TOWNS);
 	// Create the town
 	if (flags & DC_EXEC) {
 		_generating_world = true;
 		DoCreateTown(t, tile);
 			continue;
 		// Check not too close to a town
 		if (IsCloseToTown(tile, 20))
 			continue;
 		// Allocate a town struct
 		t = AllocateTown();
 		if (t == NULL)
 			break;
 	for(i=0; i!=4; i++) {
 		tile += _tile_add[i];
 		t = ClosestTownFromTile(tile, (uint)-1);
 		if (t1 != t)
 			return false;
 		if (GetTileSlope(tile, NULL))
 			return false;
 	uint bitmask;
 	int house;
 	uint slope;
 	int z;
 	uint oneof;
 	// Above snow?
 	slope = GetTileSlope(tile, &z);
 	// Get the town zone type
 	{
 				continue;
 			// Make sure there is no slope?
 			if (_housetype_extra_flags[house]&0x12 && slope)
 				continue;
 			if (_housetype_extra_flags[house]&0x10) {
 				if (CheckFree2x2Area(t,tile) ||
 						CheckFree2x2Area(t,(tile+=TILE_XY(-1,0))) ||
 						CheckFree2x2Area(t,(tile+=TILE_XY(0,-1))) ||
 						CheckFree2x2Area(t,(tile+=TILE_XY(1,0))))
 							break;
 				tile += TILE_XY(0,1);
 			} else if (_housetype_extra_flags[house]&4) {
 				if (CheckBuildHouseMode(t, tile+TILE_XY(1,0), slope, 0))
 					break;
 				if (CheckBuildHouseMode(t, tile+TILE_XY(-1,0), slope, 1)) {
 					tile += TILE_XY(-1,0);
 					break;
 				}
 			} else if (_housetype_extra_flags[house]&8) {
 	t->num_houses++;
 	// Special houses that there can be only one of.
 	t->flags12 |= oneof;
 	{
 		int m3lo,m5,eflags;
 		// ENDING_2
 		m3lo = 0;
 		m5 = 0;
 		if (_generating_world) {
 			uint32 r = Random();
 			// Value for map3lo
 			m3lo = 0xC0;
 			if ((byte)r >= 220) m3lo &= (r>>8);
 			if (m3lo == 0xC0)
 				ChangePopulation(t, _housetype_population[house]);
 			// Initial value for map5.
 			m5 = (r >> 16) & 0x3F;
 		}
 		assert(IS_TILETYPE(tile, MP_CLEAR));
 		ModifyTile(tile,
 			MP_SETTYPE(MP_HOUSE) | MP_MAP2 | MP_MAP3LO | MP_MAP3HI_CLEAR | MP_MAP5 | MP_MAPOWNER,
 			house, /* map2 */
 			m3lo,  /* map3_lo */
 			0,     /* map_owner */
 			m5		 /* map5 */
 }
 static bool BuildTownHouse(Town *t, uint tile)
 {
 	int32 r;
 	// make sure it's possible
 	if (!EnsureNoVehicle(tile)) return false;
 	if (GetTileSlope(tile, NULL) & 0x10) return false;
 	r = DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_LANDSCAPE_CLEAR);
 		} else if (_housetype_extra_flags[house-3] & 0x10) {
 			house-=3;
 			tile += TILE_XY(-1,-1);
 		}
 	}
 	// Remove population from the town if the
 	// house is finished.
 	if ((~_map3_lo[tile] & 0xC0) == 0) {
 		ChangePopulation(t, -_housetype_population[house]);
 	}
 	if (house == 0x5B || house == 0x53 || house == 0x3C ||
 			house == 0x3D || house == 0x03)
 		t->flags12 &= ~2;
 	if (house == 0x14 || house == 0x20)
 		t->flags12 &= ~4;
 	// Do the actual clearing of tiles
 	eflags = _housetype_extra_flags[house];
 	DoClearTownHouseHelper(tile);
 	if (eflags & 0x14) DoClearTownHouseHelper(tile + TILE_XY(1,0));
 	if (eflags & 0x18) DoClearTownHouseHelper(tile + TILE_XY(0,1));
 int32 CmdRenameTown(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 {
 	StringID str;
 	Town *t = DEREF_TOWN(p1);
 	str = AllocateName((byte*)_decode_parameters, 4);
 	if (str == 0)
 		return CMD_ERROR;
 	if (flags & DC_EXEC) {
 void ExpandTown(Town *t)
 {
 	int amount, n;
 	_generating_world = true;
 	amount = ((int)Random()&3) + 3;
 	t->num_houses += amount;
 	UpdateTownRadius(t);
 	n = amount * 4;
 static void TownActionAdvertise(Town *t, int action)
 {
 	static const byte _advertising_amount[3] = {0x40, 0x70, 0xA0};
 	static const byte _advertising_radius[3] = {10,15,20};
 	ModifyStationRatingAround(t->xy, _current_player,
 		_advertising_amount[action],
 		_advertising_radius[action]);
 }
 static void TownActionRoadRebuild(Town *t, int action)
 {
 	Player *p;
 	t->road_build_months = 6;
 	SET_DPARAM16(0, t->index);
 	p = DEREF_PLAYER(_current_player);
 	SET_DPARAM16(1, p->name_1);
 	SET_DPARAM32(2, p->name_2);
 	AddNewsItem(STR_2055_TRAFFIC_CHAOS_IN_ROAD_REBUILDING,
 		NEWS_FLAGS(NM_NORMAL, NF_TILE, NT_GENERAL, 0), t->xy, 0);
 }
 static bool DoBuildStatueOfCompany(uint tile)
 {
 static void TownActionBuildStatue(Town *t, int action)
 {
 	// Layouted as an outward spiral
 	static const TileIndexDiff _statue_tiles[] = {
 	  TILE_XY(-1,0), TILE_XY(0,1),  TILE_XY(1,0),  TILE_XY(1,0),
 	  TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(-1,0), TILE_XY(-1,0),
 	  TILE_XY(-1,0), TILE_XY(0,1),  TILE_XY(0,1),  TILE_XY(0,1),
 	  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),
 	  TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1),
 	  TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0),
 	  TILE_XY(-1,0), TILE_XY(0,1),  TILE_XY(0,1),  TILE_XY(0,1),
 	  TILE_XY(0,1),  TILE_XY(0,1),  TILE_XY(1,0),  TILE_XY(1,0),
 	  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),
 	  TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1),
 	  TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(-1,0), TILE_XY(-1,0),
 	  TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0),
 	  TILE_XY(-1,0), TILE_XY(0,1),  TILE_XY(0,1),  TILE_XY(0,1),
 	  TILE_XY(0,1),  TILE_XY(0,1),  TILE_XY(0,1),  TILE_XY(0,1),
 	  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),
 	  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),  TILE_XY(1,0),
 	  TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1),
 	  TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1), TILE_XY(0,-1),
 	  TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0),
 	  TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0), TILE_XY(-1,0),
 	  0,
 };
 	int offs;
 Town *ClosestTownFromTile(uint tile, uint threshold)
 {
 	Town *t;
 	uint dist, best = threshold;
 	Town *best_town = NULL;
 	FOR_ALL_TOWNS(t) {
 		if (t->xy != 0) {
 			dist = GetTileDist(tile, t->xy);
 			if (dist < best) {
 				best = dist;
 	//	if magic_bulldozer cheat is active, town doesn't penaltize for removing stuff
 	if (t == NULL || _current_player >= MAX_PLAYERS || (_cheats.magic_bulldozer.value && add < 0)	)
 		return;
 	SETBIT(t->have_ratings, _current_player);
 	rating = t->ratings[_current_player];
 	if (add < 0) {
 		if (rating > max) {
 			rating += add;
 			if (rating < max) rating = max;
 		}
 	//	if magic_bulldozer cheat is active, town doesn't restrict your destructive actions
 	if (t == NULL || _current_player >= MAX_PLAYERS || _cheats.magic_bulldozer.value)
 		return true;
 	/*	check if you're allowed to remove the street/bridge/tunnel/industry
 	 *	owned by a town	no removal if rating is lower than ... depends now on
 	 *	difficulty setting. Minimum town rating selected by difficulty level
 	 */
 	modemod = _default_rating_settings[_opt_mod_ptr->diff.town_council_tolerance][type];
 	if (t->ratings[_current_player] < 16 + modemod && !(flags & DC_NO_TOWN_RATING)) {
 // Save and load of towns.
 static const byte _town_desc[] = {
 	SLE_VAR(Town,xy,					SLE_UINT16),
 	SLE_CONDVAR(Town,population,	SLE_FILE_U16 | SLE_VAR_U32, 0, 2),
 	SLE_CONDVAR(Town,population,	SLE_UINT32, 3, 255),
 	SLE_VAR(Town,num_houses,	SLE_UINT16),

changeset 193	0a7025304867
parent 159	139cf78bfb28
child 260	4819bcce8389