openttd-ottdgrfs: comparison src/economy.cpp

equal deleted inserted replaced

-:ebf0ece7d8f6
+:eee46cb39750
 /** @file economy.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "currency.h"
-#include "functions.h"
 #include "landscape.h"
-#include "strings.h" // XXX InjectDParam()
 #include "table/strings.h"
 #include "table/sprites.h"
-#include "map.h"
 #include "news.h"
 #include "player.h"
 #include "station.h"
-#include "vehicle.h"
+#include "command_func.h"
-#include "window.h"
-#include "gfx.h"
-#include "command.h"
 #include "saveload.h"
-#include "economy.h"
 #include "industry.h"
 #include "town.h"
 #include "network/network.h"
-#include "sound.h"
 #include "engine.h"
 #include "network/network_data.h"
 #include "variables.h"
 #include "vehicle_gui.h"
 #include "ai/ai.h"
 #include "newgrf_sound.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_industries.h"
 #include "newgrf_industrytiles.h"
 #include "unmovable.h"
-#include "date.h"
 #include "cargotype.h"
 #include "player_face.h"
 #include "group.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"
+#include "track_type.h"
+#include "track_func.h"
+#include "rail_map.h"
+#include "gfx_func.h"
 /**
 * Multiply two integer values and shift the results to right.
 *
 * This function multiplies two integer values. The result is
 	{ SCORE_LOAN,         250000,  50 },
 	{ SCORE_TOTAL,             0,   0 }
 };
 int _score_part[MAX_PLAYERS][SCORE_END];
+Economy _economy;
+Subsidy _subsidies[MAX_PLAYERS];
+Prices _price;
+uint16 _price_frac[NUM_PRICES];
+Money  _cargo_payment_rates[NUM_CARGO];
+uint16 _cargo_payment_rates_frac[NUM_CARGO];
+Money _additional_cash_required;
 Money CalculateCompanyValue(const Player* p)
 {
 	PlayerID owner = p->index;
-	/* Do a little nasty by using CommandCost, so we can use the "overflow" protection of CommandCost */
 	Money value = 0;
 	Station *st;
 	uint num = 0;
 		uint i;
 		/* See if the old_player had shares in other companies */
 		_current_player = old_player;
 		FOR_ALL_PLAYERS(p) {
+			if (!p->is_active) continue;
 			for (i = 0; i < 4; i++) {
 				if (p->share_owners[i] == old_player) {
 					/* Sell his shares */
 					CommandCost res = DoCommand(0, p->index, 0, DC_EXEC, CMD_SELL_SHARE_IN_COMPANY);
 					/* Because we are in a DoCommand, we can't just execute an other one and
 				}
 			}
 		}
 		FOR_ALL_VEHICLES(v) {
-			if (v->owner == old_player && IS_BYTE_INSIDE(v->type, VEH_TRAIN, VEH_AIRCRAFT + 1)) {
+			if (v->owner == old_player && IsInsideMM(v->type, VEH_TRAIN, VEH_AIRCRAFT + 1)) {
 				if (new_player == PLAYER_SPECTATOR) {
 					DeleteWindowById(WC_VEHICLE_VIEW, v->index);
 					DeleteWindowById(WC_VEHICLE_DETAILS, v->index);
 					DeleteWindowById(WC_VEHICLE_ORDERS, v->index);
 								break;
 						}
 					}
 				} else {
 					v->owner = new_player;
+					v->colormap = PAL_NONE;
 					v->group_id = DEFAULT_GROUP;
 					if (IsEngineCountable(v)) GetPlayer(new_player)->num_engines[v->engine_type]++;
 					switch (v->type) {
 						case VEH_TRAIN:    if (IsFrontEngine(v)) v->unitnumber = ++num_train; break;
 						case VEH_ROAD:     if (IsRoadVehFront(v)) v->unitnumber = ++num_road; break;
 	{
 		TileIndex tile = 0;
 		do {
 			ChangeTileOwner(tile, old_player, new_player);
 		} while (++tile != MapSize());
+		if (new_player != PLAYER_SPECTATOR) {
+			/* Update all signals because there can be new segment that was owned by two players
+			 * and signals were not propagated */
+			tile = 0;
+			do {
+				if (IsTileType(tile, MP_RAILWAY) && IsTileOwner(tile, new_player) && HasSignals(tile)) {
+					TrackBits tracks = GetTrackBits(tile);
+					do { // there may be two tracks with signals for TRACK_BIT_HORZ and TRACK_BIT_VERT
+						Track track = RemoveFirstTrack(&tracks);
+						if (HasSignalOnTrack(tile, track)) SetSignalsOnBothDir(tile, track);
+					} while (tracks != TRACK_BIT_NONE);
+				}
+			} while (++tile != MapSize());
+		}
 	}
 	/* Change color of existing windows */
 	if (new_player != PLAYER_SPECTATOR) ChangeWindowOwner(old_player, new_player);
 	Station *st;
 	Player *p;
 	FOR_ALL_STATIONS(st) {
 		_current_player = st->owner;
-		SET_EXPENSES_TYPE(EXPENSES_PROPERTY);
+		CommandCost cost(EXPENSES_PROPERTY, _price.station_value >> 1);
-		SubtractMoneyFromPlayer(_price.station_value >> 1);
+		SubtractMoneyFromPlayer(cost);
 	}
 	if (!HasBit(1<<0|1<<3|1<<6|1<<9, _cur_month))
 		return;
 	FOR_ALL_PLAYERS(p) {
 		if (!p->is_active) continue;
 		_current_player = p->index;
-		SET_EXPENSES_TYPE(EXPENSES_LOAN_INT);
+		SubtractMoneyFromPlayer(CommandCost(EXPENSES_LOAN_INT, (Money)BigMulSU(p->current_loan, interest, 16)));
-		SubtractMoneyFromPlayer(CommandCost((Money)BigMulSU(p->current_loan, interest, 16)));
+		SubtractMoneyFromPlayer(CommandCost(EXPENSES_OTHER, _price.station_value >> 2));
-		SET_EXPENSES_TYPE(EXPENSES_OTHER);
-		SubtractMoneyFromPlayer(_price.station_value >> 2);
 	}
 }
 static void HandleEconomyFluctuations()
 {
 	 700000, ///< aircraft_base
 	  14000, ///< roadveh_base
 	  65000, ///< ship_base
 	     20, ///< build_trees
 	    250, ///< terraform
-	     20, ///< clear_1
+	     20, ///< clear_grass
-	     40, ///< purchase_land
+	     40, ///< clear_roughland
-	    200, ///< clear_2
+	    200, ///< clear_rocks
-	    500, ///< clear_3
+	    500, ///< clear_fields
 	     20, ///< remove_trees
 	    -70, ///< remove_rail
 	     10, ///< remove_signals
 	     50, ///< clear_bridge
 	     80, ///< remove_train_depot
 			s->age++;
 		}
 	}
 	/* 25% chance to go on */
