openttd-ottdgrfs: comparison src/industry

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 #include "table/strings.h"
 #include "strings.h"
 #include "table/sprites.h"
 #include "map.h"
 #include "tile.h"
+#include "train.h"
 #include "landscape.h"
 #include "viewport.h"
 #include "command.h"
 #include "industry.h"
 #include "town.h"
 #include "newgrf_industries.h"
 #include "newgrf_industrytiles.h"
 #include "newgrf_callbacks.h"
 #include "misc/autoptr.hpp"
 #include "autoslope.h"
+#include "transparency.h"
+#include "water.h"
 void ShowIndustryViewWindow(int industry);
 void BuildOilRig(TileIndex tile);
 static byte _industry_sound_ctr;
 	memcpy(&_industry_specs, &_origin_industry_specs, sizeof(_origin_industry_specs));
 	/* once performed, enable only the current climate industries */
 	for (IndustryType i = 0; i < NUM_INDUSTRYTYPES; i++) {
 		_industry_specs[i].enabled = i < NEW_INDUSTRYOFFSET &&
-				HASBIT(_origin_industry_specs[i].climate_availability, _opt.landscape);
+				HasBit(_origin_industry_specs[i].climate_availability, _opt.landscape);
 	}
 	memset(&_industry_tile_specs, 0, sizeof(_industry_tile_specs));
 	memcpy(&_industry_tile_specs, &_origin_industry_tile_specs, sizeof(_origin_industry_tile_specs));
 	dits = &_industry_draw_tile_data[gfx << 2 | (indts->anim_state ?
 			GetIndustryAnimationState(ti->tile) & INDUSTRY_COMPLETED :
 			GetIndustryConstructionStage(ti->tile))];
 	image = dits->ground.sprite;
