openttd-ottdgrfs: comparison src/openttd.cpp

equal deleted inserted replaced

-:70d78ac95d6c
+:7bd07f43b0e3
 #include "clear_map.h"
 #include "rail_map.h"
 #include "road_map.h"
 #include "water_map.h"
 #include "industry_map.h"
+#include "unmovable_map.h"
 #include <stdarg.h>
-void CallLandscapeTick(void);
+void CallLandscapeTick();
-void IncreaseDate(void);
+void IncreaseDate();
-void DoPaletteAnimations(void);
+void DoPaletteAnimations();
-void MusicLoop(void);
+void MusicLoop();
-void ResetMusic(void);
+void ResetMusic();
 extern void SetDifficultyLevel(int mode, GameOptions *gm_opt);
 extern Player* DoStartupNewPlayer(bool is_ai);
 extern void ShowOSErrorBox(const char *buf);
 	*lenp = len;
 	return mem;
 }
 extern const char _openttd_revision[];
-static void showhelp(void)
+static void showhelp()
 {
 	char buf[4096], *p;
 	p = buf;
 	res[0] = clamp(strtoul(s, NULL, 0), 64, MAX_SCREEN_WIDTH);
 	res[1] = clamp(strtoul(t + 1, NULL, 0), 64, MAX_SCREEN_HEIGHT);
 }
-static void InitializeDynamicVariables(void)
+static void InitializeDynamicVariables()
 {
 	/* Dynamic stuff needs to be initialized somewhere... */
 	_town_sort     = NULL;
 	_industry_sort = NULL;
 }
-static void UnInitializeGame(void)
+static void UnInitializeGame()
 {
 	UnInitWindowSystem();
 	/* Uninitialize airport state machines */
 	UnInitializeAirports();
 	free((void*)_industry_sort);
 	free(_config_file);
 }
-static void LoadIntroGame(void)
+static void LoadIntroGame()
 {
 	char filename[256];
 	_game_mode = GM_MENU;
 	CLRBITS(_display_opt, DO_TRANS_BUILDINGS); // don't make buildings transparent in intro
 	if (SaveOrLoad(filename, SL_LOAD) != SL_OK) {
 		GenerateWorld(GW_EMPTY, 64, 64); // if failed loading, make empty world.
 		WaitTillGeneratedWorld();
 	}
-	_pause = 0;
+	_pause_game = 0;
 	SetLocalPlayer(PLAYER_FIRST);
 	/* Make sure you can't scroll in the menu */
 	_scrolling_viewport = 0;
 	_cursor.fix_at = false;
 	MarkWholeScreenDirty();
 	// Play main theme
 	if (_music_driver->is_song_playing()) ResetMusic();
 }
 #if defined(UNIX) && !defined(__MORPHOS__)
-extern void DedicatedFork(void);
+extern void DedicatedFork();
 #endif
 int ttd_main(int argc, char *argv[])
 {
 	int i;
 			if (mgo.opt != NULL) {
 				strcpy(_file_to_saveload.name, mgo.opt);
 				_switch_mode = SM_LOAD;
 			} else {
 				_switch_mode = SM_NEWGAME;
+				/* Give a random map */
+				generation_seed = InteractiveRandom();
 			}
 			break;
 		case 'G': generation_seed = atoi(mgo.opt); break;
 		case 'c': _config_file = strdup(mgo.opt); break;
 		case 'x': save_config = false; break;
 			showhelp();
 			return 0;
 		}
 	}
-	DeterminePaths();
+	DeterminePaths(argv[0]);
 	CheckExternalFiles();
 #if defined(UNIX) && !defined(__MORPHOS__)
 	// We must fork here, or we'll end up without some resources we need (like sockets)
 	if (_dedicated_forks)
 	FioCloseAll();
 	return 0;
 }
