openttd-ottdgrfs: comparison src/industry

equal deleted inserted replaced

-:0b8b245a2391
+:1ac8aac92385
 void BuildOilRig(TileIndex tile);
 static byte _industry_sound_ctr;
 static TileIndex _industry_sound_tile;
+int _total_industries;                      //general counter
+uint16 _industry_counts[NUM_INDUSTRYTYPES]; // Number of industries per type ingame
+const Industry **_industry_sort;
+bool _industry_sort_dirty;
+IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];
+IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];
+/** This function initialize the spec arrays of both
+* industry and industry tiles.
+* It adjusts the enabling of the industry too, based on climate availability.
+* This will allow for clearer testings */
+void ResetIndustries()
+{
+	memset(&_industry_specs, 0, sizeof(_industry_specs));
+	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 = 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));
+}
 /**
 * Called if a new block is added to the industry-pool
 */
 static void IndustryPoolNewBlock(uint start_item)
 {
 /**
 * Accessor for array _industry_tile_specs.
 * This will ensure at once : proper access and
 * not allowing modifications of it.
 * @param gfx of industrytile (which is the index in _industry_specs)
-* @pre gfx < NUM_INDUSTRY_GFXES
+* @pre gfx < INVALID_INDUSTRYTILE
 * @return a pointer to the corresponding industrytile spec
 **/
 const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)
 {
-	assert(gfx < NUM_INDUSTRY_GFXES);
+	assert(gfx < INVALID_INDUSTRYTILE);
 	return &_industry_tile_specs[gfx];
 }
 void DestroyIndustry(Industry *i)
 {
 			}
 		} END_TILE_LOOP(tile_cur, 42, 42, i->xy - TileDiff(21, 21))
 	}
 	_industry_sort_dirty = true;