-	if (HASBIT(image, PALETTE_MODIFIER_COLOR) && dits->ground.pal == PAL_NONE) {
+	if (HasBit(image, PALETTE_MODIFIER_COLOR) && dits->ground.pal == PAL_NONE) {
 		pal = GENERAL_SPRITE_COLOR(ind->random_color);
 	} else {
 		pal = dits->ground.pal;
 	}
 	/* Add industry on top of the ground? */
 	image = dits->building.sprite;
 	if (image != 0) {
 		AddSortableSpriteToDraw(image,
-			(HASBIT(image, PALETTE_MODIFIER_COLOR) && dits->building.pal == PAL_NONE) ? GENERAL_SPRITE_COLOR(ind->random_color) : dits->building.pal,
+			(HasBit(image, PALETTE_MODIFIER_COLOR) && dits->building.pal == PAL_NONE) ? GENERAL_SPRITE_COLOR(ind->random_color) : dits->building.pal,
 			ti->x + dits->subtile_x,
 			ti->y + dits->subtile_y,
 			dits->width,
 			dits->height,
 			dits->dz,
 			ti->z,
-			HASBIT(_transparent_opt, TO_INDUSTRIES));
+			IsTransparencySet(TO_INDUSTRIES));
-		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) return;
+		if (IsTransparencySet(TO_INDUSTRIES)) return;
 	}
 	{
 		int proc = dits->draw_proc - 1;
 		if (proc >= 0) _industry_draw_tile_procs[proc](ti);
 	/* And then these will always point to a same sized array with the required data */
 	const CargoID *accepts_cargo = itspec->accepts_cargo;
 	const uint8 *acceptance = itspec->acceptance;
-	if (HASBIT(itspec->callback_flags, CBM_INDT_ACCEPT_CARGO)) {
+	if (HasBit(itspec->callback_flags, CBM_INDT_ACCEPT_CARGO)) {
 		uint16 res = GetIndustryTileCallback(CBID_INDTILE_ACCEPT_CARGO, 0, 0, gfx, GetIndustryByTile(tile), tile);
 		if (res != CALLBACK_FAILED) {
 			accepts_cargo = raw_accepts_cargo;
 			for (uint i = 0; i < lengthof(itspec->accepts_cargo); i++) raw_accepts_cargo[i] = GetCargoTranslation(GB(res, i * 5, 5), itspec->grf_prop.grffile);
 		}
 	}
-	if (HASBIT(itspec->callback_flags, CBM_INDT_CARGO_ACCEPTANCE)) {
+	if (HasBit(itspec->callback_flags, CBM_INDT_CARGO_ACCEPTANCE)) {
 		uint16 res = GetIndustryTileCallback(CBID_INDTILE_CARGO_ACCEPTANCE, 0, 0, gfx, GetIndustryByTile(tile), tile);
 		if (res != CALLBACK_FAILED) {
 			acceptance = raw_acceptance;
 			for (uint i = 0; i < lengthof(itspec->accepts_cargo); i++) raw_acceptance[i] = GB(res, i * 4, 4);
 		}
 		SetDParam(0, indspec->name);
 		return_cmd_error(STR_4800_IN_THE_WAY);
 	}
 	if (flags & DC_EXEC) delete i;
-	return CommandCost();
+	return CommandCost(indspec->GetRemovalCost());
 }
 static void TransportIndustryGoods(TileIndex tile)
 {
 	Industry *i = GetIndustryByTile(tile);
 	const IndustrySpec *indspec = GetIndustrySpec(i->type);
-	uint cw, am;
+	bool moved_cargo = false;
-	cw = min(i->produced_cargo_waiting[0], 255);
+	for (uint j = 0; j < lengthof(i->produced_cargo_waiting); j++) {
-	if (cw > indspec->minimal_cargo/* && i->produced_cargo[0] != 0xFF*/) {
+		uint cw = min(i->produced_cargo_waiting[j], 255);
-		i->produced_cargo_waiting[0] -= cw;
+		if (cw > indspec->minimal_cargo && i->produced_cargo[j] != CT_INVALID) {
+			i->produced_cargo_waiting[j] -= cw;
-		/* fluctuating economy? */
-		if (_economy.fluct <= 0) cw = (cw + 1) / 2;
+			/* fluctuating economy? */
+			if (_economy.fluct <= 0) cw = (cw + 1) / 2;
-		i->this_month_production[0] += cw;
+			i->this_month_production[j] += cw;
-		am = MoveGoodsToStation(i->xy, i->width, i->height, i->produced_cargo[0], cw);
-		i->this_month_transported[0] += am;
+			uint am = MoveGoodsToStation(i->xy, i->width, i->height, i->produced_cargo[j], cw);
-		if (am != 0 && !StartStopIndustryTileAnimation(i, IAT_INDUSTRY_DISTRIBUTES_CARGO)) {
+			i->this_month_transported[j] += am;
-			uint newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_production;
+			moved_cargo |= (am != 0);
-			if (newgfx != INDUSTRYTILE_NOANIM) {
+		}
-				ResetIndustryConstructionStage(tile);
+	}
-				SetIndustryCompleted(tile, true);
-				SetIndustryGfx(tile, newgfx);
+	if (moved_cargo && !StartStopIndustryTileAnimation(i, IAT_INDUSTRY_DISTRIBUTES_CARGO)) {
-				MarkTileDirtyByTile(tile);
+		uint newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_production;
-			}
-		}
+		if (newgfx != INDUSTRYTILE_NOANIM) {
-	}
+			ResetIndustryConstructionStage(tile);
+			SetIndustryCompleted(tile, true);
-	cw = min(i->produced_cargo_waiting[1], 255);
+			SetIndustryGfx(tile, newgfx);
-	if (cw > indspec->minimal_cargo) {
+			MarkTileDirtyByTile(tile);
-		i->produced_cargo_waiting[1] -= cw;
+		}
-		if (_economy.fluct <= 0) cw = (cw + 1) / 2;
-		i->this_month_production[1] += cw;
-		am = MoveGoodsToStation(i->xy, i->width, i->height, i->produced_cargo[1], cw);
-		i->this_month_transported[1] += am;
 	}
 }
 static void AnimateTile_Industry(TileIndex tile)
 	case GFX_OILWELL_ANIMATED_1:
 	case GFX_OILWELL_ANIMATED_2:
 	case GFX_OILWELL_ANIMATED_3:
 		if ((_tick_counter & 7) == 0) {
-			bool b = CHANCE16(1, 7);
+			bool b = Chance16(1, 7);
 			IndustryGfx gfx = GetIndustryGfx(tile);
 			m = GetIndustryAnimationState(tile) + 1;
 			if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIMATED_3 + 1 && (gfx = GFX_OILWELL_ANIMATED_1, b)) {
 				SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);
 	if (!IsIndustryCompleted(tile)) return;
 	IndustryGfx gfx = GetIndustryGfx(tile);
 	if (gfx >= NEW_INDUSTRYTILEOFFSET) {
-		/* New industry */
+		/* New industries are already animated on construction. */
-		const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
-		if (its->animation_info != 0xFFFF) AddAnimatedTile(tile);
 		return;
 	}
 	switch (gfx) {
 	case GFX_POWERPLANT_CHIMNEY:
 static void TileLoop_Industry(TileIndex tile)
 {
 	IndustryGfx newgfx;
 	IndustryGfx gfx;
+	TriggerIndustryTile(tile, INDTILE_TRIGGER_TILE_LOOP);
 	if (!IsIndustryCompleted(tile)) {
 		MakeIndustryTileBigger(tile);
 		return;
 	}
 		break;
 	case GFX_COAL_MINE_TOWER_NOT_ANIMATED:
 	case GFX_COPPER_MINE_TOWER_NOT_ANIMATED:
 	case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:
-		if (!(_tick_counter & 0x400) && CHANCE16(1, 2)) {
+		if (!(_tick_counter & 0x400) && Chance16(1, 2)) {
 			switch (gfx) {
 				case GFX_COAL_MINE_TOWER_NOT_ANIMATED:   gfx = GFX_COAL_MINE_TOWER_ANIMATED;   break;
 				case GFX_COPPER_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_ANIMATED; break;
 				case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:   gfx = GFX_GOLD_MINE_TOWER_ANIMATED;   break;
 			}
 			AddAnimatedTile(tile);
 		}
 		break;
 	case GFX_OILWELL_NOT_ANIMATED:
-		if (CHANCE16(1, 6)) {
+		if (Chance16(1, 6)) {
 			SetIndustryGfx(tile, GFX_OILWELL_ANIMATED_1);
 			SetIndustryAnimationState(tile, 0);
 			AddAnimatedTile(tile);
 		}
 		break;
 			DeleteAnimatedTile(tile);
 		}
 		break;
 	case GFX_POWERPLANT_SPARKS:
-		if (CHANCE16(1, 3)) {
+		if (Chance16(1, 3)) {
 			SndPlayTileFx(SND_0C_ELECTRIC_SPARK, tile);
 			AddAnimatedTile(tile);
 		}
 		break;
 	case GFX_TOFFEE_QUARY:
 		AddAnimatedTile(tile);
 		break;
 	case GFX_SUGAR_MINE_SIEVE:
-		if (CHANCE16(1, 3)) AddAnimatedTile(tile);
+		if (Chance16(1, 3)) AddAnimatedTile(tile);
 		break;
 	}
 }
 static void ClickTile_Industry(TileIndex tile)
 		tile = TILE_MASK(tile);
 		if (IsTileType(tile, MP_CLEAR) || IsTileType(tile, MP_TREES)) {
 			byte or_ = type;
-			if (or_ == 1 && CHANCE16(1, 7)) or_ = 2;
+			if (or_ == 1 && Chance16(1, 7)) or_ = 2;
 			if (direction == AXIS_X) {
 				SetFenceSE(tile, or_);
 			} else {
 				SetFenceSW(tile, or_);
 	uint num;
 	const IndustrySpec *indsp = GetIndustrySpec(i->type);
 	/* play a sound? */
 	if ((i->counter & 0x3F) == 0) {
-		if (CHANCE16R(1, 14, r) && (num = indsp->number_of_sounds) != 0) {
+		if (Chance16R(1, 14, r) && (num = indsp->number_of_sounds) != 0) {
 			SndPlayTileFx(
 				(SoundFx)(indsp->random_sounds[((r >> 16) * num) >> 16]),
 				i->xy);
 		}
 	}
 	i->counter--;
 	/* produce some cargo */
 	if ((i->counter & 0xFF) == 0) {
-		if (HASBIT(indsp->callback_flags, CBM_IND_PRODUCTION_256_TICKS)) IndustryProductionCallback(i, 1);
+		if (HasBit(indsp->callback_flags, CBM_IND_PRODUCTION_256_TICKS)) IndustryProductionCallback(i, 1);
-		IndustyBehaviour indbehav = indsp->behaviour;
+		IndustryBehaviour indbehav = indsp->behaviour;
 		i->produced_cargo_waiting[0] = min(0xffff, i->produced_cargo_waiting[0] + i->production_rate[0]);
 		i->produced_cargo_waiting[1] = min(0xffff, i->produced_cargo_waiting[1] + i->production_rate[1]);
 		if ((indbehav & INDUSTRYBEH_PLANT_FIELDS) != 0) {
 			bool plant;
-			if (HASBIT(indsp->callback_flags, CBM_IND_SPECIAL_EFFECT)) {
+			if (HasBit(indsp->callback_flags, CBM_IND_SPECIAL_EFFECT)) {
 				plant = (GetIndustryCallback(CBID_INDUSTRY_SPECIAL_EFFECT, Random(), 0, i, i->type, i->xy) != 0);
 			} else {
-				plant = CHANCE16(1, 8);
+				plant = Chance16(1, 8);
 			}
 			if (plant) PlantRandomFarmField(i);
 		}
 		if ((indbehav & INDUSTRYBEH_CUT_TREES) != 0) {
 			bool cut = ((i->counter & 0x1FF) == 0);
-			if (HASBIT(indsp->callback_flags, CBM_IND_SPECIAL_EFFECT)) {
+			if (HasBit(indsp->callback_flags, CBM_IND_SPECIAL_EFFECT)) {
 				cut = (GetIndustryCallback(CBID_INDUSTRY_SPECIAL_EFFECT, 0, 1, i, i->type, i->xy) != 0);
 			}
 			if (cut) ChopLumberMillTrees(i);
 		}
 	}
 	if (_game_mode == GM_EDITOR) return;
 	FOR_ALL_INDUSTRIES(i) {
+		TriggerIndustry(i, INDUSTRY_TRIGGER_INDUSTRY_TICK);
 		StartStopIndustryTileAnimation(i, IAT_INDUSTRY_TICK);
 		ProduceIndustryGoods(i);
 	}
 }
 	return t;
 }
 bool IsSlopeRefused(Slope current, Slope refused)
 {
+	if (IsSteepSlope(current)) return true;
 	if (current != SLOPE_FLAT) {
 		if (refused & SLOPE_STEEP) return true;
 		Slope t = ComplementSlope(current);
 			if (!IsTileType(cur_tile, MP_WATER) ||
 					GetTileSlope(cur_tile, NULL) != SLOPE_FLAT) {
 				return false;
 			}
 		} else {
-			if (!EnsureNoVehicle(cur_tile)) return false;
+			if (!EnsureNoVehicleOnGround(cur_tile)) return false;
 			if (MayHaveBridgeAbove(cur_tile) && IsBridgeAbove(cur_tile)) return false;
 			const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
-			IndustyBehaviour ind_behav = GetIndustrySpec(type)->behaviour;
+			IndustryBehaviour ind_behav = GetIndustrySpec(type)->behaviour;
-			if (HASBIT(its->callback_flags, CBM_INDT_SHAPE_CHECK)) {
+			/* Perform land/water check if not disabled */
+			if (!HasBit(its->slopes_refused, 5) && (IsWaterTile(cur_tile) == !(ind_behav & INDUSTRYBEH_BUILT_ONWATER))) return false;
+			if (HasBit(its->callback_flags, CBM_INDT_SHAPE_CHECK)) {
 				custom_shape = true;
 				if (!PerformIndustryTileSlopeCheck(tile, cur_tile, its, type, gfx, itspec_index)) return false;
 			} else {
-				if (ind_behav & INDUSTRYBEH_BUILT_ONWATER) {
+				Slope tileh = GetTileSlope(cur_tile, NULL);
-					/* As soon as the tile is not water, bail out.
+				refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
-					* But that does not mean the search is over.  You have
+			}
-					* to make sure every tile of the industry will be only water*/
-					if (!IsClearWaterTile(cur_tile)) return false;
+			if (ind_behav & (INDUSTRYBEH_ONLY_INTOWN | INDUSTRYBEH_TOWN1200_MORE)) {
-				} else {
-					Slope tileh;
-					if (IsClearWaterTile(cur_tile)) return false;
-					tileh = GetTileSlope(cur_tile, NULL);
-					if (IsSteepSlope(tileh)) return false;
-					refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
-				}
-			}
-			if (ind_behav & INDUSTRYBEH_ONLY_INTOWN) {
 				if (!IsTileType(cur_tile, MP_HOUSE)) {
 					_error_message = STR_029D_CAN_ONLY_BE_BUILT_IN_TOWNS;
 					return false;
 				}
 				if (CmdFailed(DoCommand(cur_tile, 0, 0, 0, CMD_LANDSCAPE_CLEAR))) return false;
 		/* Is the tile clear? */
 		if ((GetTileType(tile_walk) != MP_CLEAR) && (GetTileType(tile_walk) != MP_TREES))
 			return false;
 		/* Don't allow too big of a change if this is the sub-tile check */
-		if (internal != 0 && delta(curh, height) > 1) return false;
+		if (internal != 0 && Delta(curh, height) > 1) return false;
 		/* Different height, so the surrounding tiles of this tile
 		 *  has to be correct too (in level, or almost in level)
 		 *  else you get a chain-reaction of terraforming. */
 		if (internal == 0 && curh != height) {
 	i->accepts_cargo[1] = indspec->accepts_cargo[1];
 	i->accepts_cargo[2] = indspec->accepts_cargo[2];
 	i->production_rate[0] = indspec->production_rate[0];
 	i->production_rate[1] = indspec->production_rate[1];
-	/* don't use smooth economy for industries using production callbacks */
+	/* don't use smooth economy for industries using production related callbacks */
-	if (_patches.smooth_economy  && !(HASBIT(indspec->callback_flags, CBM_IND_PRODUCTION_256_TICKS) || HASBIT(indspec->callback_flags, CBM_IND_PRODUCTION_CARGO_ARRIVAL))) {
+	if (_patches.smooth_economy &&
+	    !(HasBit(indspec->callback_flags, CBM_IND_PRODUCTION_256_TICKS) || HasBit(indspec->callback_flags, CBM_IND_PRODUCTION_CARGO_ARRIVAL)) && // production callbacks
+	    !(HasBit(indspec->callback_flags, CBM_IND_MONTHLYPROD_CHANGE) || HasBit(indspec->callback_flags, CBM_IND_PRODUCTION_CHANGE))             // production change callbacks
+	) {
 		i->production_rate[0] = min((RandomRange(256) + 128) * i->production_rate[0] >> 8 , 255);
 		i->production_rate[1] = min((RandomRange(256) + 128) * i->production_rate[1] >> 8 , 255);
 	}
 	i->town = t;
 	i->owner = owner;
 	r = Random();
-	i->random_color = GB(r, 8, 4);
+	i->random_color = GB(r, 0, 4);
-	i->counter = GB(r, 0, 12);
+	i->counter = GB(r, 4, 12);
+	i->random = GB(r, 16, 16);
 	i->produced_cargo_waiting[0] = 0;
 	i->produced_cargo_waiting[1] = 0;
 	i->incoming_cargo_waiting[0] = 0;
 	i->incoming_cargo_waiting[1] = 0;
 	i->incoming_cargo_waiting[2] = 0;
 	i->last_prod_year = _cur_year;
 	i->last_month_production[0] = i->production_rate[0] * 8;
 	i->last_month_production[1] = i->production_rate[1] * 8;
 	i->founder = _current_player;
-	if (HASBIT(indspec->callback_flags, CBM_IND_DECIDE_COLOUR)) {
+	if (HasBit(indspec->callback_flags, CBM_IND_DECIDE_COLOUR)) {
 		uint16 res = GetIndustryCallback(CBID_INDUSTRY_DECIDE_COLOUR, 0, 0, i, type, INVALID_TILE);
 		if (res != CALLBACK_FAILED) i->random_color = GB(res, 0, 4);
 	}
-	if (HASBIT(indspec->callback_flags, CBM_IND_INPUT_CARGO_TYPES)) {
+	if (HasBit(indspec->callback_flags, CBM_IND_INPUT_CARGO_TYPES)) {
 		for (j = 0; j < lengthof(i->accepts_cargo); j++) i->accepts_cargo[j] = CT_INVALID;
 		for (j = 0; j < lengthof(i->accepts_cargo); j++) {
 			uint16 res = GetIndustryCallback(CBID_INDUSTRY_INPUT_CARGO_TYPES, j, 0, i, type, INVALID_TILE);
 			if (res == CALLBACK_FAILED || GB(res, 0, 8) == CT_INVALID) break;
 			i->accepts_cargo[j] = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
 		}
 	}
-	if (HASBIT(indspec->callback_flags, CBM_IND_OUTPUT_CARGO_TYPES)) {
+	if (HasBit(indspec->callback_flags, CBM_IND_OUTPUT_CARGO_TYPES)) {
 		for (j = 0; j < lengthof(i->produced_cargo); j++) i->produced_cargo[j] = CT_INVALID;
 		for (j = 0; j < lengthof(i->produced_cargo); j++) {
 			uint16 res = GetIndustryCallback(CBID_INDUSTRY_OUTPUT_CARGO_TYPES, j, 0, i, type, INVALID_TILE);
 			if (res == CALLBACK_FAILED || GB(res, 0, 8) == CT_INVALID) break;
 			i->produced_cargo[j] = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
 			if (size > i->height)i->height = size;
 			DoCommand(cur_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
 			MakeIndustry(cur_tile, i->index, it->gfx);
 			if (_generating_world) {
 				SetIndustryConstructionCounter(cur_tile, 3);
 				SetIndustryConstructionStage(cur_tile, 2);
+			}
+			if (it->gfx >= NEW_INDUSTRYTILEOFFSET) {
+				/* New industry */
+				const IndustryTileSpec *its = GetIndustryTileSpec(it->gfx);
+				if (its->animation_info != 0xFFFF) AddAnimatedTile(cur_tile);
 			}
 		}
 	} while ((++it)->ti.x != -0x80);
 	i->width++;
 	const IndustryTileTable *it = indspec->table[itspec_index];
 	bool custom_shape_check = false;
 	if (!CheckIfIndustryTilesAreFree(tile, it, itspec_index, type, &custom_shape_check)) return NULL;
-	if (HASBIT(GetIndustrySpec(type)->callback_flags, CBM_IND_LOCATION)) {
+	if (HasBit(GetIndustrySpec(type)->callback_flags, CBM_IND_LOCATION)) {
 		if (!CheckIfCallBackAllowsCreation(tile, type, itspec_index)) return NULL;
 	} else {
 		if (!_check_new_industry_procs[indspec->check_proc](tile)) return NULL;
 	}
 /** Build/Fund an industry
 * @param tile tile where industry is built
 * @param flags of operations to conduct
 * @param p1 industry type see build_industry.h and see industry.h
-* @param p2 unused
+* @param p2 first layout to try
 * @return index of the newly create industry, or CMD_ERROR if it failed
 */
 CommandCost CmdBuildIndustry(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
-	int num;
-	const IndustryTileTable * const *itt;
 	const IndustrySpec *indspec;
 	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	indspec = GetIndustrySpec(p1);
 			/* Prospecting has a chance to fail, however we cannot guarantee that something can
 			 * be built on the map, so the chance gets lower when the map is fuller, but there
 			 * is nothing we can really do about that. */
 			if (Random() <= indspec->prospecting_chance) {
 				for (int i = 0; i < 5000; i++) {
-					uint tilespec_index = RandomRange(indspec->num_table);
+					const Industry *ind = CreateNewIndustryHelper(RandomTile(), p1, flags, indspec, RandomRange(indspec->num_table));
-					const Industry *ind = CreateNewIndustryHelper(RandomTile(), p1, flags, indspec, tilespec_index);
 					if (ind != NULL) {
 						SetDParam(0, indspec->name);
-						SetDParam(1, ind->town->index);
+						if (indspec->new_industry_text > STR_LAST_STRINGID) {
+							SetDParam(1, STR_TOWN);
+							SetDParam(2, ind->town->index);
+						} else {
+							SetDParam(1, ind->town->index);
+						}
 						AddNewsItem(indspec->new_industry_text,
 								NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_TILE, NT_OPENCLOSE, 0), ind->xy, 0);
 						break;
 					}
 				}
 			}
 		}
 	} else {
-		num = indspec->num_table;
+		int count = indspec->num_table;
-		itt = indspec->table;
+		const IndustryTileTable * const *itt = indspec->table;
+		int num = Clamp(p2, 0, count - 1);
+		_error_message = STR_0239_SITE_UNSUITABLE;
 		do {
-			if (--num < 0) return_cmd_error(STR_0239_SITE_UNSUITABLE);
+			if (--count < 0) return CMD_ERROR;
+			if (--num < 0) num = indspec->num_table - 1;
 		} while (!CheckIfIndustryTilesAreFree(tile, itt[num], num, p1));
 		if (CreateNewIndustryHelper(tile, p1, flags, indspec, num) == NULL) return CMD_ERROR;
 	}
 	ProbabilityHelper cumulative_probs[NUM_INDUSTRYTYPES]; // probability collector
 	uint16 probability_max = 0;
 	/* Generate a list of all possible industries that can be built. */
 	for (j = 0; j < NUM_INDUSTRYTYPES; j++) {
-		byte chance = GetIndustrySpec(j)->appear_ingame[_opt.landscape];
+		ind_spc = GetIndustrySpec(j);
+		byte chance = ind_spc->appear_ingame[_opt.landscape];
+		if (!ind_spc->enabled || chance == 0) continue;
 		/* If there is no Callback CBID_INDUSTRY_AVAILABLE or if this one did anot failed,
 		 * and if appearing chance for this landscape is above 0, this industry can be chosen */
-		if (CheckIfCallBackAllowsAvailability(j, IACT_RANDOMCREATION) && chance != 0) {
+		if (CheckIfCallBackAllowsAvailability(j, IACT_RANDOMCREATION)) {
 			probability_max += chance;
 			/* adds the result for this industry */
 			cumulative_probs[num].ind = j;
 			cumulative_probs[num++].prob = probability_max;
 		}
 		if (ind != NULL) break;
 		if (--num == 0) return;
 	}
 	SetDParam(0, ind_spc->name);
-	SetDParam(1, ind->town->index);
+	if (ind_spc->new_industry_text > STR_LAST_STRINGID) {
+		SetDParam(1, STR_TOWN);
+		SetDParam(2, ind->town->index);
+	} else {
+		SetDParam(1, ind->town->index);
+	}
 	AddNewsItem(ind_spc->new_industry_text,
 		NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_TILE, NT_OPENCLOSE, 0), ind->xy, 0);
 }
 /**
 {
 	const IndustrySpec *indspec = GetIndustrySpec(type);
 	/* oil wells (or the industries with that flag set) are always allowed to closedown */
 	if (indspec->behaviour & INDUSTRYBEH_DONT_INCR_PROD && _opt.landscape == LT_TEMPERATE) return false;
-	return (indspec->behaviour & INDUSTRYBEH_CANCLOSE_LASTINSTANCE && GetIndustryTypeCount(type) <= 1);
+	return (indspec->behaviour & INDUSTRYBEH_CANCLOSE_LASTINSTANCE) == 0 && GetIndustryTypeCount(type) <= 1;
 }
+/**
+* Can given cargo type be accepted or produced by the industry?
+* @param cargo: Cargo type
+* @param ind: Industry
+* @param *c_accepts: Pointer to boolean for acceptance of cargo
+* @param *c_produces: Pointer to boolean for production of cargo
+* @return: \c *c_accepts is set when industry accepts the cargo type,
+*          \c *c_produces is set when the industry produces the cargo type
+*/
+static void CanCargoServiceIndustry(CargoID cargo, Industry *ind, bool *c_accepts, bool *c_produces)
+{
+	const IndustrySpec *indspec = GetIndustrySpec(ind->type);
+	/* Check for acceptance of cargo */
+	for (uint j = 0; j < lengthof(ind->accepts_cargo) && ind->accepts_cargo[j] != CT_INVALID; j++) {
+		if (cargo == ind->accepts_cargo[j]) {
+			if (HasBit(indspec->callback_flags, CBM_IND_REFUSE_CARGO)) {
+				uint16 res = GetIndustryCallback(CBID_INDUSTRY_REFUSE_CARGO,
+						0, GetReverseCargoTranslation(cargo, indspec->grf_prop.grffile),
+						ind, ind->type, ind->xy);
+				if (res == 0) continue;
+			}
+			*c_accepts = true;
+			break;
+		}
+	}
+	/* Check for produced cargo */
+	for (uint j = 0; j < lengthof(ind->produced_cargo) && ind->produced_cargo[j] != CT_INVALID; j++) {
+		if (cargo == ind->produced_cargo[j]) {
+			*c_produces = true;
+			break;
+		}
+	}
+}
+/**
+* Compute who can service the industry.
+*
+* Here, 'can service' means that he/she has trains and stations close enough
+* to the industry with the right cargo type and the right orders (ie has the
+* technical means).
+*
+* @param ind: Industry being investigated.
+*
+* @return: 0 if nobody can service the industry, 2 if the local player can
+* service the industry, and 1 otherwise (only competitors can service the
+* industry)
+*/
+int WhoCanServiceIndustry(Industry* ind)
+{
+	/* Find all stations within reach of the industry */
+	StationSet stations = FindStationsAroundIndustryTile(ind->xy, ind->width, ind->height);
+	if (stations.size() == 0) return 0; // No stations found at all => nobody services
+	const Vehicle *v;
+	int result = 0;
+	FOR_ALL_VEHICLES(v) {
+		/* Is it worthwhile to try this vehicle? */
+		if (v->owner != _local_player && result != 0) continue;
+		/* Check whether it accepts the right kind of cargo */
+		bool c_accepts = false;
+		bool c_produces = false;
+		if (v->type == VEH_TRAIN && IsFrontEngine(v)) {
+			const Vehicle *u = v;
+			BEGIN_ENUM_WAGONS(u)
+				CanCargoServiceIndustry(u->cargo_type, ind, &c_accepts, &c_produces);
+			END_ENUM_WAGONS(u)
+		} else if (v->type == VEH_ROAD || v->type == VEH_SHIP || v->type == VEH_AIRCRAFT) {
+			CanCargoServiceIndustry(v->cargo_type, ind, &c_accepts, &c_produces);
+		} else {
+			continue;
+		}
+		if (!c_accepts && !c_produces) continue; // Wrong cargo
+		/* Check orders of the vehicle.
+		 * We cannot check the first of shared orders only, since the first vehicle in such a chain
+		 * may have a different cargo type.
+		 */
+		const Order *o;
+		FOR_VEHICLE_ORDERS(v, o) {
+			if (o->type == OT_GOTO_STATION && !HasBit(o->flags, OFB_TRANSFER)) {
+				/* Vehicle visits a station to load or unload */
+				Station *st = GetStation(o->dest);
+				if (!st->IsValid()) continue;
+				/* Same cargo produced by industry is dropped here => not serviced by vehicle v */
+				if (HasBit(o->flags, OFB_UNLOAD) && !c_accepts) break;
+				if (stations.find(st) != stations.end()) {
+					if (v->owner == _local_player) return 2; // Player services industry
+					result = 1; // Competitor services industry
+				}
+			}
+		}
+	}
+	return result;
+}
+/**
+* Report news that industry production has changed significantly
+*
+* @param ind: Industry with changed production
+* @param type: Cargo type that has changed
+* @param percent: Percentage of change (>0 means increase, <0 means decrease)
+*/
+static void ReportNewsProductionChangeIndustry(Industry *ind, CargoID type, int percent)
+{
+	NewsType nt;
+	switch (WhoCanServiceIndustry(ind)) {
+		case 0: nt = NT_INDUSTRY_NOBODY; break;
+		case 1: nt = NT_INDUSTRY_OTHER;  break;
+		case 2: nt = NT_INDUSTRY_PLAYER; break;
+		default: NOT_REACHED(); break;
+	}
+	SetDParam(2, abs(percent));
+	SetDParam(0, GetCargo(type)->name);
+	SetDParam(1, ind->index);
+	AddNewsItem(
+		percent >= 0 ? STR_INDUSTRY_PROD_GOUP : STR_INDUSTRY_PROD_GODOWN,
+		NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_TILE, nt, 0),
+		ind->xy + TileDiffXY(1, 1), 0
+	);
+}
+enum {
+	PERCENT_TRANSPORTED_60 = 153,
+};
 /** Change industry production or do closure
 * @param i Industry for which changes are performed
 * @param monthly true if it's the monthly call, false if it's the random call
 */
 	StringID str = STR_NULL;
 	bool closeit = false;
 	const IndustrySpec *indspec = GetIndustrySpec(i->type);
 	bool standard = true;
 	bool suppress_message = false;
-	/* don't use smooth economy for industries using production callbacks */
+	/* don't use smooth economy for industries using production related callbacks */
-	bool smooth_economy = _patches.smooth_economy && !(HASBIT(indspec->callback_flags, CBM_IND_PRODUCTION_256_TICKS) || HASBIT(indspec->callback_flags, CBM_IND_PRODUCTION_CARGO_ARRIVAL));
+	bool smooth_economy = _patches.smooth_economy &&
+	                      !(HasBit(indspec->callback_flags, CBM_IND_PRODUCTION_256_TICKS) || HasBit(indspec->callback_flags, CBM_IND_PRODUCTION_CARGO_ARRIVAL)) && // production callbacks
+	                      !(HasBit(indspec->callback_flags, CBM_IND_MONTHLYPROD_CHANGE) || HasBit(indspec->callback_flags, CBM_IND_PRODUCTION_CHANGE));            // production change callbacks
 	byte div = 0;
 	byte mul = 0;
+	int8 increment = 0;
-	if (HASBIT(indspec->callback_flags, monthly ? CBM_IND_MONTHLYPROD_CHANGE : CBM_IND_PRODUCTION_CHANGE)) {
+	if (HasBit(indspec->callback_flags, monthly ? CBM_IND_MONTHLYPROD_CHANGE : CBM_IND_PRODUCTION_CHANGE)) {
 		uint16 res = GetIndustryCallback(monthly ? CBID_INDUSTRY_MONTHLYPROD_CHANGE : CBID_INDUSTRY_PRODUCTION_CHANGE, 0, Random(), i, i->type, i->xy);
+		standard = false;
+		monthly = false; // smooth economy is disabled so we need to fake random industry production change to allow 'use standard' result
 		if (res != CALLBACK_FAILED) {
-			standard = false;
+			suppress_message = HasBit(res, 7);
-			suppress_message = HASBIT(res, 7);
 			/* Get the custom message if any */
-			if (HASBIT(res, 8)) str = MapGRFStringID(indspec->grf_prop.grffile->grfid, GB(GetRegister(0x100), 0, 16));
+			if (HasBit(res, 8)) str = MapGRFStringID(indspec->grf_prop.grffile->grfid, GB(GetRegister(0x100), 0, 16));
 			res = GB(res, 0, 4);
 			switch(res) {
 				default: NOT_REACHED();
 				case 0x0: break;                  // Do nothing, but show the custom message if any
 				case 0x1: div = 1; break;         // Halve industry production. If production reaches the quarter of the default, the industry is closed instead.
 				case 0x2: mul = 1; break;         // Double industry production if it hasn't reached eight times of the original yet.
 				case 0x3: closeit = true; break;  // The industry announces imminent closure, and is physically removed from the map next month.
 				case 0x4: standard = true; break; // Do the standard random production change as if this industry was a primary one.
 				case 0x5: case 0x6: case 0x7:     // Divide production by 4, 8, 16
-				case 0x8: div = res - 0x5; break; // Divide production by 32
+				case 0x8: div = res - 0x3; break; // Divide production by 32
 				case 0x9: case 0xA: case 0xB:     // Multiply production by 4, 8, 16
-				case 0xC: mul = res - 0x9; break; // Multiply production by 32
+				case 0xC: mul = res - 0x7; break; // Multiply production by 32
+				case 0xD:                         // decrement production
+				case 0xE:                         // increment production
+					increment = res == 0x0D ? -1 : 1;
+					break;
 			}
 		}
 	}
 	if (standard && monthly != smooth_economy) return;
 		bool only_decrease = (indspec->behaviour & INDUSTRYBEH_DONT_INCR_PROD) && _opt.landscape == LT_TEMPERATE;
 		if (smooth_economy) {
 			closeit = true;
 			for (byte j = 0; j < 2 && i->produced_cargo[j] != CT_INVALID; j++){
-				uint32 r = Random();
 				int old_prod, new_prod, percent;
-				int mag;
+				int mult = (i->last_month_pct_transported[j] > PERCENT_TRANSPORTED_60) ? 1 : -1;
 				new_prod = old_prod = i->production_rate[j];
-				if (CHANCE16I(20, 1024, r)) new_prod -= max(((RandomRange(50) + 10) * old_prod) >> 8, 1U);
+				if (only_decrease) {
-				/* Chance of increasing becomes better when more is transported */
+					mult = -1;
-				if (CHANCE16I(20 + (i->last_month_pct_transported[j] * 20 >> 8), 1024, r >> 16) && !only_decrease) {
+				} else if (Chance16(1, 3)) {
-					new_prod += max(((RandomRange(50) + 10) * old_prod) >> 8, 1U);
+					mult *= -1;
 				}
-				new_prod = clamp(new_prod, 1, 255);
+				if (Chance16(1, 22)) {
+					new_prod += mult * (max(((RandomRange(50) + 10) * old_prod) >> 8, 1U));
+				}
+				/* Prevent production to overflow or Oil Rig passengers to be over-"produced" */
+				new_prod = Clamp(new_prod, 1, 255);
+				if (((indspec->behaviour & INDUSTRYBEH_BUILT_ONWATER) != 0) && j == 1)
+					new_prod = Clamp(new_prod, 0, 16);
 				/* Do not stop closing the industry when it has the lowest possible production rate */
 				if (new_prod == old_prod && old_prod > 1) {
 					closeit = false;
 					continue;
 				}
 				i->production_rate[j] = new_prod;
 				/* Close the industry when it has the lowest possible production rate */
 				if (new_prod > 1) closeit = false;
-				mag = abs(percent);
+				if (abs(percent) >= 10) {
-				if (mag >= 10) {
+					ReportNewsProductionChangeIndustry(i, i->produced_cargo[j], percent);
-					SetDParam(2, mag);
-					SetDParam(0, GetCargo(i->produced_cargo[j])->name);
-					SetDParam(1, i->index);
-					AddNewsItem(
-						percent >= 0 ? STR_INDUSTRY_PROD_GOUP : STR_INDUSTRY_PROD_GODOWN,
-						NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_TILE, NT_ECONOMY, 0),
-						i->xy + TileDiffXY(1, 1), 0
-					);
 				}
 			}
 		} else {
-			if (only_decrease || CHANCE16(1, 3)) {
+			if (only_decrease || Chance16(1, 3)) {
 				/* If you transport > 60%, 66% chance we increase, else 33% chance we increase */
-				if (!only_decrease && (i->last_month_pct_transported[0] > 153) != CHANCE16(1, 3)) {
+				if (!only_decrease && (i->last_month_pct_transported[0] > PERCENT_TRANSPORTED_60) != Chance16(1, 3)) {
 					mul = 1; // Increase production
 				} else {
 					div = 1; // Decrease production
 				}
 			}
 		}
 	}
 	if (standard && indspec->life_type & INDUSTRYLIFE_PROCESSING) {
-		if ( (byte)(_cur_year - i->last_prod_year) >= 5 && CHANCE16(1, smooth_economy ? 180 : 2)) {
+		if ( (byte)(_cur_year - i->last_prod_year) >= 5 && Chance16(1, smooth_economy ? 180 : 2)) {
 			closeit = true;
 		}
 	}
 	/* Increase if needed */
 			i->production_rate[1] = (i->production_rate[1] + 1) >> 1;
 			if (str == STR_NULL) str = indspec->production_down_text;
 		}
 	}
+	if (increment != 0) {
+		i->prod_level = ClampU(i->prod_level + increment, 4, 0x80);
+		if (i->prod_level == 4) closeit = true;
+	}
 	/* Close if needed and allowed */
 	if (closeit && !CheckIndustryCloseDownProtection(i->type)) {
 		i->prod_level = 0;
 		str = indspec->closure_text;
 	}
 	if (!suppress_message && str != STR_NULL) {
-		SetDParam(0, i->index);
+		NewsType nt;
+		/* Compute news category */
+		if (closeit) {
+			nt = NT_OPENCLOSE;
+		} else {
+			switch (WhoCanServiceIndustry(i)) {
+				case 0: nt = NT_INDUSTRY_NOBODY; break;
+				case 1: nt = NT_INDUSTRY_OTHER;  break;
+				case 2: nt = NT_INDUSTRY_PLAYER; break;
+				default: NOT_REACHED(); break;
+			}
+		}
+		/* Set parameters of news string */
+		if (str > STR_LAST_STRINGID) {
+			SetDParam(0, STR_TOWN);
+			SetDParam(1, i->town->index);
+			SetDParam(2, indspec->name);
+		} else if (closeit) {
+			SetDParam(0, STR_INDUSTRY_FORMAT);
+			SetDParam(1, i->town->index);
+			SetDParam(2, indspec->name);
+		} else {
+			SetDParam(0, i->index);
+		}
+		/* and report the news to the user */
 		AddNewsItem(str,
-			NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_TILE, closeit ? NT_OPENCLOSE : NT_ECONOMY, 0),
+			NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_TILE, nt, 0),
 			i->xy + TileDiffXY(1, 1), 0);
 	}
 }
 void IndustryMonthlyLoop()
 			ChangeIndustryProduction(i, true);
 		}
 	}
 	/* 3% chance that we start a new industry */
-	if (CHANCE16(3, 100)) {
+	if (Chance16(3, 100)) {
 		MaybeNewIndustry();
 	} else {
 		i = GetRandomIndustry();
 		if (i != NULL) ChangeIndustryProduction(i, false);
 	}
 	return (_price.build_industry *
 			(_patches.raw_industry_construction == 1 && this->IsRawIndustry() ?
 					this->raw_industry_cost_multiplier :
 					this->cost_multiplier
 			)) >> 8;
+}
+Money IndustrySpec::GetRemovalCost() const
+{
+	return (_price.remove_house * this->removal_cost_multiplier) >> 8;
 }
 static CommandCost TerraformTile_Industry(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new)
 {
 	if (AutoslopeEnabled()) {
 		if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) {
 			const IndustryGfx gfx = GetIndustryGfx(tile);
 			const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
 			/* Call callback 3C 'disable autosloping for industry tiles'. */
-			if (HASBIT(itspec->callback_flags, CBM_INDT_AUTOSLOPE)) {
+			if (HasBit(itspec->callback_flags, CBM_INDT_AUTOSLOPE)) {
 				/* If the callback fails, allow autoslope. */
 				uint16 res = GetIndustryTileCallback(CBID_INDUSTRY_AUTOSLOPE, 0, 0, gfx, GetIndustryByTile(tile), tile);
 				if ((res == 0) || (res == CALLBACK_FAILED)) return _price.terraform;
 			} else {
-				// allow autoslope
+				/* allow autoslope */
 				return _price.terraform;
 			}
 		}
 	}
 	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 	SLE_CONDVAR(Industry, last_cargo_accepted_at,     SLE_INT32,                 70, SL_MAX_VERSION),
 	SLE_CONDVAR(Industry, selected_layout,            SLE_UINT8,                 73, SL_MAX_VERSION),
 	SLE_CONDARRX(cpp_offsetof(Industry, psa) + cpp_offsetof(Industry::PersistentStorage, storage), SLE_UINT32, 16, 76, SL_MAX_VERSION),
+	SLE_CONDVAR(Industry, random_triggers,            SLE_UINT8,                 82, SL_MAX_VERSION),
+	SLE_CONDVAR(Industry, random,                     SLE_UINT16,                82, SL_MAX_VERSION),
 	/* reserve extra space in savegame here. (currently 32 bytes) */
 	SLE_CONDNULL(32, 2, SL_MAX_VERSION),
 	SLE_END()
 };

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6870	ca3fd1fbe311
child 6872	1c4a4a609f85