openttd-ottdgrfs: comparison src/industry

equal deleted inserted replaced

-:ebf0ece7d8f6
+:eee46cb39750
 /** @file industry_cmd.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "clear_map.h"
-#include "functions.h"
 #include "industry_map.h"
 #include "station_map.h"
 #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 "viewport_func.h"
-#include "command.h"
+#include "command_func.h"
 #include "industry.h"
 #include "town.h"
-#include "vehicle.h"
 #include "news.h"
 #include "saveload.h"
-#include "economy.h"
-#include "sound.h"
 #include "variables.h"
 #include "table/industry_land.h"
 #include "table/build_industry.h"
 #include "genworld.h"
-#include "date.h"
 #include "water_map.h"
 #include "tree_map.h"
 #include "cargotype.h"
 #include "newgrf.h"
 #include "newgrf_commons.h"
 #include "newgrf_industrytiles.h"
 #include "newgrf_callbacks.h"
 #include "misc/autoptr.hpp"
 #include "autoslope.h"
 #include "transparency.h"
+#include "water.h"
+#include "strings_func.h"
+#include "tile_cmd.h"
+#include "functions.h"
+#include "window_func.h"
+#include "date_func.h"
+#include "vehicle_func.h"
+#include "sound_func.h"
 void ShowIndustryViewWindow(int industry);
 void BuildOilRig(TileIndex tile);
 static byte _industry_sound_ctr;
 		SetDParam(0, indspec->name);
 		return_cmd_error(STR_4800_IN_THE_WAY);
 	}
 	if (flags & DC_EXEC) delete i;
-	return CommandCost();
+	return CommandCost(EXPENSES_CONSTRUCTION, indspec->GetRemovalCost());
 }
 static void TransportIndustryGoods(TileIndex tile)
 {
 	Industry *i = GetIndustryByTile(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);
 		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);
 		}
 	}
 		if ((indbehav & INDUSTRYBEH_PLANT_FIELDS) != 0) {
 			bool plant;
 			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 IsSlopeRefused(Slope current, Slope refused)
 {
 	if (IsSteepSlope(current)) return true;
 	if (current != SLOPE_FLAT) {
-		if (refused & SLOPE_STEEP) return true;
+		if (IsSteepSlope(refused)) return true;
 		Slope t = ComplementSlope(current);
-		if (refused & 1 && (t & SLOPE_NW)) return false;
+		if (refused & SLOPE_W && (t & SLOPE_NW)) return true;
-		if (refused & 2 && (t & SLOPE_NE)) return false;
+		if (refused & SLOPE_S && (t & SLOPE_NE)) return true;
-		if (refused & 4 && (t & SLOPE_SW)) return false;
+		if (refused & SLOPE_E && (t & SLOPE_SW)) return true;
-		if (refused & 8 && (t & SLOPE_SE)) return false;
+		if (refused & SLOPE_N && (t & SLOPE_SE)) return true;
 	}
 	return false;
 }
 				refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
 			}
 			if (ind_behav & (INDUSTRYBEH_ONLY_INTOWN | INDUSTRYBEH_TOWN1200_MORE)) {
 				if (!IsTileType(cur_tile, MP_HOUSE)) {
-					_error_message = STR_029D_CAN_ONLY_BE_BUILT_IN_TOWNS;
+					_error_message = STR_030D_CAN_ONLY_BE_BUILT_IN_TOWNS;
 					return false;
 				}
 				if (CmdFailed(DoCommand(cur_tile, 0, 0, 0, CMD_LANDSCAPE_CLEAR))) return false;
 			} else if ((ind_behav & INDUSTRYBEH_ONLY_NEARTOWN) == 0 || !IsTileType(cur_tile, MP_HOUSE)) {
 				if (CmdFailed(DoCommand(cur_tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR))) return false;
 	if (custom_shape_check != NULL) *custom_shape_check = custom_shape;
 	/* It is almost impossible to have a fully flat land in TG, so what we
 	 *  do is that we check if we can make the land flat later on. See
 	 *  CheckIfCanLevelIndustryPlatform(). */