-void HandleExitGameRequest(void)
+void HandleExitGameRequest()
 {
 	if (_game_mode == GM_MENU) { // do not ask to quit on the main screen
 		_exit_game = true;
 	} else if (_patches.autosave_on_exit) {
 		DoExitSave();
 /** Mutex so that only one thread can communicate with the main program
 * at any given time */
 static ThreadMsg _message = MSG_OTTD_NO_MESSAGE;
-static inline void OTTD_ReleaseMutex(void) {_message = MSG_OTTD_NO_MESSAGE;}
+static inline void OTTD_ReleaseMutex() {_message = MSG_OTTD_NO_MESSAGE;}
-static inline ThreadMsg OTTD_PollThreadEvent(void) {return _message;}
+static inline ThreadMsg OTTD_PollThreadEvent() {return _message;}
 /** Called by running thread to execute some action in the main game.
 * It will stall as long as the mutex is not freed (handled) by the game */
 void OTTD_SendThreadMessage(ThreadMsg msg)
 {
 		ShowErrorMessage(INVALID_STRING_ID, STR_031C_SCREENSHOT_FAILED, 0, 0);
 	}
 }
-static void MakeNewGameDone(void)
+static void MakeNewGameDone()
 {
 	/* In a dedicated server, the server does not play */
 	if (_network_dedicated) {
 		SetLocalPlayer(PLAYER_SPECTATOR);
 		return;
 	GenerateWorldSetCallback(&MakeNewGameDone);
 	GenerateWorld(from_heightmap ? GW_HEIGHTMAP : GW_NEWGAME, 1 << _patches.map_x, 1 << _patches.map_y);
 }
-static void MakeNewEditorWorldDone(void)
+static void MakeNewEditorWorldDone()
 {
 	SetLocalPlayer(OWNER_NONE);
 	MarkWholeScreenDirty();
 }
-static void MakeNewEditorWorld(void)
+static void MakeNewEditorWorld()
 {
 	_game_mode = GM_EDITOR;
 	ResetGRFConfig(true);
 	GenerateWorldSetCallback(&MakeNewEditorWorldDone);
 	GenerateWorld(GW_EMPTY, 1 << _patches.map_x, 1 << _patches.map_y);
 }
-void StartupPlayers(void);
+void StartupPlayers();
-void StartupDisasters(void);
+void StartupDisasters();
-extern void StartupEconomy(void);
+extern void StartupEconomy();
 /**
 * Start Scenario starts a new game based on a scenario.
 * Eg 'New Game' --> select a preset scenario
 * This starts a scenario based on your current difficulty settings
 */
-static void StartScenario(void)
+static void StartScenario()
 {
 	_game_mode = GM_NORMAL;
 	// invalid type
 	if (_file_to_saveload.mode == SL_INVALID) {
 // State controlling game loop.
 // The state must not be changed from anywhere
 // but here.
 // That check is enforced in DoCommand.
-void StateGameLoop(void)
+void StateGameLoop()
 {
 	// dont execute the state loop during pause
-	if (_pause) return;
+	if (_pause_game) return;
 	if (IsGeneratingWorld()) return;
 	if (_game_mode == GM_EDITOR) {
 		RunTileLoop();
 		CallVehicleTicks();
 		NewsLoop();
 		_current_player = p;
 	}
 }
-static void DoAutosave(void)
+static void DoAutosave()
 {
 	char buf[200];
 #if defined(PSP)
 	/* Autosaving in networking is too time expensive for the PSP */
 	{ 0,  2}, // 13 : left + right + down = down
 	{ 0, -2}, // 14 : left + right + up = up
 	{ 0,  0}, // 15 : impossible
 };
-static void HandleKeyScrolling(void)
+static void HandleKeyScrolling()
 {
 	if (_dirkeys && !_no_scroll) {
 		int factor = _shift_pressed ? 50 : 10;
 		ScrollMainViewport(scrollamt[_dirkeys][0] * factor, scrollamt[_dirkeys][1] * factor);
 	}
 }
-void GameLoop(void)
+void GameLoop()
 {
 	ThreadMsg message;
 	if ((message = OTTD_PollThreadEvent()) != 0) ProcessSentMessage(message);
 	}
 #else
 	StateGameLoop();
 #endif /* ENABLE_NETWORK */
-	if (!_pause && _display_opt & DO_FULL_ANIMATION) DoPaletteAnimations();
+	if (!_pause_game && _display_opt & DO_FULL_ANIMATION) DoPaletteAnimations();
-	if (!_pause || _cheats.build_in_pause.value) MoveAllTextEffects();
+	if (!_pause_game || _cheats.build_in_pause.value) MoveAllTextEffects();
 	InputLoop();
 	MusicLoop();
 }
-void BeforeSaveGame(void)
+void BeforeSaveGame()
 {
 	const Window *w = FindWindowById(WC_MAIN_WINDOW, 0);
 	if (w != NULL) {
 		_saved_scrollpos_x = WP(w, const vp_d).scrollpos_x;
 		_saved_scrollpos_y = WP(w, const vp_d).scrollpos_y;
 		_saved_scrollpos_zoom = w->viewport->zoom;
 	}
 }
-static void ConvertTownOwner(void)
+static void ConvertTownOwner()
 {
 	TileIndex tile;
 	for (tile = 0; tile != MapSize(); tile++) {
 		switch (GetTileType(tile)) {
 		}
 	}
 }
 // before savegame version 4, the name of the company determined if it existed
-static void CheckIsPlayerActive(void)
+static void CheckIsPlayerActive()
 {
 	Player *p;
 	FOR_ALL_PLAYERS(p) {
 		if (p->name_1 != 0) p->is_active = true;
 	}
 }
 // since savegame version 4.1, exclusive transport rights are stored at towns
-static void UpdateExclusiveRights(void)
+static void UpdateExclusiveRights()
 {
 	Town *t;
 	FOR_ALL_TOWNS(t) {
 		t->exclusivity = INVALID_PLAYER;
 	 9, 11, 13,  6, 17,
 	16, 22, 21,  7, 15,
 	18,  2, 20, };
 // since savegame version 4.2 the currencies are arranged differently
-static void UpdateCurrencies(void)
+static void UpdateCurrencies()
 {
 	_opt.currency = convert_currency[_opt.currency];
 }
 /* Up to revision 1413 the invisible tiles at the southern border have not been
 * MP_VOID, even though they should have. This is fixed by this function
 */
-static void UpdateVoidTiles(void)
+static void UpdateVoidTiles()
 {
 	uint i;
 	for (i = 0; i < MapMaxY(); ++i) MakeVoid(i * MapSizeX() + MapMaxX());
 	for (i = 0; i < MapSizeX(); ++i) MakeVoid(MapSizeX() * MapMaxY() + i);
 }
 // since savegame version 6.0 each sign has an "owner", signs without owner (from old games are set to 255)
-static void UpdateSignOwner(void)
+static void UpdateSignOwner()
 {
 	Sign *si;
 	FOR_ALL_SIGNS(si) si->owner = OWNER_NONE;
 }
-extern void UpdateOldAircraft( void );
+extern void UpdateOldAircraft();
 static inline RailType UpdateRailType(RailType rt, RailType min)
 {
 	return rt >= min ? (RailType)(rt + 1): rt;
 }
-bool AfterLoadGame(void)
+bool AfterLoadGame()
 {
 	TileIndex map_size = MapSize();
 	Window *w;
 	ViewPort *vp;
 	Player *p;
 	// convert road side to my format.
 	if (_opt.road_side) _opt.road_side = 1;
 	/* Check if all NewGRFs are present, we are very strict in MP mode */
-	GCF_Flags gcf_res = IsGoodGRFConfigList();
+	GRFListCompatibility gcf_res = IsGoodGRFConfigList();
-	if (_networking && gcf_res != GCF_ACTIVATED) return false;
+	if (_networking && gcf_res != GLC_ALL_GOOD) return false;
 	switch (gcf_res) {
-		case GCF_COMPATIBLE: _switch_mode_errorstr = STR_NEWGRF_COMPATIBLE_LOAD_WARNING; break;
+		case GLC_COMPATIBLE: _switch_mode_errorstr = STR_NEWGRF_COMPATIBLE_LOAD_WARNING; break;
-		case GCF_NOT_FOUND: _switch_mode_errorstr = STR_NEWGRF_DISABLED_WARNING; break;
+		case GLC_NOT_FOUND: _switch_mode_errorstr = STR_NEWGRF_DISABLED_WARNING; break;
 		default: break;
 	}
 	/* Update current year
 	 * must be done before loading sprites as some newgrfs check it */
 				}
 			}
 		}
 		FOR_ALL_VEHICLES(v) {
-			if (v->type != VEH_Train && v->type != VEH_Road) continue;
+			if (v->type != VEH_TRAIN && v->type != VEH_ROAD) continue;
 			if (IsBridgeTile(v->tile)) {
 				DiagDirection dir = GetBridgeRampDirection(v->tile);
 				if (dir != DirToDiagDir(v->direction)) continue;
 				switch (dir) {
 			} else if (v->z_pos > GetSlopeZ(v->x_pos, v->y_pos)) {
 				v->tile = GetNorthernBridgeEnd(v->tile);
 			} else {
 				continue;
 			}
-			if (v->type == VEH_Train) {
+			if (v->type == VEH_TRAIN) {
 				v->u.rail.track = TRACK_BIT_WORMHOLE;
 			} else {
 				v->u.road.state = RVSB_WORMHOLE;
 			}
 		}
 	if (CheckSavegameVersion(24)) {
 		Vehicle *v;
 		RailType min_rail = RAILTYPE_ELECTRIC;
 		FOR_ALL_VEHICLES(v) {
-			if (v->type == VEH_Train) {
+			if (v->type == VEH_TRAIN) {
 				RailType rt = RailVehInfo(v->engine_type)->railtype;
 				v->u.rail.railtype = rt;
 				if (rt == RAILTYPE_ELECTRIC) min_rail = RAILTYPE_RAIL;
 			}
 					break;
 			}
 		}
 		FOR_ALL_VEHICLES(v) {
-			if (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v))) TrainConsistChanged(v);
+			if (v->type == VEH_TRAIN && (IsFrontEngine(v) || IsFreeWagon(v))) TrainConsistChanged(v);
 		}
 	}
 	/* In version 16.1 of the savegame a player can decide if trains, which get
 	if (CheckSavegameVersion(22))  UpdatePatches();
 	if (CheckSavegameVersion(25)) {
 		Vehicle *v;
 		FOR_ALL_VEHICLES(v) {
-			if (v->type == VEH_Road) {
+			if (v->type == VEH_ROAD) {
 				v->vehstatus &= ~0x40;
 				v->u.road.slot = NULL;
 				v->u.road.slot_age = 0;
 			}
 		}
 	} else {
 		Vehicle *v;
 		FOR_ALL_VEHICLES(v) {
-			if (v->type == VEH_Road && v->u.road.slot != NULL) v->u.road.slot->num_vehicles++;
+			if (v->type == VEH_ROAD && v->u.road.slot != NULL) v->u.road.slot->num_vehicles++;
 		}
 	}
 	if (CheckSavegameVersion(26)) {
 		Station *st;
 		FOR_ALL_STATIONS(st) {
-			st->last_vehicle_type = VEH_Invalid;
+			st->last_vehicle_type = VEH_INVALID;
 		}
 	}
 	YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);
 		 * where this situation exists, the cargo-source information is lost. in this case, we set the origin
 		 * to the current tile of the vehicle to prevent excessive profits
 		 */
 		FOR_ALL_VEHICLES(v) {
 			v->cargo_source_xy = IsValidStationID(v->cargo_source) ? GetStation(v->cargo_source)->xy : v->tile;
+		}
+		/* Store position of the station where the goods come from, so there
+		 * are no very high payments when stations get removed. However, if the
+		 * station where the goods came from is already removed, the source
+		 * information is lost. In that case we set it to the position of this
+		 * station */
+		Station *st;
+		FOR_ALL_STATIONS(st) {
+			for (CargoID c = 0; c < NUM_CARGO; c++) {
+				GoodsEntry *ge = &st->goods[c];
+				/* In old versions, enroute_from used 0xFF as INVALID_STATION */
+				if (CheckSavegameVersion(7) && ge->enroute_from == 0xFF) {
+					ge->enroute_from = INVALID_STATION;
+				}
+				ge->enroute_from_xy = IsValidStationID(ge->enroute_from) ? GetStation(ge->enroute_from)->xy : st->xy;
+			}
 		}
 	}
 	if (CheckSavegameVersion(45)) {
 		Vehicle *v;
 	if (CheckSavegameVersion(50)) {
 		Vehicle *v;
 		/* Aircraft units changed from 8 mph to 1 km/h */
 		FOR_ALL_VEHICLES(v) {
-			if (v->type == VEH_Aircraft && v->subtype <= AIR_AIRCRAFT) {
+			if (v->type == VEH_AIRCRAFT && v->subtype <= AIR_AIRCRAFT) {
 				const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);
 				v->cur_speed *= 129;
 				v->cur_speed /= 10;
 				v->max_speed = avi->max_speed;
 				v->acceleration = avi->acceleration;
 			}
 		}
 	}
 	if (CheckSavegameVersion(49)) FOR_ALL_PLAYERS(p) p->face = ConvertFromOldPlayerFace(p->face);
+	if (CheckSavegameVersion(52)) {
+		for (TileIndex t = 0; t < map_size; t++) {
+			if (IsStatueTile(t)) {
+				_m[t].m2 = CalcClosestTownFromTile(t, (uint)-1)->index;
+			}
+		}
+	}
 	return true;
 }
 /** Reload all NewGRF files during a running game. This is a cut-down
 * version of AfterLoadGame().
 * XXX - We need to reset the vehicle position hash because with a non-empty
 * hash AfterLoadVehicles() will loop infinitely. We need AfterLoadVehicles()
 * to recalculate vehicle data as some NewGRF vehicle sets could have been
 * removed or added and changed statistics */
-void ReloadNewGRFData(void)
+void ReloadNewGRFData()
 {
 	/* reload grf data */
 	GfxLoadSprites();
 	LoadStringWidthTable();
 	/* reload vehicles */

branch	gamebalance
changeset 9895	7bd07f43b0e3
parent 6522	bf0da9f42953
child 9896	2473804114de