-	if (CHANCE16(1,4)) {
+	if (Chance16(1,4)) {
 		/*  Find a free slot*/
 		s = _subsidies;
 		while (s->cargo_type != CT_INVALID) {
 			if (++s == endof(_subsidies))
 				goto no_add;
 		ShowFeederIncomeAnimation(front_v->x_pos, front_v->y_pos, front_v->z_pos, virtual_profit);
 	}
 	if (route_profit != 0) {
 		front_v->profit_this_year += vehicle_profit;
-		SubtractMoneyFromPlayer(-route_profit);
+		SubtractMoneyFromPlayer(CommandCost(front_v->GetExpenseType(true), -route_profit));
 		if (IsLocalPlayer() && !PlayVehicleSound(front_v, VSE_LOAD_UNLOAD)) {
 			SndPlayVehicleFx(SND_14_CASHTILL, front_v);
 		}
 			}
 		}
 		return;
 	}
-	if (v->type == VEH_TRAIN && !IsTileType(v->tile, MP_STATION)) {
+	StationID last_visited = v->last_station_visited;
+	Station *st = GetStation(last_visited);
+	if (v->type == VEH_TRAIN && (!IsTileType(v->tile, MP_STATION) || GetStationIndex(v->tile) != st->index)) {
 		/* The train reversed in the station. Take the "easy" way
 		 * out and let the train just leave as it always did. */
 		SetBit(v->vehicle_flags, VF_LOADING_FINISHED);
 		return;
 	}
 	bool anything_loaded   = false;
 	uint32 cargo_not_full  = 0;
 	uint32 cargo_full      = 0;
 	v->cur_speed = 0;
-	StationID last_visited = v->last_station_visited;
-	Station *st = GetStation(last_visited);
 	for (; v != NULL; v = v->Next()) {
 		if (v->cargo_cap == 0) continue;
 		byte load_amount = EngInfo(v->engine_type)->load_amount;
 	value = CalculateCompanyValue(p) >> 2;
 	PlayerID old_player = _current_player;
 	for (i = 0; i != 4; i++) {
 		if (p->share_owners[i] != PLAYER_SPECTATOR) {
-			SET_EXPENSES_TYPE(EXPENSES_OTHER);
 			_current_player = p->share_owners[i];
-			SubtractMoneyFromPlayer(CommandCost(-value));
+			SubtractMoneyFromPlayer(CommandCost(EXPENSES_OTHER, -value));
 		}
 	}
 	_current_player = old_player;
 	p->is_active = false;
 * @param p2 unused
 */
 CommandCost CmdBuyShareInCompany(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Player *p;
-	CommandCost cost;
+	CommandCost cost(EXPENSES_OTHER);
 	/* Check if buying shares is allowed (protection against modified clients) */
 	/* Cannot buy own shares */
 	if (!IsValidPlayer((PlayerID)p1) || !_patches.allow_shares || _current_player == (PlayerID)p1) return CMD_ERROR;
 	p = GetPlayer((PlayerID)p1);
 	/* Cannot buy shares of non-existent nor bankrupted company */
 	if (!p->is_active) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	/* Protect new companies from hostile takeovers */
 	if (_cur_year - p->inaugurated_year < 6) return_cmd_error(STR_7080_PROTECTED);
 	/* Those lines are here for network-protection (clients can be slow) */
 	p = GetPlayer((PlayerID)p1);
 	/* Cannot sell shares of non-existent nor bankrupted company */
 	if (!p->is_active) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	/* Those lines are here for network-protection (clients can be slow) */
 	if (GetAmountOwnedBy(p, _current_player) == 0) return CommandCost();
 	/* adjust it a little to make it less profitable to sell and buy */
 	cost = CalculateCompanyValue(p) >> 2;
 		PlayerByte* b = p->share_owners;
 		while (*b != _current_player) b++; // share owners is guaranteed to contain player
 		*b = PLAYER_SPECTATOR;
 		InvalidateWindow(WC_COMPANY, p1);
 	}
-	return CommandCost(cost);
+	return CommandCost(EXPENSES_OTHER, cost);
 }
 /** Buy up another company.
 * When a competing company is gone bankrupt you get the chance to purchase
 * that company.
 	if (!IsValidPlayer(pid) || _networking) return CMD_ERROR;
 	/* Do not allow players to take over themselves */
 	if (pid == _current_player) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_OTHER);
 	p = GetPlayer(pid);
 	if (!p->is_ai) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		DoAcquireCompany(p);
 	}
-	return CommandCost(p->bankrupt_value);
+	return CommandCost(EXPENSES_OTHER, p->bankrupt_value);
 }
 /** Prices */
 static void SaveLoad_PRIC()
 {

branch	noai
changeset 9723	eee46cb39750
parent 9722	ebf0ece7d8f6
child 9724	b39bc69bb2f2