-	return !refused_slope || (_patches.land_generator == LG_TERRAGENESIS && _generating_world && !custom_shape);
+	return !refused_slope || (_patches.land_generator == LG_TERRAGENESIS && _generating_world && !custom_shape && !_ignore_restrictions);
 }
 static bool CheckIfIndustryIsAllowed(TileIndex tile, int type, const Town *t)
 {
 	if ((GetIndustrySpec(type)->behaviour & INDUSTRYBEH_TOWN1200_MORE) && t->population < 1200) {
 		/* 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) {
 			size = it->ti.y;
 			if (size > i->height)i->height = size;
 			DoCommand(cur_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
-			MakeIndustry(cur_tile, i->index, it->gfx);
+			MakeIndustry(cur_tile, i->index, it->gfx, Random());
 			if (_generating_world) {
 				SetIndustryConstructionCounter(cur_tile, 3);
 				SetIndustryConstructionStage(cur_tile, 2);
 			}
 		if (!CheckIfCallBackAllowsCreation(tile, type, itspec_index)) return NULL;
 	} else {
 		if (!_check_new_industry_procs[indspec->check_proc](tile)) return NULL;
 	}
-	if (!custom_shape_check && _patches.land_generator == LG_TERRAGENESIS && _generating_world && !CheckIfCanLevelIndustryPlatform(tile, 0, it, type)) return NULL;
+	if (!custom_shape_check && _patches.land_generator == LG_TERRAGENESIS && _generating_world && !_ignore_restrictions && !CheckIfCanLevelIndustryPlatform(tile, 0, it, type)) return NULL;
 	if (!CheckIfTooCloseToIndustry(tile, type)) return NULL;
 	const Town *t = CheckMultipleIndustryInTown(tile, type);
 	if (t == NULL) return NULL;
 */
 CommandCost CmdBuildIndustry(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	const IndustrySpec *indspec;
-	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	indspec = GetIndustrySpec(p1);
 	/* Check if the to-be built/founded industry is available for this climate. */
 	if (!indspec->enabled) {
 		return CMD_ERROR;
 			/* 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++) {
-					const Industry *ind = CreateNewIndustryHelper(RandomTile(), p1, flags, indspec, RandomRange(indspec->num_table));
+					/* We should not have more than one Random() in a function call
+					 * because parameter evaluation order is not guaranteed in the c++ standard
+					 */
+					tile = RandomTile();
+					const Industry *ind = CreateNewIndustryHelper(tile, p1, flags, indspec, RandomRange(indspec->num_table));
 					if (ind != NULL) {
 						SetDParam(0, indspec->name);
 						if (indspec->new_industry_text > STR_LAST_STRINGID) {
 							SetDParam(1, STR_TOWN);
 							SetDParam(2, ind->town->index);
 		} while (!CheckIfIndustryTilesAreFree(tile, itt[num], num, p1));
 		if (CreateNewIndustryHelper(tile, p1, flags, indspec, num) == NULL) return CMD_ERROR;
 	}
-	return CommandCost(indspec->GetConstructionCost());
+	return CommandCost(EXPENSES_OTHER, indspec->GetConstructionCost());
 }
 Industry *CreateNewIndustry(TileIndex tile, IndustryType type)
 {
 	);
 }
 enum {
 	PERCENT_TRANSPORTED_60 = 153,
+	PERCENT_TRANSPORTED_80 = 204,
 };
 /** 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
 	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)) {
 		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
 				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 - 0x3; break; // Divide production by 32
 				case 0x9: case 0xA: case 0xB:     // Multiply production by 4, 8, 16
 				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;
+				/* If over 60% is transported, mult is 1, else mult is -1. */
 				int mult = (i->last_month_pct_transported[j] > PERCENT_TRANSPORTED_60) ? 1 : -1;
 				new_prod = old_prod = i->production_rate[j];
-				if (only_decrease || CHANCE16(1, 3)) mult *= -1;
+				/* For industries with only_decrease flags (temperate terrain Oil Wells),
+				 * the multiplier will always be -1 so they will only decrease. */
-				if (CHANCE16(1, 22)) {
+				if (only_decrease) {
+					mult = -1;
+				/* For normal industries, if over 60% is transported, 33% chance for decrease.
+				 * Bonus for very high station ratings (over 80%): 16% chance for decrease. */
+				} else if (Chance16I(1, ((i->last_month_pct_transported[j] > PERCENT_TRANSPORTED_80) ? 6 : 3), r)) {
+					mult *= -1;
+				}
+				/* 4.5% chance for 3-23% (or 1 unit for very low productions) production change,
+				 * determined by mult value. If mult = 1 prod. increases, else (-1) it decreases. */
+				if (Chance16I(1, 22, r >> 16)) {
 					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 (abs(percent) >= 10) {
 					ReportNewsProductionChangeIndustry(i, i->produced_cargo[j], percent);
 				}
 			}
 		} 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 more than 60% transported, 66% chance of increase, else 33% chance of increase */
-				if (!only_decrease && (i->last_month_pct_transported[0] > PERCENT_TRANSPORTED_60) != 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->prod_level >>= 1;
 			i->production_rate[0] = (i->production_rate[0] + 1) >> 1;
 			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;
 			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()) {
 			/* Call callback 3C 'disable autosloping for industry tiles'. */
 			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;
+				if ((res == 0) || (res == CALLBACK_FAILED)) return CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
 			} else {
 				/* allow autoslope */
-				return _price.terraform;
+				return CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
 			}
 		}
 	}
 	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 }

branch	noai
changeset 9723	eee46cb39750
parent 9722	ebf0ece7d8f6
child 9724	b39bc69bb2f2