openttd-mini: comparison src/openttd.cpp

equal deleted inserted replaced

-:0050610c0368
+:c291a21b304e
 void ResetOldNames();
 void ProcessAsyncSaveFinish();
 void CallWindowTickEvent();
 extern void SetDifficultyLevel(int mode, DifficultySettings *gm_opt);
-extern Player* DoStartupNewPlayer(bool is_ai);
+extern Company *DoStartupNewCompany(bool is_ai);
 extern void ShowOSErrorBox(const char *buf, bool system);
 extern void InitializeRailGUI();
 /**
 * Error handling for fatal user errors.
 		"  -d [[fac=]lvl[,...]]= Debug mode\n"
 		"  -e                  = Start Editor\n"
 		"  -g [savegame]       = Start new/save game immediately\n"
 		"  -G seed             = Set random seed\n"
 #if defined(ENABLE_NETWORK)
-		"  -n [ip:port#player] = Start networkgame\n"
+		"  -n [ip:port#company]= Start networkgame\n"
 		"  -D [ip][:port]      = Start dedicated server\n"
 		"  -l ip[:port]        = Redirect DEBUG()\n"
 #if !defined(__MORPHOS__) && !defined(__AMIGA__) && !defined(WIN32)
 		"  -f                  = Fork into the background (dedicated only)\n"
 #endif
 static void InitializeDynamicVariables()
 {
 	/* Dynamic stuff needs to be initialized somewhere... */
 	_industry_mngr.ResetMapping();
 	_industile_mngr.ResetMapping();
