summaryrefslogtreecommitdiff
path: root/src/misc.c
diff options
context:
space:
mode:
authorrubidium <rubidium@openttd.org>2007-01-02 19:19:48 +0000
committerrubidium <rubidium@openttd.org>2007-01-02 19:19:48 +0000
commit66bbf336c6af7353ef0aeed58002c46543b30635 (patch)
treead4a63860df2626b22f77e7dac712e958bea54cb /src/misc.c
parentccc0a3f4dbf58c005b22341ac8874252924690cd (diff)
downloadopenttd-66bbf336c6af7353ef0aeed58002c46543b30635.tar.xz
(svn r7759) -Merge: makefile rewrite. This merge features:
- A proper ./configure, so everything needs to be configured only once, not for every make. - Usage of makedepend when available. This greatly reduces the time needed for generating the dependencies. - A generator for all project files. There is a single file with sources, which is used to generate Makefiles and the project files for MSVC. - Proper support for OSX universal binaries. - Object files for non-MSVC compiles are also placed in separate directories, making is faster to switch between debug and release compiles and it does not touch the directory with the source files. - Functionality to make a bundle of all needed files for for example a nightly or distribution of a binary with all needed GRFs and language files. Note: as this merge moves almost all files, it is recommended to make a backup of your working copy before updating your working copy.
Diffstat (limited to 'src/misc.c')
-rw-r--r--src/misc.c634
1 files changed, 634 insertions, 0 deletions
diff --git a/src/misc.c b/src/misc.c
new file mode 100644
index 000000000..fd3a74b79
--- /dev/null
+++ b/src/misc.c
@@ -0,0 +1,634 @@
+/* $Id$ */
+
+#include "stdafx.h"
+#include "openttd.h"
+#include "currency.h"
+#include "functions.h"
+#include "news.h"
+#include "player.h"
+#include "string.h"
+#include "table/strings.h"
+#include "table/sprites.h"
+#include "map.h"
+#include "vehicle.h"
+#include "saveload.h"
+#include "engine.h"
+#include "vehicle_gui.h"
+#include "variables.h"
+#include "ai/ai.h"
+#include "table/landscape_const.h"
+#include "date.h"
+
+char _name_array[512][32];
+
+#ifndef MERSENNE_TWISTER
+
+#ifdef RANDOM_DEBUG
+#include "network/network_data.h"
+uint32 DoRandom(int line, const char *file)
+#else // RANDOM_DEBUG
+uint32 Random(void)
+#endif // RANDOM_DEBUG
+{
+
+uint32 s;
+uint32 t;
+
+#ifdef RANDOM_DEBUG
+ if (_networking && (DEREF_CLIENT(0)->status != STATUS_INACTIVE || !_network_server))
+ printf("Random [%d/%d] %s:%d\n",_frame_counter, _current_player, file, line);
+#endif
+
+ s = _random_seeds[0][0];
+ t = _random_seeds[0][1];
+ _random_seeds[0][0] = s + ROR(t ^ 0x1234567F, 7) + 1;
+ return _random_seeds[0][1] = ROR(s, 3) - 1;
+}
+#endif // MERSENNE_TWISTER
+
+#if defined(RANDOM_DEBUG) && !defined(MERSENNE_TWISTER)
+uint DoRandomRange(uint max, int line, const char *file)
+{
+ return GB(DoRandom(line, file), 0, 16) * max >> 16;
+}
+#else
+uint RandomRange(uint max)
+{
+ return GB(Random(), 0, 16) * max >> 16;
+}
+#endif
+
+
+uint32 InteractiveRandom(void)
+{
+ uint32 t = _random_seeds[1][1];
+ uint32 s = _random_seeds[1][0];
+ _random_seeds[1][0] = s + ROR(t ^ 0x1234567F, 7) + 1;
+ return _random_seeds[1][1] = ROR(s, 3) - 1;
+}
+
+uint InteractiveRandomRange(uint max)
+{
+ return GB(InteractiveRandom(), 0, 16) * max >> 16;
+}
+
+void InitializeVehicles(void);
+void InitializeWaypoints(void);
+void InitializeDepots(void);
+void InitializeEngines(void);
+void InitializeOrders(void);
+void InitializeClearLand(void);
+void InitializeRailGui(void);
+void InitializeRoadGui(void);
+void InitializeAirportGui(void);
+void InitializeDockGui(void);
+void InitializeIndustries(void);
+void InitializeMainGui(void);
+void InitializeLandscape(void);
+void InitializeTowns(void);
+void InitializeTrees(void);
+void InitializeSigns(void);
+void InitializeStations(void);
+static void InitializeNameMgr(void);
+void InitializePlayers(void);
+static void InitializeCheats(void);
+void InitializeNPF(void);
+
+void InitializeGame(int mode, uint size_x, uint size_y)
+{
+ AllocateMap(size_x, size_y);
+
+ AddTypeToEngines(); // make sure all engines have a type
+
+ SetObjectToPlace(SPR_CURSOR_ZZZ, 0, 0, 0);
+
+ _pause = 0;
+ _fast_forward = 0;
+ _tick_counter = 0;
+ _date_fract = 0;
+ _cur_tileloop_tile = 0;
+
+ if ((mode & IG_DATE_RESET) == IG_DATE_RESET) {
+ SetDate(ConvertYMDToDate(_patches.starting_year, 0, 1));
+ }
+
+ InitializeEngines();
+ InitializeVehicles();
+ InitializeWaypoints();
+ InitializeDepots();
+ InitializeOrders();
+
+ InitNewsItemStructs();
+ InitializeLandscape();
+ InitializeClearLand();
+ InitializeRailGui();
+ InitializeRoadGui();
+ InitializeAirportGui();
+ InitializeDockGui();
+ InitializeTowns();
+ InitializeTrees();
+ InitializeSigns();
+ InitializeStations();
+ InitializeIndustries();
+ InitializeMainGui();
+
+ InitializeNameMgr();
+ InitializeVehiclesGuiList();
+ InitializeTrains();
+ InitializeNPF();
+
+ AI_Initialize();
+ InitializePlayers();
+ InitializeCheats();
+
+ InitTextEffects();
+ InitTextMessage();
+ InitializeAnimatedTiles();
+
+ InitializeLandscapeVariables(false);
+
+ ResetObjectToPlace();
+}
+
+bool IsCustomName(StringID id)
+{
+ return GB(id, 11, 5) == 15;
+}
+
+void DeleteName(StringID id)
+{
+ if (IsCustomName(id)) {
+ memset(_name_array[id & 0x1FF], 0, sizeof(_name_array[id & 0x1FF]));
+ }
+}
+
+char *GetName(char *buff, StringID id, const char* last)
+{
+ return strecpy(buff, _name_array[id & ~0x600], last);
+}
+
+
+static void InitializeCheats(void)
+{
+ memset(&_cheats, 0, sizeof(Cheats));
+}
+
+
+static void InitializeNameMgr(void)
+{
+ memset(_name_array, 0, sizeof(_name_array));
+}
+
+StringID RealAllocateName(const char *name, byte skip, bool check_double)
+{
+ char (*free_item)[lengthof(*_name_array)] = NULL;
+ char (*i)[lengthof(*_name_array)];
+
+ for (i = _name_array; i != endof(_name_array); ++i) {
+ if ((*i)[0] == '\0') {
+ if (free_item == NULL) free_item = i;
+ } else if (check_double && strncmp(*i, name, lengthof(*i) - 1) == 0) {
+ _error_message = STR_0132_CHOSEN_NAME_IN_USE_ALREADY;
+ return 0;
+ }
+ }
+
+ if (free_item != NULL) {
+ ttd_strlcpy(*free_item, name, lengthof(*free_item));
+ return (free_item - _name_array) | 0x7800 | (skip << 8);
+ } else {
+ _error_message = STR_0131_TOO_MANY_NAMES_DEFINED;
+ return 0;
+ }
+}
+
+void ConvertNameArray(void)
+{
+ uint i;
+
+ for (i = 0; i < lengthof(_name_array); i++) {
+ const char *strfrom = _name_array[i];
+ char tmp[sizeof(*_name_array)];
+ char *strto = tmp;
+
+ for (; *strfrom != '\0'; strfrom++) {
+ WChar c = (byte)*strfrom;
+ switch (c) {
+ case 0xA4: c = 0x20AC; break; // Euro
+ case 0xA6: c = 0x0160; break; // S with caron
+ case 0xA8: c = 0x0161; break; // s with caron
+ case 0xB4: c = 0x017D; break; // Z with caron
+ case 0xB8: c = 0x017E; break; // z with caron
+ case 0xBC: c = 0x0152; break; // OE ligature
+ case 0xBD: c = 0x0153; break; // oe ligature
+ case 0xBE: c = 0x0178; break; // Y with diaresis
+ default: break;
+ }
+ if (strto + Utf8CharLen(c) > lastof(tmp)) break;
+ strto += Utf8Encode(strto, c);
+ }
+
+ /* Terminate the new string and copy it back to the name array */
+ *strto = '\0';
+ memcpy(_name_array[i], tmp, sizeof(*_name_array));
+ }
+}
+
+// Calculate constants that depend on the landscape type.
+void InitializeLandscapeVariables(bool only_constants)
+{
+ const CargoTypesValues *lpd;
+ uint i;
+ StringID str;
+
+ lpd = &_cargo_types_base_values[_opt.landscape];
+
+ for (i = 0; i != NUM_CARGO; i++) {
+ _cargoc.sprites[i] = lpd->sprites[i];
+
+ str = lpd->names[i];
+ _cargoc.names_s[i] = str;
+ _cargoc.names_long[i] = (str += 0x40);
+ _cargoc.names_short[i] = (str += 0x20);
+ _cargoc.weights[i] = lpd->weights[i];
+
+ if (!only_constants) {
+ _cargo_payment_rates[i] = lpd->initial_cargo_payment[i];
+ _cargo_payment_rates_frac[i] = 0;
+ }
+
+ _cargoc.transit_days_1[i] = lpd->transit_days_table_1[i];
+ _cargoc.transit_days_2[i] = lpd->transit_days_table_2[i];
+ }
+}
+
+
+
+int FindFirstBit(uint32 value)
+{
+ // This is much faster than the one that was before here.
+ // Created by Darkvater.. blame him if it is wrong ;)
+ // Btw, the macro FINDFIRSTBIT is better to use when your value is
+ // not more than 128.
+ byte i = 0;
+ if (value & 0xffff0000) { value >>= 16; i += 16; }
+ if (value & 0x0000ff00) { value >>= 8; i += 8; }
+ if (value & 0x000000f0) { value >>= 4; i += 4; }
+ if (value & 0x0000000c) { value >>= 2; i += 2; }
+ if (value & 0x00000002) { i += 1; }
+ return i;
+}
+
+
+static void Save_NAME(void)
+{
+ int i;
+
+ for (i = 0; i != lengthof(_name_array); ++i) {
+ if (_name_array[i][0] != '\0') {
+ SlSetArrayIndex(i);
+ SlArray(_name_array[i], (uint)strlen(_name_array[i]), SLE_UINT8);
+ }
+ }
+}
+
+static void Load_NAME(void)
+{
+ int index;
+
+ while ((index = SlIterateArray()) != -1) {
+ SlArray(_name_array[index],SlGetFieldLength(),SLE_UINT8);
+ }
+}
+
+static const SaveLoadGlobVarList _date_desc[] = {
+ SLEG_CONDVAR(_date, SLE_FILE_U16 | SLE_VAR_I32, 0, 30),
+ SLEG_CONDVAR(_date, SLE_INT32, 31, SL_MAX_VERSION),
+ SLEG_VAR(_date_fract, SLE_UINT16),
+ SLEG_VAR(_tick_counter, SLE_UINT16),
+ SLEG_VAR(_vehicle_id_ctr_day, SLE_UINT16),
+ SLEG_VAR(_age_cargo_skip_counter, SLE_UINT8),
+ SLEG_VAR(_avail_aircraft, SLE_UINT8),
+ SLEG_CONDVAR(_cur_tileloop_tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
+ SLEG_CONDVAR(_cur_tileloop_tile, SLE_UINT32, 6, SL_MAX_VERSION),
+ SLEG_VAR(_disaster_delay, SLE_UINT16),
+ SLEG_VAR(_station_tick_ctr, SLE_UINT16),
+ SLEG_VAR(_random_seeds[0][0], SLE_UINT32),
+ SLEG_VAR(_random_seeds[0][1], SLE_UINT32),
+ SLEG_CONDVAR(_cur_town_ctr, SLE_FILE_U8 | SLE_VAR_U32, 0, 9),
+ SLEG_CONDVAR(_cur_town_ctr, SLE_UINT32, 10, SL_MAX_VERSION),
+ SLEG_VAR(_cur_player_tick_index, SLE_FILE_U8 | SLE_VAR_U32),
+ SLEG_VAR(_next_competitor_start, SLE_FILE_U16 | SLE_VAR_U32),
+ SLEG_VAR(_trees_tick_ctr, SLE_UINT8),
+ SLEG_CONDVAR(_pause, SLE_UINT8, 4, SL_MAX_VERSION),
+ SLEG_CONDVAR(_cur_town_iter, SLE_UINT32, 11, SL_MAX_VERSION),
+ SLEG_END()
+};
+
+// Save load date related variables as well as persistent tick counters
+// XXX: currently some unrelated stuff is just put here
+static void SaveLoad_DATE(void)
+{
+ SlGlobList(_date_desc);
+}
+
+
+static const SaveLoadGlobVarList _view_desc[] = {
+ SLEG_CONDVAR(_saved_scrollpos_x, SLE_FILE_I16 | SLE_VAR_I32, 0, 5),
+ SLEG_CONDVAR(_saved_scrollpos_x, SLE_INT32, 6, SL_MAX_VERSION),
+ SLEG_CONDVAR(_saved_scrollpos_y, SLE_FILE_I16 | SLE_VAR_I32, 0, 5),
+ SLEG_CONDVAR(_saved_scrollpos_y, SLE_INT32, 6, SL_MAX_VERSION),
+ SLEG_VAR(_saved_scrollpos_zoom, SLE_UINT8),
+ SLEG_END()
+};
+
+static void SaveLoad_VIEW(void)
+{
+ SlGlobList(_view_desc);
+}
+
+static uint32 _map_dim_x;
+static uint32 _map_dim_y;
+
+static const SaveLoadGlobVarList _map_dimensions[] = {
+ SLEG_CONDVAR(_map_dim_x, SLE_UINT32, 6, SL_MAX_VERSION),
+ SLEG_CONDVAR(_map_dim_y, SLE_UINT32, 6, SL_MAX_VERSION),
+ SLEG_END()
+};
+
+static void Save_MAPS(void)
+{
+ _map_dim_x = MapSizeX();
+ _map_dim_y = MapSizeY();
+ SlGlobList(_map_dimensions);
+}
+
+static void Load_MAPS(void)
+{
+ SlGlobList(_map_dimensions);
+ AllocateMap(_map_dim_x, _map_dim_y);
+}
+
+static void Load_MAPT(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) _m[i++].type_height = buf[j];
+ }
+}
+
+static void Save_MAPT(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size);
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].type_height;
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ }
+}
+
+static void Load_MAP1(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) _m[i++].m1 = buf[j];
+ }
+}
+
+static void Save_MAP1(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size);
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].m1;
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ }
+}
+
+static void Load_MAP2(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ for (i = 0; i != size;) {
+ uint16 buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf),
+ /* In those versions the m2 was 8 bits */
+ CheckSavegameVersion(5) ? SLE_FILE_U8 | SLE_VAR_U16 : SLE_UINT16
+ );
+ for (j = 0; j != lengthof(buf); j++) _m[i++].m2 = buf[j];
+ }
+}
+
+static void Save_MAP2(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size * sizeof(_m[0].m2));
+ for (i = 0; i != size;) {
+ uint16 buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].m2;
+ SlArray(buf, lengthof(buf), SLE_UINT16);
+ }
+}
+
+static void Load_MAP3(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) _m[i++].m3 = buf[j];
+ }
+}
+
+static void Save_MAP3(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size);
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].m3;
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ }
+}
+
+static void Load_MAP4(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) _m[i++].m4 = buf[j];
+ }
+}
+
+static void Save_MAP4(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size);
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].m4;
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ }
+}
+
+static void Load_MAP5(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) _m[i++].m5 = buf[j];
+ }
+}
+
+static void Save_MAP5(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size);
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].m5;
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ }
+}
+
+static void Load_MAPE(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ if (CheckSavegameVersion(42)) {
+ for (i = 0; i != size;) {
+ uint8 buf[1024];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) {
+ _m[i++].extra = GB(buf[j], 0, 2);
+ _m[i++].extra = GB(buf[j], 2, 2);
+ _m[i++].extra = GB(buf[j], 4, 2);
+ _m[i++].extra = GB(buf[j], 6, 2);
+ }
+ }
+ } else {
+ for (i = 0; i != size;) {
+ byte buf[4096];
+ uint j;
+
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ for (j = 0; j != lengthof(buf); j++) _m[i++].extra = buf[j];
+ }
+ }
+}
+
+static void Save_MAPE(void)
+{
+ uint size = MapSize();
+ uint i;
+
+ SlSetLength(size);
+ for (i = 0; i != size;) {
+ uint8 buf[4096];
+ uint j;
+
+ for (j = 0; j != lengthof(buf); j++) buf[j] = _m[i++].extra;
+ SlArray(buf, lengthof(buf), SLE_UINT8);
+ }
+}
+
+
+static void Save_CHTS(void)
+{
+ byte count = sizeof(_cheats)/sizeof(Cheat);
+ Cheat* cht = (Cheat*) &_cheats;
+ Cheat* cht_last = &cht[count];
+
+ SlSetLength(count * 2);
+ for (; cht != cht_last; cht++) {
+ SlWriteByte(cht->been_used);
+ SlWriteByte(cht->value);
+ }
+}
+
+static void Load_CHTS(void)
+{
+ Cheat* cht = (Cheat*)&_cheats;
+ uint count = SlGetFieldLength() / 2;
+ uint i;
+
+ for (i = 0; i < count; i++) {
+ cht[i].been_used = SlReadByte();
+ cht[i].value = SlReadByte();
+ }
+}
+
+
+const ChunkHandler _misc_chunk_handlers[] = {
+ { 'MAPS', Save_MAPS, Load_MAPS, CH_RIFF },
+ { 'MAPT', Save_MAPT, Load_MAPT, CH_RIFF },
+ { 'MAPO', Save_MAP1, Load_MAP1, CH_RIFF },
+ { 'MAP2', Save_MAP2, Load_MAP2, CH_RIFF },
+ { 'M3LO', Save_MAP3, Load_MAP3, CH_RIFF },
+ { 'M3HI', Save_MAP4, Load_MAP4, CH_RIFF },
+ { 'MAP5', Save_MAP5, Load_MAP5, CH_RIFF },
+ { 'MAPE', Save_MAPE, Load_MAPE, CH_RIFF },
+
+ { 'NAME', Save_NAME, Load_NAME, CH_ARRAY},
+ { 'DATE', SaveLoad_DATE, SaveLoad_DATE, CH_RIFF},
+ { 'VIEW', SaveLoad_VIEW, SaveLoad_VIEW, CH_RIFF},
+ { 'CHTS', Save_CHTS, Load_CHTS, CH_RIFF | CH_LAST}
+};