-	_total_industries--;
+	DecIndustryTypeCount(i->type);
 	DeleteSubsidyWithIndustry(i->index);
 	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);
 	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);
 }
 static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)
 {
 	const IndustryTileSpec *itspec = GetIndustryTileSpec(GetIndustryGfx(tile));
 	CargoID a;
-	a = itspec->accepts_cargo[0];
+	for (byte i = 0; i < lengthof(itspec->accepts_cargo); i++) {
-	if (a != CT_INVALID) ac[a] = (a == CT_PASSENGERS) ? 1 : 8;
+		a = itspec->accepts_cargo[i];
+		if (a != CT_INVALID) ac[a] = itspec->acceptance[i];
-	a = itspec->accepts_cargo[1];
+	}
-	if (a != CT_INVALID) ac[a] = 8;
-	a = itspec->accepts_cargo[2];
-	if (a != CT_INVALID) ac[a] = 8;
 }
 static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)
 {
 	const Industry *i = GetIndustryByTile(tile);
 		i->cargo_waiting[0] -= cw;
 		/* fluctuating economy? */
 		if (_economy.fluct <= 0) cw = (cw + 1) / 2;
-		i->last_mo_production[0] += cw;
+		i->this_month_production[0] += cw;
 		am = MoveGoodsToStation(i->xy, i->width, i->height, indspec->produced_cargo[0], cw);
-		i->last_mo_transported[0] += am;
+		i->this_month_transported[0] += am;
 		if (am != 0) {
 			uint newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_production;
-			if (newgfx != INDUTILE_NOANIM) {
+			if (newgfx != INDUSTRYTILE_NOANIM) {
 				ResetIndustryConstructionStage(tile);
 				SetIndustryCompleted(tile, true);
 				SetIndustryGfx(tile, newgfx);
 				MarkTileDirtyByTile(tile);
 			}
 	if (cw > indspec->minimal_cargo) {
 		i->cargo_waiting[1] -= cw;
 		if (_economy.fluct <= 0) cw = (cw + 1) / 2;
-		i->last_mo_production[1] += cw;
+		i->this_month_production[1] += cw;
 		am = MoveGoodsToStation(i->xy, i->width, i->height, indspec->produced_cargo[1], cw);
-		i->last_mo_transported[1] += am;
+		i->this_month_transported[1] += am;
 	}
 }
 static void AnimateTile_Industry(TileIndex tile)
 	if (_game_mode == GM_EDITOR) return;
 	TransportIndustryGoods(tile);
 	newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_next;
-	if (newgfx != INDUTILE_NOANIM) {
+	if (newgfx != INDUSTRYTILE_NOANIM) {
 		ResetIndustryConstructionStage(tile);
 		SetIndustryGfx(tile, newgfx);
 		MarkTileDirtyByTile(tile);
 		return;
 	}
 static void ClickTile_Industry(TileIndex tile)
 {
 	ShowIndustryViewWindow(GetIndustryIndex(tile));
 }
-static uint32 GetTileTrackStatus_Industry(TileIndex tile, TransportType mode)
+static uint32 GetTileTrackStatus_Industry(TileIndex tile, TransportType mode, uint sub_mode)
 {
 	return 0;
 }
 static void GetProducedCargo_Industry(TileIndex tile, CargoID *b)
 	FOR_ALL_INDUSTRIES(i) {
 		/* check if an industry that accepts the same goods is nearby */
 		if (DistanceMax(tile, i->xy) <= 14 &&
 				indspec->accepts_cargo[0] != CT_INVALID &&
-				indspec->accepts_cargo[0] == indspec->accepts_cargo[0] && (
+				indspec->accepts_cargo[0] == GetIndustrySpec(i->type)->accepts_cargo[0] && (
 					_game_mode != GM_EDITOR ||
 					!_patches.same_industry_close ||
 					!_patches.multiple_industry_per_town
 				)) {
 			_error_message = STR_INDUSTRY_TOO_CLOSE;
 {
 	const IndustrySpec *indspec = GetIndustrySpec(type);
 	uint32 r;
 	int j;
-	_total_industries++;
 	i->xy = tile;
 	i->width = i->height = 0;
 	i->type = type;
+	IncIndustryTypeCount(type);
 	i->production_rate[0] = indspec->production_rate[0];
 	i->production_rate[1] = indspec->production_rate[1];
 	if (_patches.smooth_economy) {
 	r = Random();
 	i->random_color = GB(r, 8, 4);
 	i->counter = GB(r, 0, 12);
 	i->cargo_waiting[0] = 0;
 	i->cargo_waiting[1] = 0;
-	i->last_mo_production[0] = 0;
+	i->this_month_production[0] = 0;
-	i->last_mo_production[1] = 0;
+	i->this_month_production[1] = 0;
-	i->last_mo_transported[0] = 0;
+	i->this_month_transported[0] = 0;
-	i->last_mo_transported[1] = 0;
+	i->this_month_transported[1] = 0;
-	i->pct_transported[0] = 0;
+	i->last_month_pct_transported[0] = 0;
-	i->pct_transported[1] = 0;
+	i->last_month_pct_transported[1] = 0;
-	i->total_transported[0] = 0;
+	i->last_month_transported[0] = 0;
-	i->total_transported[1] = 0;
+	i->last_month_transported[1] = 0;
 	i->was_cargo_delivered = false;
 	i->last_prod_year = _cur_year;
-	i->total_production[0] = i->production_rate[0] * 8;
+	i->last_month_production[0] = i->production_rate[0] * 8;
-	i->total_production[1] = i->production_rate[1] * 8;
+	i->last_month_production[1] = i->production_rate[1] * 8;
-	if (!_generating_world) i->total_production[0] = i->total_production[1] = 0;
+	if (!_generating_world) i->last_month_production[0] = i->last_month_production[1] = 0;
 	i->prod_level = 0x10;
 	do {
 		TileIndex cur_tile = tile + ToTileIndexDiff(it->ti);
 	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	indspec = GetIndustrySpec(p1);
 	/* Check if the to-be built/founded industry is available for this climate. */
-	if (!HASBIT(indspec->climate_availability, _opt_ptr->landscape)) return CMD_ERROR;
+	if (!indspec->enabled) {
+		return CMD_ERROR;
+	}
 	/* If the patch for raw-material industries is not on, you cannot build raw-material industries.
 	 * Raw material industries are industries that do not accept cargo (at least for now)
 	 * Exclude the lumber mill (only "raw" industry that can be built) */
 	if (!_patches.build_rawmaterial_ind &&
 			indspec->accepts_cargo[0] == CT_INVALID &&
 			indspec->accepts_cargo[1] == CT_INVALID &&
 			indspec->accepts_cargo[2] == CT_INVALID &&
-			p1 != IT_LUMBER_MILL) {
+			!(indspec->behaviour & INDUSTRYBEH_CUT_TREES)) {
 		return CMD_ERROR;
 	}
 	num = indspec->num_table;
 	itt = indspec->table;
 		if (--num < 0) return_cmd_error(STR_0239_SITE_UNSUITABLE);
 	} while (!CheckIfIndustryTilesAreFree(tile, it = itt[num], p1));
 	if (CreateNewIndustryHelper(tile, p1, flags, indspec, it) == NULL) return CMD_ERROR;
-	return (_eco->GetPrice(CEconomy::BUILD_INDUSTRY) >> 5) * indspec->cost_multiplier;
+	return (_eco->GetPrice(CEconomy::BUILD_INDUSTRY) >> 8) * indspec->cost_multiplier;
 }
 Industry *CreateNewIndustry(TileIndex tile, IndustryType type)
 {
 * @param type IndustryType of the desired industry
 * @param amount of industries that need to be built */
 static void PlaceInitialIndustry(IndustryType type, int amount)
 {
 	int num = _numof_industry_table[_opt.diff.number_industries][amount];
+	const IndustrySpec *ind_spc = GetIndustrySpec(type);
 	/* These are always placed next to the coastline, so we scale by the perimeter instead. */
-	num = (type == IT_OIL_REFINERY || type == IT_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);
+	num = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);
 	if (_opt.diff.number_industries != 0) {
 		PlayerID old_player = _current_player;
 		_current_player = OWNER_NONE;
 		assert(num > 0);
 	IndustryType it;
 	const IndustrySpec *ind_spc;
 	/* Find the total amount of industries */
 	for (it = IT_COAL_MINE; it < NUM_INDUSTRYTYPES; it++) {
-		int num;
 		ind_spc = GetIndustrySpec(it);
-		chance = ind_spc->appear_creation[_opt.landscape];
+		if (ind_spc->enabled) {
+			chance = ind_spc->appear_creation[_opt.landscape];
-		if (chance > 0) {
+			if (chance > 0) {
-			/* once the chance of appearance is determind, it have to be scaled by
+				/* once the chance of appearance is determind, it have to be scaled by
-			 * the difficulty level. The "chance" in question is more an index into
+				 * the difficulty level. The "chance" in question is more an index into
-			 * the _numof_industry_table,in fact */
+				 * the _numof_industry_table,in fact */
-			num = _numof_industry_table[_opt.diff.number_industries][chance];
+				int num = _numof_industry_table[_opt.diff.number_industries][chance];
-			/* These are always placed next to the coastline, so we scale by the perimeter instead. */
+				/* These are always placed next to the coastline, so we scale by the perimeter instead. */
-			num = (it == IT_OIL_REFINERY || it == IT_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);
+				num = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);
-			i += num;
+				i += num;
+			}
 		}
 	}
 	SetGeneratingWorldProgress(GWP_INDUSTRY, i);
 		/* Once the number of industries has been determined, let's really create them.
 		 * The test for chance allows us to try create industries that are available only
 		 * for this landscape.
 		 * @todo :  Do we really have to pass chance as un-scaled value, since we've already
 		 *          processed that scaling above? No, don't think so.  Will find a way. */
-		chance = GetIndustrySpec(it)->appear_creation[_opt.landscape];
+		ind_spc = GetIndustrySpec(it);
-		if (chance > 0) PlaceInitialIndustry(it, chance);
+		if (ind_spc->enabled) {
+			chance = ind_spc->appear_creation[_opt.landscape];
+			if (chance > 0) PlaceInitialIndustry(it, chance);
+		}
 	};
 }
 /* Change industry production or do closure */
 static void ExtChangeIndustryProduction(Industry *i)
 				int mag;
 				new_prod = old_prod = i->production_rate[j];
 				if (CHANCE16I(20, 1024, r))
 					new_prod -= ((RandomRange(50) + 10) * old_prod) >> 8;
-				if (CHANCE16I(20 + (i->pct_transported[j] * 20 >> 8), 1024, r >> 16))
+				if (CHANCE16I(20 + (i->last_month_pct_transported[j] * 20 >> 8), 1024, r >> 16))
 					new_prod += ((RandomRange(50) + 10) * old_prod) >> 8;
 				new_prod = clamp(new_prod, 0, 255);
 				if (new_prod == old_prod) {
 					closeit = false;
 	const IndustrySpec *indsp = GetIndustrySpec(i->type);
 	for (byte j = 0; j < lengthof(indsp->produced_cargo); j++) {
 		if (indsp->produced_cargo[j] != CT_INVALID) {
 			pct = 0;
-			if (i->last_mo_production[j] != 0) {
+			if (i->this_month_production[j] != 0) {
 				i->last_prod_year = _cur_year;
-				pct = min(i->last_mo_transported[j] * 256 / i->last_mo_production[j], 255);
+				pct = min(i->this_month_transported[j] * 256 / i->this_month_production[j], 255);
 			}
-			i->pct_transported[j] = pct;
+			i->last_month_pct_transported[j] = pct;
-			i->total_production[j] = i->last_mo_production[j];
+			i->last_month_production[j] = i->this_month_production[j];
-			i->last_mo_production[j] = 0;
+			i->this_month_production[j] = 0;
-			i->total_transported[j] = i->last_mo_transported[j];
+			i->last_month_transported[j] = i->this_month_transported[j];
-			i->last_mo_transported[j] = 0;
+			i->this_month_transported[j] = 0;
 			refresh = true;
 		}
 	}
 	if (refresh)
 			if ((indspec->behaviour & INDUSTRYBEH_DONT_INCR_PROD) && _opt.landscape == LT_TEMPERATE)
 				only_decrease = true;
 			if (only_decrease || CHANCE16(1, 3)) {
 				/* If you transport > 60%, 66% chance we increase, else 33% chance we increase */
-				if (!only_decrease && (i->pct_transported[0] > 153) != CHANCE16(1, 3)) {
+				if (!only_decrease && (i->last_month_pct_transported[0] > 153) != CHANCE16(1, 3)) {
 					/* Increase production */
 					if (i->prod_level != 0x80) {
 						byte b;
 						i->prod_level <<= 1;
 void InitializeIndustries()
 {
 	CleanPool(&_Industry_pool);
 	AddBlockToPool(&_Industry_pool);
-	_total_industries = 0;
+	ResetIndustryCounts();
 	_industry_sort_dirty = true;
 	_industry_sound_tile = 0;
 }
 extern const TileTypeProcs _tile_type_industry_procs = {
 	NULL,                        /* vehicle_enter_tile_proc */
 	GetSlopeTileh_Industry,      /* get_slope_tileh_proc */
 };
 static const SaveLoad _industry_desc[] = {
-	SLE_CONDVAR(Industry, xy,                  SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
+	SLE_CONDVAR(Industry, xy,                         SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Industry, xy,                  SLE_UINT32,                  6, SL_MAX_VERSION),
+	SLE_CONDVAR(Industry, xy,                         SLE_UINT32,                  6, SL_MAX_VERSION),
-	    SLE_VAR(Industry, width,               SLE_UINT8),
+	    SLE_VAR(Industry, width,                      SLE_UINT8),
-	    SLE_VAR(Industry, height,              SLE_UINT8),
+	    SLE_VAR(Industry, height,                     SLE_UINT8),
-	    SLE_REF(Industry, town,                REF_TOWN),
+	    SLE_REF(Industry, town,                       REF_TOWN),
 	SLE_CONDNULL( 2, 2, 60),       ///< used to be industry's produced_cargo
-	    SLE_ARR(Industry, cargo_waiting,       SLE_UINT16, 2),
+	    SLE_ARR(Industry, cargo_waiting,              SLE_UINT16, 2),
-	    SLE_ARR(Industry, production_rate,     SLE_UINT8,  2),
+	    SLE_ARR(Industry, production_rate,            SLE_UINT8,  2),
 	SLE_CONDNULL( 3, 2, 60),       ///< used to be industry's accepts_cargo
-	    SLE_VAR(Industry, prod_level,          SLE_UINT8),
+	    SLE_VAR(Industry, prod_level,                 SLE_UINT8),
-	    SLE_ARR(Industry, last_mo_production,  SLE_UINT16, 2),
+	    SLE_ARR(Industry, this_month_production,      SLE_UINT16, 2),
-	    SLE_ARR(Industry, last_mo_transported, SLE_UINT16, 2),
+	    SLE_ARR(Industry, this_month_transported,     SLE_UINT16, 2),
-	    SLE_ARR(Industry, pct_transported,     SLE_UINT8,  2),
+	    SLE_ARR(Industry, last_month_pct_transported, SLE_UINT8,  2),
-	    SLE_ARR(Industry, total_production,    SLE_UINT16, 2),
+	    SLE_ARR(Industry, last_month_production,      SLE_UINT16, 2),
-	    SLE_ARR(Industry, total_transported,   SLE_UINT16, 2),
+	    SLE_ARR(Industry, last_month_transported,     SLE_UINT16, 2),
-	    SLE_VAR(Industry, counter,             SLE_UINT16),
+	    SLE_VAR(Industry, counter,                    SLE_UINT16),
-	    SLE_VAR(Industry, type,                SLE_UINT8),
+	    SLE_VAR(Industry, type,                       SLE_UINT8),
-	    SLE_VAR(Industry, owner,               SLE_UINT8),
+	    SLE_VAR(Industry, owner,                      SLE_UINT8),
-	    SLE_VAR(Industry, random_color,        SLE_UINT8),
+	    SLE_VAR(Industry, random_color,               SLE_UINT8),
-	SLE_CONDVAR(Industry, last_prod_year,      SLE_FILE_U8 | SLE_VAR_I32,  0, 30),
+	SLE_CONDVAR(Industry, last_prod_year,             SLE_FILE_U8 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Industry, last_prod_year,      SLE_INT32,                 31, SL_MAX_VERSION),
+	SLE_CONDVAR(Industry, last_prod_year,             SLE_INT32,                 31, SL_MAX_VERSION),
-	    SLE_VAR(Industry, was_cargo_delivered, SLE_UINT8),
+	    SLE_VAR(Industry, was_cargo_delivered,        SLE_UINT8),
 	/* reserve extra space in savegame here. (currently 32 bytes) */
 	SLE_CONDNULL(32, 2, SL_MAX_VERSION),
 	SLE_END()
 static void Load_INDY()
 {
 	int index;
-	_total_industries = 0;
+	ResetIndustryCounts();
 	while ((index = SlIterateArray()) != -1) {
 		Industry *i;
 		if (!AddBlockIfNeeded(&_Industry_pool, index))
 			error("Industries: failed loading savegame: too many industries");
 		i = GetIndustry(index);
 		SlObject(i, _industry_desc);
+		IncIndustryTypeCount(i->type);
-		_total_industries++;
 	}
 }
 extern const ChunkHandler _industry_chunk_handlers[] = {
 	{ 'INDY', Save_INDY, Load_INDY, CH_ARRAY | CH_LAST},

branch	gamebalance
changeset 9912	1ac8aac92385
parent 9911	0b8b245a2391
child 9913	e79cd19772dd