-	_Player_pool.AddBlockToPool();
+	_Company_pool.AddBlockToPool();
 }
 /** Unitializes drivers, frees allocated memory, cleans pools, ...
 * Generally, prepares the game for shutting down
 	_Sign_pool.CleanPool();
 	_Order_pool.CleanPool();
 	_Group_pool.CleanPool();
 	_CargoPacket_pool.CleanPool();
 	_Engine_pool.CleanPool();
-	_Player_pool.CleanPool();
+	_Company_pool.CleanPool();
 	free(_config_file);
 	/* Close all and any open filehandles */
 	FioCloseAll();
 	/* Load the default opening screen savegame */
 	if (SaveOrLoad("opntitle.dat", SL_LOAD, DATA_DIR) != SL_OK) {
 		GenerateWorld(GW_EMPTY, 64, 64); // if failed loading, make empty world.
 		WaitTillGeneratedWorld();
-		SetLocalPlayer(PLAYER_SPECTATOR);
+		SetLocalCompany(COMPANY_SPECTATOR);
 	} else {
-		SetLocalPlayer(PLAYER_FIRST);
+		SetLocalCompany(COMPANY_FIRST);
 	}
 	_pause_game = 0;
 	_cursor.fix_at = false;
 	MarkWholeScreenDirty();
 			strcpy(videodriver, "dedicated");
 			strcpy(blitter, "null");
 			dedicated = true;
 			if (mgo.opt != NULL) {
 				/* Use the existing method for parsing (openttd -n).
-				 * However, we do ignore the #player part. */
+				 * However, we do ignore the #company part. */
 				const char *temp = NULL;
 				const char *port = NULL;
 				ParseConnectionString(&temp, &port, mgo.opt);
 				if (!StrEmpty(mgo.opt)) dedicated_host = mgo.opt;
 				if (port != NULL) dedicated_port = atoi(port);
 #ifdef ENABLE_NETWORK
 	if (network && _network_available) {
 		if (network_conn != NULL) {
 			const char *port = NULL;
-			const char *player = NULL;
+			const char *company = NULL;
 			uint16 rport;
 			rport = NETWORK_DEFAULT_PORT;
-			_network_playas = PLAYER_NEW_COMPANY;
+			_network_playas = COMPANY_NEW_COMPANY;
-			ParseConnectionString(&player, &port, network_conn);
+			ParseConnectionString(&company, &port, network_conn);
-			if (player != NULL) {
+			if (company != NULL) {
-				_network_playas = (PlayerID)atoi(player);
+				_network_playas = (CompanyID)atoi(company);
-				if (_network_playas != PLAYER_SPECTATOR) {
+				if (_network_playas != COMPANY_SPECTATOR) {
 					_network_playas--;
-					if (_network_playas >= MAX_PLAYERS) return false;
+					if (_network_playas >= MAX_COMPANIES) return false;
 				}
 			}
 			if (port != NULL) rport = atoi(port);
 			LoadIntroGame();
 {
 	SettingsDisableElrail(_settings_game.vehicle.disable_elrails);
 	/* In a dedicated server, the server does not play */
 	if (_network_dedicated) {
-		SetLocalPlayer(PLAYER_SPECTATOR);
+		SetLocalCompany(COMPANY_SPECTATOR);
 		return;
 	}
-	/* Create a single player */
+	/* Create a single company */
-	DoStartupNewPlayer(false);
+	DoStartupNewCompany(false);
-	SetLocalPlayer(PLAYER_FIRST);
+	SetLocalCompany(COMPANY_FIRST);
-	_current_player = _local_player;
+	_current_company = _local_company;
 	DoCommandP(0, (_settings_client.gui.autorenew << 15 ) | (_settings_client.gui.autorenew_months << 16) | 4, _settings_client.gui.autorenew_money, NULL, CMD_SET_AUTOREPLACE);
 	InitializeRailGUI();
 #ifdef ENABLE_NETWORK
-	/* We are the server, we start a new player (not dedicated),
+	/* We are the server, we start a new company (not dedicated),
 	 * so set the default password *if* needed. */
 	if (_network_server && !StrEmpty(_settings_client.network.default_company_pass)) {
 		char *password = _settings_client.network.default_company_pass;
 		NetworkChangeCompanyPassword(1, &password);
 	}
 	GenerateWorld(from_heightmap ? GW_HEIGHTMAP : GW_NEWGAME, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
 }
 static void MakeNewEditorWorldDone()
 {
-	SetLocalPlayer(OWNER_NONE);
+	SetLocalCompany(OWNER_NONE);
 	MarkWholeScreenDirty();
 }
 static void MakeNewEditorWorld()
 	GenerateWorldSetCallback(&MakeNewEditorWorldDone);
 	GenerateWorld(GW_EMPTY, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
 }
-void StartupPlayers();
+void StartupCompanies();
 void StartupDisasters();
 extern void StartupEconomy();
 /**
 * Start Scenario starts a new game based on a scenario.
 	_settings_game.difficulty = _settings_newgame.difficulty;
 	/* Inititalize data */
 	StartupEconomy();
-	StartupPlayers();
+	StartupCompanies();
 	StartupEngines();
 	StartupDisasters();
-	SetLocalPlayer(PLAYER_FIRST);
+	SetLocalCompany(COMPANY_FIRST);
-	_current_player = _local_player;
+	_current_company = _local_company;
 	DoCommandP(0, (_settings_client.gui.autorenew << 15 ) | (_settings_client.gui.autorenew_months << 16) | 4, _settings_client.gui.autorenew_money, NULL, CMD_SET_AUTOREPLACE);
 	MarkWholeScreenDirty();
 }
 				ShowErrorMessage(INVALID_STRING_ID, STR_012D, 0, 0);
 			} else {
 				if (_saveload_mode == SLD_LOAD_SCENARIO) {
 					StartupEngines();
 				}
-				/* Update the local player for a loaded game. It is either always
+				/* Update the local company for a loaded game. It is either always
-				* player #1 (eg 0) or in the case of a dedicated server a spectator */
+				* company #1 (eg 0) or in the case of a dedicated server a spectator */
-				SetLocalPlayer(_network_dedicated ? PLAYER_SPECTATOR : PLAYER_FIRST);
+				SetLocalCompany(_network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST);
 				/* Decrease pause counter (was increased from opening load dialog) */
 				DoCommandP(0, 0, 0, NULL, CMD_PAUSE);
 #ifdef ENABLE_NETWORK
 				if (_network_server) {
 					snprintf(_network_game_info.map_name, lengthof(_network_game_info.map_name), "%s (Loaded game)", _file_to_saveload.title);
 #endif /* ENABLE_NETWORK */
 			MakeNewGame(true);
 			break;
 		case SM_LOAD_HEIGHTMAP: /* Load heightmap from scenario editor */
-			SetLocalPlayer(OWNER_NONE);
+			SetLocalCompany(OWNER_NONE);
 			GenerateWorld(GW_HEIGHTMAP, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
 			MarkWholeScreenDirty();
 			break;
 		case SM_LOAD_SCENARIO: { /* Load scenario from scenario editor */
 			if (SafeSaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode, GM_EDITOR, NO_DIRECTORY)) {
-				SetLocalPlayer(OWNER_NONE);
+				SetLocalCompany(OWNER_NONE);
 				_settings_newgame.game_creation.starting_year = _cur_year;
 			} else {
 				SetDParam(0, STR_JUST_RAW_STRING);
 				SetDParamStr(1, GetSaveLoadErrorString());
 				ShowErrorMessage(INVALID_STRING_ID, STR_012D, 0, 0);
 			}
 			if (_networking && _pause_game == 2) _pause_game = 1;
 			break;
 		case SM_GENRANDLAND: /* Generate random land within scenario editor */
-			SetLocalPlayer(OWNER_NONE);
+			SetLocalCompany(OWNER_NONE);
 			GenerateWorld(GW_RANDOM, 1 << _settings_game.game_creation.map_x, 1 << _settings_game.game_creation.map_y);
 			/* XXX: set date */
 			MarkWholeScreenDirty();
 			break;
 	}
 			switch (v->type) {
 				case VEH_ROAD: {
 					extern byte GetRoadVehLength(const Vehicle *v);
 					if (GetRoadVehLength(v) != v->u.road.cached_veh_length) {
-						printf("cache mismatch: vehicle %i, player %i, unit number %i\n", v->index, (int)v->owner, v->unitnumber);
+						printf("cache mismatch: vehicle %i, company %i, unit number %i\n", v->index, (int)v->owner, v->unitnumber);
 					}
 				} break;
 				case VEH_TRAIN: {
 					uint length = 0;
 					TrainConsistChanged(v, true);
 					length = 0;
 					for (Vehicle *u = v; u != NULL; u = u->Next()) {
 						if (memcmp(&wagons[length], &u->u.rail, sizeof(VehicleRail)) != 0) {
-							printf("cache mismatch: vehicle %i, player %i, unit number %i, wagon %i\n", v->index, (int)v->owner, v->unitnumber, length);
+							printf("cache mismatch: vehicle %i, company %i, unit number %i, wagon %i\n", v->index, (int)v->owner, v->unitnumber, length);
 						}
 						length++;
 					}
 					free(wagons);
 				case VEH_AIRCRAFT: {
 					uint speed = v->u.air.cached_max_speed;
 					UpdateAircraftCache(v);
 					if (speed != v->u.air.cached_max_speed) {
-						printf("cache mismatch: vehicle %i, player %i, unit number %i\n", v->index, (int)v->owner, v->unitnumber);
+						printf("cache mismatch: vehicle %i, company %i, unit number %i\n", v->index, (int)v->owner, v->unitnumber);
 					}
 				} break;
 				default:
 					break;
 		}
 #endif
 		/* All these actions has to be done from OWNER_NONE
 		 *  for multiplayer compatibility */
-		PlayerID p = _current_player;
+		CompanyID old_company = _current_company;
-		_current_player = OWNER_NONE;
+		_current_company = OWNER_NONE;
 		AnimateAnimatedTiles();
 		IncreaseDate();
 		RunTileLoop();
 		CallVehicleTicks();
 		AI_RunGameLoop();
 		CallWindowTickEvent();
 		NewsLoop();
-		_current_player = p;
+		_current_company = old_company;
 	}
 }
 /** Create an autosave. The default name is "autosave#.sav". However with
 * the patch setting 'keep_all_autosave' the name defaults to company-name + date */
 #if defined(PSP)
 	/* Autosaving in networking is too time expensive for the PSP */
 	if (_networking) return;
 #endif /* PSP */
-	if (_settings_client.gui.keep_all_autosave && _local_player != PLAYER_SPECTATOR) {
+	if (_settings_client.gui.keep_all_autosave && _local_company != COMPANY_SPECTATOR) {
-		SetDParam(0, _local_player);
+		SetDParam(0, _local_company);
 		SetDParam(1, _date);
 		GetString(buf, STR_4004, lastof(buf));
 		ttd_strlcat(buf, ".sav", lengthof(buf));
 	} else {
 		/* generate a savegame name and number according to _settings_client.gui.max_num_autosaves */
 static void UpdateExclusiveRights()
 {
 	Town *t;
 	FOR_ALL_TOWNS(t) {
-		t->exclusivity = INVALID_PLAYER;
+		t->exclusivity = INVALID_COMPANY;
 	}
 	/* FIXME old exclusive rights status is not being imported (stored in s->blocked_months_obsolete)
 	 *   could be implemented this way:
 	 * 1.) Go through all stations
-	 *     Build an array town_blocked[ town_id ][ player_id ]
+	 *     Build an array town_blocked[ town_id ][ company_id ]
-	 *     that stores if at least one station in that town is blocked for a player
+	 *     that stores if at least one station in that town is blocked for a company
 	 * 2.) Go through that array, if you find a town that is not blocked for
-	 *     one player, but for all others, then give him exclusivity.
+	 *     one company, but for all others, then give him exclusivity.
 	 */
 }
 static const byte convert_currency[] = {
 	 0,  1, 12,  8,  3,
 	UpdateAllStationVirtCoord();
 	UpdateAllSignVirtCoords();
 	UpdateAllTownVirtCoords();
 	UpdateAllWaypointSigns();
-	Player *p;
+	Company *c;
-	FOR_ALL_PLAYERS(p) {
+	FOR_ALL_COMPANIES(c) {
-		/* For each player, verify (while loading a scenario) that the inauguration date is the current year and set it
+		/* For each company, verify (while loading a scenario) that the inauguration date is the current year and set it
-		 * accordingly if it is not the case.  No need to set it on players that are not been used already,
+		 * accordingly if it is not the case.  No need to set it on companies that are not been used already,
 		 * thus the MIN_YEAR (which is really nothing more than Zero, initialized value) test */
-		if (_file_to_saveload.filetype == FT_SCENARIO && p->inaugurated_year != MIN_YEAR) {
+		if (_file_to_saveload.filetype == FT_SCENARIO && c->inaugurated_year != MIN_YEAR) {
-			p->inaugurated_year = _cur_year;
+			c->inaugurated_year = _cur_year;
 		}
 	}
 	SetCachedEngineCounts();
 }
 bool AfterLoadGame()
 {
 	TileIndex map_size = MapSize();
-	Player *p;
+	Company *c;
 	if (CheckSavegameVersion(98)) GamelogOldver();
 	GamelogTestRevision();
 	GamelogTestMode();
 	 * OWNER_NONE, not OWNER_WATER.. I can't replicate it for the current
 	 * (4.3) version, so I just check when versions are older, and then
 	 * walk through the whole map.. */
 	if (CheckSavegameVersionOldStyle(4, 3)) {
 		for (TileIndex t = 0; t < map_size; t++) {
-			if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_PLAYERS) {
+			if (IsTileType(t, MP_WATER) && GetTileOwner(t) >= MAX_COMPANIES) {
 				SetTileOwner(t, OWNER_WATER);
 			}
 		}
 	}
 	if (CheckSavegameVersion(84)) {
-		Player *p;
+		FOR_ALL_COMPANIES(c) {
-		FOR_ALL_PLAYERS(p) {
+			c->name = CopyFromOldName(c->name_1);
-			p->name = CopyFromOldName(p->name_1);
+			if (c->name != NULL) c->name_1 = STR_SV_UNNAMED;
-			if (p->name != NULL) p->name_1 = STR_SV_UNNAMED;
+			c->president_name = CopyFromOldName(c->president_name_1);
-			p->president_name = CopyFromOldName(p->president_name_1);
+			if (c->president_name != NULL) c->president_name_1 = SPECSTR_PRESIDENT_NAME;
-			if (p->president_name != NULL) p->president_name_1 = SPECSTR_PRESIDENT_NAME;
 		}
 		Station *st;
 		FOR_ALL_STATIONS(st) {
 			st->name = CopyFromOldName(st->string_id);
 			wp->name = CopyFromOldName(wp->string);
 			wp->string = STR_EMPTY;
 		}
 		for (uint i = 0; i < GetSignPoolSize(); i++) {
-			/* invalid signs are determined by si->ower == INVALID_PLAYER now */
+			/* invalid signs are determined by si->ower == INVALID_COMPANY now */
 			Sign *si = GetSign(i);
 			if (!si->IsValid() && si->name != NULL) {
 				si->owner = OWNER_NONE;
 			}
 		}
 	 * savegame and saving again, the buggy map array could be converted to new savegame
 	 * version. It didn't show up before r12070. */
 	if (CheckSavegameVersion(87)) UpdateVoidTiles();
 	/* If Load Scenario / New (Scenario) Game is used,
-	 *  a player does not exist yet. So create one here.
+	 *  a company does not exist yet. So create one here.
-	 * 1 exeption: network-games. Those can have 0 players
+	 * 1 exeption: network-games. Those can have 0 companies
 	 *   But this exeption is not true for non dedicated network_servers! */
-	if (!IsValidPlayerID(PLAYER_FIRST) && (!_networking || (_networking && _network_server && !_network_dedicated)))
+	if (!IsValidCompanyID(COMPANY_FIRST) && (!_networking || (_networking && _network_server && !_network_dedicated)))
-		DoStartupNewPlayer(false);
+		DoStartupNewCompany(false);
 	if (CheckSavegameVersion(72)) {
 		/* Locks/shiplifts in very old savegames had OWNER_WATER as owner */
 		for (TileIndex t = 0; t < MapSize(); t++) {
 			switch (GetTileType(t)) {
 	}
 	/* From version 16.0, we included autorenew on engines, which are now saved, but
 	 *  of course, we do need to initialize them for older savegames. */
 	if (CheckSavegameVersion(16)) {
-		FOR_ALL_PLAYERS(p) {
+		FOR_ALL_COMPANIES(c) {
-			p->engine_renew_list   = NULL;
+			c->engine_renew_list   = NULL;
-			p->engine_renew        = false;
+			c->engine_renew        = false;
-			p->engine_renew_months = -6;
+			c->engine_renew_months = -6;
-			p->engine_renew_money  = 100000;
+			c->engine_renew_money  = 100000;
 		}
-		/* When loading a game, _local_player is not yet set to the correct value.
+		/* When loading a game, _local_company is not yet set to the correct value.
 		 * However, in a dedicated server we are a spectator, so nothing needs to
-		 * happen. In case we are not a dedicated server, the local player always
+		 * happen. In case we are not a dedicated server, the local company always
-		 * becomes player 0, unless we are in the scenario editor where all the
+		 * becomes company 0, unless we are in the scenario editor where all the
-		 * players are 'invalid'.
+		 * companies are 'invalid'.
 		 */
-		if (!_network_dedicated && IsValidPlayerID(PLAYER_FIRST)) {
+		if (!_network_dedicated && IsValidCompanyID(COMPANY_FIRST)) {
-			p = GetPlayer(PLAYER_FIRST);
+			c = GetCompany(COMPANY_FIRST);
-			p->engine_renew        = _settings_client.gui.autorenew;
+			c->engine_renew        = _settings_client.gui.autorenew;
-			p->engine_renew_months = _settings_client.gui.autorenew_months;
+			c->engine_renew_months = _settings_client.gui.autorenew_months;
-			p->engine_renew_money  = _settings_client.gui.autorenew_money;
+			c->engine_renew_money  = _settings_client.gui.autorenew_money;
 		}
 	}
 	if (CheckSavegameVersion(48)) {
 		for (TileIndex t = 0; t < map_size; t++) {
 			if (v->type == VEH_TRAIN && (IsFrontEngine(v) || IsFreeWagon(v))) TrainConsistChanged(v, true);
 		}
 	}
-	/* In version 16.1 of the savegame a player can decide if trains, which get
+	/* In version 16.1 of the savegame a company can decide if trains, which get
 	 * replaced, shall keep their old length. In all prior versions, just default
 	 * to false */
 	if (CheckSavegameVersionOldStyle(16, 1)) {
-		FOR_ALL_PLAYERS(p) p->renew_keep_length = false;
+		FOR_ALL_COMPANIES(c) c->renew_keep_length = false;
 	}
 	/* In version 17, ground type is moved from m2 to m4 for depots and
 	 * waypoints to make way for storing the index in m2. The custom graphics
 	 * id which was stored in m4 is now saved as a grf/id reference in the
 		}
 	}
 	YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
-	if (CheckSavegameVersion(34)) FOR_ALL_PLAYERS(p) ResetPlayerLivery(p);
+	if (CheckSavegameVersion(34)) FOR_ALL_COMPANIES(c) ResetCompanyLivery(c);
-	FOR_ALL_PLAYERS(p) {
+	FOR_ALL_COMPANIES(c) {
-		p->avail_railtypes = GetPlayerRailtypes(p->index);
+		c->avail_railtypes = GetCompanyRailtypes(c->index);
-		p->avail_roadtypes = GetPlayerRoadtypes(p->index);
+		c->avail_roadtypes = GetCompanyRoadtypes(c->index);
 	}
 	if (!CheckSavegameVersion(27)) AfterLoadStations();
 	/* Time starts at 0 instead of 1920.
 	 * Account for this in older games by adding an offset */
 	if (CheckSavegameVersion(31)) {
 		Station *st;
 		Waypoint *wp;
 		Engine *e;
-		Player *player;
 		Industry *i;
 		Vehicle *v;
 		_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
 		_cur_year += ORIGINAL_BASE_YEAR;
-		FOR_ALL_STATIONS(st)    st->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
+		FOR_ALL_STATIONS(st)  st->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
-		FOR_ALL_WAYPOINTS(wp)   wp->build_date += DAYS_TILL_ORIGINAL_BASE_YEAR;
+		FOR_ALL_WAYPOINTS(wp) wp->build_date      += DAYS_TILL_ORIGINAL_BASE_YEAR;
-		FOR_ALL_ENGINES(e)      e->intro_date  += DAYS_TILL_ORIGINAL_BASE_YEAR;
+		FOR_ALL_ENGINES(e)    e->intro_date       += DAYS_TILL_ORIGINAL_BASE_YEAR;
-		FOR_ALL_PLAYERS(player) player->inaugurated_year += ORIGINAL_BASE_YEAR;
+		FOR_ALL_COMPANIES(c)  c->inaugurated_year += ORIGINAL_BASE_YEAR;
-		FOR_ALL_INDUSTRIES(i)   i->last_prod_year        += ORIGINAL_BASE_YEAR;
+		FOR_ALL_INDUSTRIES(i) i->last_prod_year   += ORIGINAL_BASE_YEAR;
 		FOR_ALL_VEHICLES(v) {
 			v->date_of_last_service += DAYS_TILL_ORIGINAL_BASE_YEAR;
 			v->build_year += ORIGINAL_BASE_YEAR;
 		}
 				v->acceleration = avi->acceleration;
 			}
 		}
 	}
-	if (CheckSavegameVersion(49)) FOR_ALL_PLAYERS(p) p->face = ConvertFromOldPlayerFace(p->face);
+	if (CheckSavegameVersion(49)) FOR_ALL_COMPANIES(c) c->face = ConvertFromOldCompanyManagerFace(c->face);
 	if (CheckSavegameVersion(52)) {
 		for (TileIndex t = 0; t < map_size; t++) {
 			if (IsStatueTile(t)) {
 				_m[t].m2 = CalcClosestTownFromTile(t, (uint)-1)->index;
 				order->SetLoadType(OLF_LOAD_IF_POSSIBLE);
 				order->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);
 			}
 		}
-		/* Set all share owners to PLAYER_SPECTATOR for
+		/* Set all share owners to INVALID_COMPANY for
-		 * 1) all inactive players
+		 * 1) all inactive companies
-		 *     (when inactive players were stored in the savegame - TTD, TTDP and some
+		 *     (when inactive companies were stored in the savegame - TTD, TTDP and some
-		 *      *really* old revisions of OTTD; else it is already set in InitializePlayers())
+		 *      *really* old revisions of OTTD; else it is already set in InitializeCompanies())
-		 * 2) shares that are owned by inactive players or self
+		 * 2) shares that are owned by inactive companies or self
-		 *     (caused by cheating players in earlier revisions) */
+		 *     (caused by cheating clients in earlier revisions) */
-		Player *p;
+		FOR_ALL_COMPANIES(c) {
-		FOR_ALL_PLAYERS(p) {
 			for (uint i = 0; i < 4; i++) {
-				PlayerID o = p->share_owners[i];
+				CompanyID company = c->share_owners[i];
-				if (o == PLAYER_SPECTATOR) continue;
+				if (company == INVALID_COMPANY) continue;
-				if (!IsValidPlayerID(o) || o == p->index) p->share_owners[i] = PLAYER_SPECTATOR;
+				if (!IsValidCompanyID(company) || company == c->index) c->share_owners[i] = INVALID_COMPANY;
 			}
 		}
 	}
 	if (CheckSavegameVersion(86)) {
 				SetWaterClass(t, WATER_CLASS_SEA);
 			}
 			if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {
 				Owner o = GetTileOwner(t);
-				if (o < MAX_PLAYERS && !IsValidPlayerID(o)) {
+				if (o < MAX_COMPANIES && !IsValidCompanyID(o)) {
-					_current_player = o;
+					_current_company = o;
-					ChangeTileOwner(t, o, PLAYER_SPECTATOR);
+					ChangeTileOwner(t, o, INVALID_OWNER);
 				}
 				if (IsBuoyTile(t)) {
 					/* reset buoy owner to OWNER_NONE in the station struct
-					 * (even if it is owned by active player) */
+					 * (even if it is owned by active company) */
 					GetStationByTile(t)->owner = OWNER_NONE;
 				}
 			} else if (IsTileType(t, MP_ROAD)) {
 				/* works for all RoadTileType */
 				for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
 					/* update even non-existing road types to update tile owner too */
 					Owner o = GetRoadOwner(t, rt);
-					if (o < MAX_PLAYERS && !IsValidPlayerID(o)) SetRoadOwner(t, rt, OWNER_NONE);
+					if (o < MAX_COMPANIES && !IsValidCompanyID(o)) SetRoadOwner(t, rt, OWNER_NONE);
 				}
 				if (IsLevelCrossing(t)) {
 					Owner o = GetTileOwner(t);
-					if (!IsValidPlayerID(o)) {
+					if (!IsValidCompanyID(o)) {
 						/* remove leftover rail piece from crossing (from very old savegames) */
-						_current_player = o;
+						_current_company = o;
 						DoCommand(t, 0, GetCrossingRailTrack(t), DC_EXEC | DC_BANKRUPT, CMD_REMOVE_SINGLE_RAIL);
 					}
 				}
 			}
 		}
 		/* Give owners to waypoints, based on rail tracks it is sitting on.
 		 * If none is available, specify OWNER_NONE */
 		Waypoint *wp;
 		FOR_ALL_WAYPOINTS(wp) {
 			Owner owner = (IsRailWaypointTile(wp->xy) ? GetTileOwner(wp->xy) : OWNER_NONE);
-			wp->owner = IsValidPlayerID(owner) ? owner : OWNER_NONE;
+			wp->owner = IsValidCompanyID(owner) ? owner : OWNER_NONE;
 		}
 	}
 	if (CheckSavegameVersion(102)) {
 		for (TileIndex t = 0; t < map_size; t++) {
 	if (CheckSavegameVersion(103)) {
 		/* signs with invalid owner left from older savegames */
 		Sign *si;
 		FOR_ALL_SIGNS(si) {
-			if (si->owner != OWNER_NONE && !IsValidPlayerID(si->owner)) si->owner = OWNER_NONE;
+			if (si->owner != OWNER_NONE && !IsValidCompanyID(si->owner)) si->owner = OWNER_NONE;
 		}
 	}
 	GamelogPrintDebug(1);
 	AfterLoadWaypoints();
 	AfterLoadStations();
 	/* Check and update house and town values */
 	UpdateHousesAndTowns();
 	/* Update livery selection windows */
-	for (PlayerID i = PLAYER_FIRST; i < MAX_PLAYERS; i++) InvalidateWindowData(WC_PLAYER_COLOR, i, _loaded_newgrf_features.has_2CC);
+	for (CompanyID i = COMPANY_FIRST; i < MAX_COMPANIES; i++) InvalidateWindowData(WC_COMPANY_COLOR, i, _loaded_newgrf_features.has_2CC);
 	/* redraw the whole screen */
 	MarkWholeScreenDirty();
 	CheckTrainsLengths();
 }

changeset 10207	c291a21b304e
parent 10195	bc84fd2b1476
child 10208	72c00af5c95d