mirror of
https://github.com/JGRennison/OpenTTD-patches.git
synced 2024-11-04 06:00:15 +00:00
b5b85a6297
With the original generator, e.g. Random()%44 on 100 attempts regularily generated only 22 different values! With this adjustment, the distribution is much more uniform, almost approaching the glibc's random() call. This means the random numbers are actually usable i.e. for the town names generators which almost never tried a large part of the names while others were very frequent. Note that we attempted to test whether the randomness did not degrade in some other way, and it came clean from the tests we performed. If you spot anything fishy, try without this patch, though.
917 lines
24 KiB
C
917 lines
24 KiB
C
#include "stdafx.h"
|
|
#include "ttd.h"
|
|
#include "string.h"
|
|
#include "strings.h" // XXX GetParam*
|
|
#include "table/strings.h"
|
|
#include "map.h"
|
|
#include "vehicle.h"
|
|
#include "gfx.h"
|
|
#include "assert.h"
|
|
#include "saveload.h"
|
|
#include "network.h"
|
|
#include "network_data.h"
|
|
#include "network_server.h"
|
|
#include "engine.h"
|
|
|
|
extern void StartupEconomy(void);
|
|
extern void InitNewsItemStructs(void);
|
|
|
|
char _name_array[512][32];
|
|
|
|
static inline uint32 ROR(uint32 x, int n)
|
|
{
|
|
return (x >> n) + (x << ((sizeof(x)*8)-n));
|
|
}
|
|
|
|
/* XXX - Player-seeds don't seem to be used anymore.. which is a good thing
|
|
so I just disabled them for now. If there are no problems, we can remove
|
|
it completely! -- TrueLight */
|
|
#undef PLAYER_SEED_RANDOM
|
|
|
|
#ifdef RANDOM_DEBUG
|
|
#include "network_data.h"
|
|
|
|
uint32 DoRandom(int line, const char *file)
|
|
#else
|
|
uint32 Random(void)
|
|
#endif
|
|
{
|
|
|
|
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
|
|
|
|
#ifdef PLAYER_SEED_RANDOM
|
|
if (_current_player>=MAX_PLAYERS || !_networking) {
|
|
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;
|
|
} else {
|
|
uint32 s = _player_seeds[_current_player][0];
|
|
uint32 t = _player_seeds[_current_player][1];
|
|
_player_seeds[_current_player][0] = s + ROR(t ^ 0x1234567F, 7) + 1;
|
|
DEBUG(net, 1)("[NET-Seeds] Player seed called!");
|
|
return _player_seeds[_current_player][1] = ROR(s, 3) - 1;
|
|
}
|
|
#else
|
|
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
|
|
}
|
|
|
|
#ifdef RANDOM_DEBUG
|
|
uint DoRandomRange(uint max, int line, const char *file)
|
|
{
|
|
return (uint16)DoRandom(line, file) * max >> 16;
|
|
}
|
|
#else
|
|
uint RandomRange(uint max)
|
|
{
|
|
return (uint16)Random() * 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 (uint16)InteractiveRandom() * max >> 16;
|
|
}
|
|
|
|
void InitPlayerRandoms(void)
|
|
{
|
|
int i;
|
|
for (i=0; i<MAX_PLAYERS; i++) {
|
|
_player_seeds[i][0]=InteractiveRandom();
|
|
_player_seeds[i][1]=InteractiveRandom();
|
|
}
|
|
}
|
|
|
|
void SetDate(uint date)
|
|
{
|
|
YearMonthDay ymd;
|
|
ConvertDayToYMD(&ymd, _date = date);
|
|
_cur_year = ymd.year;
|
|
_cur_month = ymd.month;
|
|
#ifdef ENABLE_NETWORK
|
|
_network_last_advertise_date = 0;
|
|
#endif /* ENABLE_NETWORK */
|
|
}
|
|
|
|
|
|
// multi os compatible sleep function
|
|
|
|
#ifdef __AMIGA__
|
|
// usleep() implementation
|
|
# include <devices/timer.h>
|
|
# include <dos/dos.h>
|
|
|
|
extern struct Device *TimerBase = NULL;
|
|
extern struct MsgPort *TimerPort = NULL;
|
|
extern struct timerequest *TimerRequest = NULL;
|
|
#endif // __AMIGA__
|
|
|
|
void CSleep(int milliseconds)
|
|
{
|
|
#if defined(WIN32)
|
|
Sleep(milliseconds);
|
|
#endif
|
|
#if defined(UNIX)
|
|
#if !defined(__BEOS__) && !defined(__AMIGA__)
|
|
usleep(milliseconds * 1000);
|
|
#endif
|
|
#ifdef __BEOS__
|
|
snooze(milliseconds * 1000);
|
|
#endif
|
|
#if defined(__AMIGA__)
|
|
{
|
|
ULONG signals;
|
|
ULONG TimerSigBit = 1 << TimerPort->mp_SigBit;
|
|
|
|
// send IORequest
|
|
TimerRequest->tr_node.io_Command = TR_ADDREQUEST;
|
|
TimerRequest->tr_time.tv_secs = (milliseconds * 1000) / 1000000;
|
|
TimerRequest->tr_time.tv_micro = (milliseconds * 1000) % 1000000;
|
|
SendIO((struct IORequest *)TimerRequest);
|
|
|
|
if (!((signals = Wait(TimerSigBit | SIGBREAKF_CTRL_C)) & TimerSigBit) ) {
|
|
AbortIO((struct IORequest *)TimerRequest);
|
|
}
|
|
WaitIO((struct IORequest *)TimerRequest);
|
|
}
|
|
#endif // __AMIGA__
|
|
#endif
|
|
}
|
|
|
|
void InitializeVehicles(void);
|
|
void InitializeDepot(void);
|
|
void InitializeOrders(void);
|
|
void InitializeClearLand(void);
|
|
void InitializeRail(void);
|
|
void InitializeRailGui(void);
|
|
void InitializeRoad(void);
|
|
void InitializeRoadGui(void);
|
|
void InitializeAirportGui(void);
|
|
void InitializeDock(void);
|
|
void InitializeDockGui(void);
|
|
void InitializeIndustries(void);
|
|
void InitializeLandscape(uint log_x, uint log_y);
|
|
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 GenerateLandscape(void);
|
|
void GenerateClearTile(void);
|
|
|
|
void GenerateIndustries(void);
|
|
void GenerateUnmovables(void);
|
|
void GenerateTowns(void);
|
|
|
|
void StartupPlayers(void);
|
|
void StartupDisasters(void);
|
|
void GenerateTrees(void);
|
|
|
|
void ConvertGroundTilesIntoWaterTiles(void);
|
|
|
|
void InitializeGame(uint log_x, uint log_y)
|
|
{
|
|
// Initialize the autoreplace array. Needs to be cleared between each game
|
|
uint i;
|
|
for (i = 0; i < lengthof(_autoreplace_array); i++)
|
|
_autoreplace_array[i] = i;
|
|
|
|
_railtype_selected_in_replace_gui = 0;
|
|
|
|
AddTypeToEngines(); // make sure all engines have a type
|
|
|
|
SetObjectToPlace(1, 0, 0, 0);
|
|
|
|
_pause = 0;
|
|
_fast_forward = 0;
|
|
_tick_counter = 0;
|
|
_date_fract = 0;
|
|
_cur_tileloop_tile = 0;
|
|
_vehicle_id_ctr_day = 0;
|
|
|
|
{
|
|
uint starting = ConvertIntDate(_patches.starting_date);
|
|
if ( starting == (uint)-1) starting = 10958;
|
|
SetDate(starting);
|
|
}
|
|
|
|
InitializeVehicles();
|
|
InitializeDepot();
|
|
InitializeOrders();
|
|
|
|
InitNewsItemStructs();
|
|
InitializeLandscape(log_x, log_y);
|
|
InitializeClearLand();
|
|
InitializeRail();
|
|
InitializeRailGui();
|
|
InitializeRoad();
|
|
InitializeRoadGui();
|
|
InitializeAirportGui();
|
|
InitializeDock();
|
|
InitializeDockGui();
|
|
InitializeTowns();
|
|
InitializeTrees();
|
|
InitializeSigns();
|
|
InitializeStations();
|
|
InitializeIndustries();
|
|
|
|
InitializeNameMgr();
|
|
InitializeVehiclesGuiList();
|
|
InitializeTrains();
|
|
InitializeNPF();
|
|
|
|
InitializePlayers();
|
|
InitializeCheats();
|
|
|
|
InitTextEffects();
|
|
InitTextMessage();
|
|
InitializeAnimatedTiles();
|
|
|
|
InitializeLandscapeVariables(false);
|
|
|
|
ResetObjectToPlace();
|
|
}
|
|
|
|
void GenerateWorld(int mode, uint log_x, uint log_y)
|
|
{
|
|
int i;
|
|
|
|
// Make sure everything is done via OWNER_NONE
|
|
_current_player = OWNER_NONE;
|
|
|
|
_generating_world = true;
|
|
InitializeGame(log_x, log_y);
|
|
SetObjectToPlace(1, 0, 0, 0);
|
|
|
|
// Must start economy early because of the costs.
|
|
StartupEconomy();
|
|
|
|
// Don't generate landscape items when in the scenario editor.
|
|
if (mode == 1) {
|
|
// empty world in scenario editor
|
|
ConvertGroundTilesIntoWaterTiles();
|
|
} else {
|
|
GenerateLandscape();
|
|
GenerateClearTile();
|
|
|
|
// only generate towns, tree and industries in newgame mode.
|
|
if (mode == 0) {
|
|
GenerateTowns();
|
|
GenerateTrees();
|
|
GenerateIndustries();
|
|
GenerateUnmovables();
|
|
}
|
|
}
|
|
|
|
// These are probably pointless when inside the scenario editor.
|
|
StartupPlayers();
|
|
StartupEngines();
|
|
StartupDisasters();
|
|
_generating_world = false;
|
|
|
|
// No need to run the tile loop in the scenario editor.
|
|
if (mode != 1) {
|
|
for(i=0x500; i!=0; i--)
|
|
RunTileLoop();
|
|
}
|
|
|
|
ResetObjectToPlace();
|
|
}
|
|
|
|
void DeleteName(StringID id)
|
|
{
|
|
if ((id & 0xF800) == 0x7800) {
|
|
memset(_name_array[id & 0x1FF], 0, sizeof(_name_array[id & 0x1FF]));
|
|
}
|
|
}
|
|
|
|
char *GetName(int id, char *buff)
|
|
{
|
|
if (id & 0x400) GetParamInt32();
|
|
if (id & 0x200) GetParamUint16();
|
|
|
|
return strecpy(buff, _name_array[id & ~0x600], NULL);
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
#define M(a,b) ((a<<5)|b)
|
|
static const uint16 _month_date_from_year_day[] = {
|
|
M(0,1),M(0,2),M(0,3),M(0,4),M(0,5),M(0,6),M(0,7),M(0,8),M(0,9),M(0,10),M(0,11),M(0,12),M(0,13),M(0,14),M(0,15),M(0,16),M(0,17),M(0,18),M(0,19),M(0,20),M(0,21),M(0,22),M(0,23),M(0,24),M(0,25),M(0,26),M(0,27),M(0,28),M(0,29),M(0,30),M(0,31),
|
|
M(1,1),M(1,2),M(1,3),M(1,4),M(1,5),M(1,6),M(1,7),M(1,8),M(1,9),M(1,10),M(1,11),M(1,12),M(1,13),M(1,14),M(1,15),M(1,16),M(1,17),M(1,18),M(1,19),M(1,20),M(1,21),M(1,22),M(1,23),M(1,24),M(1,25),M(1,26),M(1,27),M(1,28),M(1,29),
|
|
M(2,1),M(2,2),M(2,3),M(2,4),M(2,5),M(2,6),M(2,7),M(2,8),M(2,9),M(2,10),M(2,11),M(2,12),M(2,13),M(2,14),M(2,15),M(2,16),M(2,17),M(2,18),M(2,19),M(2,20),M(2,21),M(2,22),M(2,23),M(2,24),M(2,25),M(2,26),M(2,27),M(2,28),M(2,29),M(2,30),M(2,31),
|
|
M(3,1),M(3,2),M(3,3),M(3,4),M(3,5),M(3,6),M(3,7),M(3,8),M(3,9),M(3,10),M(3,11),M(3,12),M(3,13),M(3,14),M(3,15),M(3,16),M(3,17),M(3,18),M(3,19),M(3,20),M(3,21),M(3,22),M(3,23),M(3,24),M(3,25),M(3,26),M(3,27),M(3,28),M(3,29),M(3,30),
|
|
M(4,1),M(4,2),M(4,3),M(4,4),M(4,5),M(4,6),M(4,7),M(4,8),M(4,9),M(4,10),M(4,11),M(4,12),M(4,13),M(4,14),M(4,15),M(4,16),M(4,17),M(4,18),M(4,19),M(4,20),M(4,21),M(4,22),M(4,23),M(4,24),M(4,25),M(4,26),M(4,27),M(4,28),M(4,29),M(4,30),M(4,31),
|
|
M(5,1),M(5,2),M(5,3),M(5,4),M(5,5),M(5,6),M(5,7),M(5,8),M(5,9),M(5,10),M(5,11),M(5,12),M(5,13),M(5,14),M(5,15),M(5,16),M(5,17),M(5,18),M(5,19),M(5,20),M(5,21),M(5,22),M(5,23),M(5,24),M(5,25),M(5,26),M(5,27),M(5,28),M(5,29),M(5,30),
|
|
M(6,1),M(6,2),M(6,3),M(6,4),M(6,5),M(6,6),M(6,7),M(6,8),M(6,9),M(6,10),M(6,11),M(6,12),M(6,13),M(6,14),M(6,15),M(6,16),M(6,17),M(6,18),M(6,19),M(6,20),M(6,21),M(6,22),M(6,23),M(6,24),M(6,25),M(6,26),M(6,27),M(6,28),M(6,29),M(6,30),M(6,31),
|
|
M(7,1),M(7,2),M(7,3),M(7,4),M(7,5),M(7,6),M(7,7),M(7,8),M(7,9),M(7,10),M(7,11),M(7,12),M(7,13),M(7,14),M(7,15),M(7,16),M(7,17),M(7,18),M(7,19),M(7,20),M(7,21),M(7,22),M(7,23),M(7,24),M(7,25),M(7,26),M(7,27),M(7,28),M(7,29),M(7,30),M(7,31),
|
|
M(8,1),M(8,2),M(8,3),M(8,4),M(8,5),M(8,6),M(8,7),M(8,8),M(8,9),M(8,10),M(8,11),M(8,12),M(8,13),M(8,14),M(8,15),M(8,16),M(8,17),M(8,18),M(8,19),M(8,20),M(8,21),M(8,22),M(8,23),M(8,24),M(8,25),M(8,26),M(8,27),M(8,28),M(8,29),M(8,30),
|
|
M(9,1),M(9,2),M(9,3),M(9,4),M(9,5),M(9,6),M(9,7),M(9,8),M(9,9),M(9,10),M(9,11),M(9,12),M(9,13),M(9,14),M(9,15),M(9,16),M(9,17),M(9,18),M(9,19),M(9,20),M(9,21),M(9,22),M(9,23),M(9,24),M(9,25),M(9,26),M(9,27),M(9,28),M(9,29),M(9,30),M(9,31),
|
|
M(10,1),M(10,2),M(10,3),M(10,4),M(10,5),M(10,6),M(10,7),M(10,8),M(10,9),M(10,10),M(10,11),M(10,12),M(10,13),M(10,14),M(10,15),M(10,16),M(10,17),M(10,18),M(10,19),M(10,20),M(10,21),M(10,22),M(10,23),M(10,24),M(10,25),M(10,26),M(10,27),M(10,28),M(10,29),M(10,30),
|
|
M(11,1),M(11,2),M(11,3),M(11,4),M(11,5),M(11,6),M(11,7),M(11,8),M(11,9),M(11,10),M(11,11),M(11,12),M(11,13),M(11,14),M(11,15),M(11,16),M(11,17),M(11,18),M(11,19),M(11,20),M(11,21),M(11,22),M(11,23),M(11,24),M(11,25),M(11,26),M(11,27),M(11,28),M(11,29),M(11,30),M(11,31),
|
|
};
|
|
#undef M
|
|
|
|
enum {
|
|
ACCUM_JAN = 0,
|
|
ACCUM_FEB = ACCUM_JAN + 31,
|
|
ACCUM_MAR = ACCUM_FEB + 29,
|
|
ACCUM_APR = ACCUM_MAR + 31,
|
|
ACCUM_MAY = ACCUM_APR + 30,
|
|
ACCUM_JUN = ACCUM_MAY + 31,
|
|
ACCUM_JUL = ACCUM_JUN + 30,
|
|
ACCUM_AUG = ACCUM_JUL + 31,
|
|
ACCUM_SEP = ACCUM_AUG + 31,
|
|
ACCUM_OCT = ACCUM_SEP + 30,
|
|
ACCUM_NOV = ACCUM_OCT + 31,
|
|
ACCUM_DEC = ACCUM_NOV + 30,
|
|
};
|
|
|
|
static const uint16 _accum_days_for_month[] = {
|
|
ACCUM_JAN,ACCUM_FEB,ACCUM_MAR,ACCUM_APR,
|
|
ACCUM_MAY,ACCUM_JUN,ACCUM_JUL,ACCUM_AUG,
|
|
ACCUM_SEP,ACCUM_OCT,ACCUM_NOV,ACCUM_DEC,
|
|
};
|
|
|
|
|
|
void ConvertDayToYMD(YearMonthDay *ymd, uint16 date)
|
|
{
|
|
uint yr = date / (365+365+365+366);
|
|
uint rem = date % (365+365+365+366);
|
|
uint x;
|
|
|
|
yr *= 4;
|
|
|
|
if (rem >= 366) {
|
|
rem--;
|
|
do {
|
|
rem -= 365;
|
|
yr++;
|
|
} while (rem >= 365);
|
|
if (rem >= 31+28) rem++;
|
|
}
|
|
|
|
ymd->year = yr;
|
|
|
|
x = _month_date_from_year_day[rem];
|
|
ymd->month = x >> 5;
|
|
ymd->day = x & 0x1F;
|
|
}
|
|
|
|
// year is a number between 0..?
|
|
// month is a number between 0..11
|
|
// day is a number between 1..31
|
|
uint ConvertYMDToDay(uint year, uint month, uint day)
|
|
{
|
|
uint rem;
|
|
|
|
// day in the year
|
|
rem = _accum_days_for_month[month] + day - 1;
|
|
|
|
// remove feb 29 from year 1,2,3
|
|
if (year & 3) rem += (year & 3) * 365 + (rem < 31+29);
|
|
|
|
// base date.
|
|
return (year >> 2) * (365+365+365+366) + rem;
|
|
}
|
|
|
|
// convert a date on the form
|
|
// 1920 - 2090 (MAX_YEAR_END_REAL)
|
|
// 192001 - 209012
|
|
// 19200101 - 20901231
|
|
// or if > 2090 and below 65536, treat it as a daycount
|
|
// returns -1 if no conversion was possible
|
|
uint ConvertIntDate(uint date)
|
|
{
|
|
uint year, month = 0, day = 1;
|
|
|
|
if (IS_INT_INSIDE(date, 1920, MAX_YEAR_END_REAL + 1)) {
|
|
year = date - 1920;
|
|
} else if (IS_INT_INSIDE(date, 192001, 209012+1)) {
|
|
month = date % 100 - 1;
|
|
year = date / 100 - 1920;
|
|
} else if (IS_INT_INSIDE(date, 19200101, 20901231+1)) {
|
|
day = date % 100; date /= 100;
|
|
month = date % 100 - 1;
|
|
year = date / 100 - 1920;
|
|
} else if (IS_INT_INSIDE(date, 2091, 65536))
|
|
return date;
|
|
else
|
|
return (uint)-1;
|
|
|
|
// invalid ranges?
|
|
if (month >= 12 || !IS_INT_INSIDE(day, 1, 31+1)) return (uint)-1;
|
|
|
|
return ConvertYMDToDay(year, month, day);
|
|
}
|
|
|
|
typedef struct LandscapePredefVar {
|
|
StringID names[NUM_CARGO];
|
|
byte weights[NUM_CARGO];
|
|
StringID sprites[NUM_CARGO];
|
|
|
|
uint16 initial_cargo_payment[NUM_CARGO];
|
|
byte transit_days_table_1[NUM_CARGO];
|
|
byte transit_days_table_2[NUM_CARGO];
|
|
|
|
byte railwagon_by_cargo[3][NUM_CARGO];
|
|
|
|
byte road_veh_by_cargo_start[NUM_CARGO];
|
|
byte road_veh_by_cargo_count[NUM_CARGO];
|
|
} LandscapePredefVar;
|
|
|
|
#include "table/landscape_const.h"
|
|
|
|
|
|
// Calculate constants that depend on the landscape type.
|
|
void InitializeLandscapeVariables(bool only_constants)
|
|
{
|
|
const LandscapePredefVar *lpd;
|
|
int i;
|
|
StringID str;
|
|
|
|
lpd = &_landscape_predef_var[_opt.landscape];
|
|
|
|
memcpy(_cargoc.ai_railwagon, lpd->railwagon_by_cargo, sizeof(lpd->railwagon_by_cargo));
|
|
memcpy(_cargoc.ai_roadveh_start, lpd->road_veh_by_cargo_start,sizeof(lpd->road_veh_by_cargo_start));
|
|
memcpy(_cargoc.ai_roadveh_count, lpd->road_veh_by_cargo_count,sizeof(lpd->road_veh_by_cargo_count));
|
|
|
|
for(i=0; i!=NUM_CARGO; i++) {
|
|
_cargoc.sprites[i] = lpd->sprites[i];
|
|
|
|
str = lpd->names[i];
|
|
_cargoc.names_s[i] = str;
|
|
_cargoc.names_p[i] = (str += 0x20);
|
|
_cargoc.names_long_s[i] = (str += 0x20);
|
|
_cargoc.names_long_p[i] = (str += 0x20);
|
|
_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];
|
|
}
|
|
}
|
|
|
|
|
|
void OnNewDay_Train(Vehicle *v);
|
|
void OnNewDay_RoadVeh(Vehicle *v);
|
|
void OnNewDay_Aircraft(Vehicle *v);
|
|
void OnNewDay_Ship(Vehicle *v);
|
|
static void OnNewDay_EffectVehicle(Vehicle *v) { /* empty */ }
|
|
void OnNewDay_DisasterVehicle(Vehicle *v);
|
|
|
|
typedef void OnNewVehicleDayProc(Vehicle *v);
|
|
|
|
static OnNewVehicleDayProc * _on_new_vehicle_day_proc[] = {
|
|
OnNewDay_Train,
|
|
OnNewDay_RoadVeh,
|
|
OnNewDay_Ship,
|
|
OnNewDay_Aircraft,
|
|
OnNewDay_EffectVehicle,
|
|
OnNewDay_DisasterVehicle,
|
|
};
|
|
|
|
void EnginesDailyLoop(void);
|
|
void DisasterDailyLoop(void);
|
|
void PlayersMonthlyLoop(void);
|
|
void EnginesMonthlyLoop(void);
|
|
void TownsMonthlyLoop(void);
|
|
void IndustryMonthlyLoop(void);
|
|
void StationMonthlyLoop(void);
|
|
|
|
void PlayersYearlyLoop(void);
|
|
void TrainsYearlyLoop(void);
|
|
void RoadVehiclesYearlyLoop(void);
|
|
void AircraftYearlyLoop(void);
|
|
void ShipsYearlyLoop(void);
|
|
|
|
void WaypointsDailyLoop(void);
|
|
|
|
|
|
static const uint16 _autosave_months[] = {
|
|
0, // never
|
|
0xFFF, // every month
|
|
0x249, // every 3 months
|
|
0x041, // every 6 months
|
|
0x001, // every 12 months
|
|
};
|
|
|
|
void IncreaseDate(void)
|
|
{
|
|
const int vehicles_per_day = (1 << (sizeof(_date_fract) * 8)) / 885;
|
|
uint i;
|
|
VehicleID ctr;
|
|
int t;
|
|
YearMonthDay ymd;
|
|
|
|
if (_game_mode == GM_MENU) {
|
|
_tick_counter++;
|
|
return;
|
|
}
|
|
|
|
/*if the day changed, call the vehicle event but only update a part of the vehicles
|
|
old max was i!= 12. But with that and a bigger number of vehicles (2560), per day only
|
|
a part of it could be done, namely: function called max_size date_fract (uint16) / 885 x 12 ==>
|
|
65536 / 885 = 74; 74x12 = 888. So max 888. Any vehicles above that were not _on_new_vehicle_day_proc'd
|
|
eg. aged.
|
|
So new code updates it for max vehicles.
|
|
(_vehicles_size / maximum number of times ctr is incremented before reset ) + 1 (to get last vehicles too)
|
|
max size of _date_fract / 885 (added each tick) is number of times before ctr is reset.
|
|
Calculation might look complicated, but compiler just replaces it with 35, so that's ok
|
|
*/
|
|
|
|
ctr = _vehicle_id_ctr_day;
|
|
for (i = 0; i != ((uint)GetVehiclePoolSize() / vehicles_per_day) + 1 && ctr != GetVehiclePoolSize(); i++) {
|
|
Vehicle *v = GetVehicle(ctr++);
|
|
if ((t = v->type) != 0)
|
|
_on_new_vehicle_day_proc[t - 0x10](v);
|
|
}
|
|
_vehicle_id_ctr_day = ctr;
|
|
|
|
/* increase day, and check if a new day is there? */
|
|
_tick_counter++;
|
|
|
|
_date_fract += 885;
|
|
if (_date_fract >= 885)
|
|
return;
|
|
|
|
/* yeah, increse day counter and call various daily loops */
|
|
_date++;
|
|
|
|
_vehicle_id_ctr_day = 0;
|
|
|
|
TextMessageDailyLoop();
|
|
|
|
DisasterDailyLoop();
|
|
WaypointsDailyLoop();
|
|
|
|
if (_game_mode != GM_MENU) {
|
|
InvalidateWindowWidget(WC_STATUS_BAR, 0, 0);
|
|
EnginesDailyLoop();
|
|
}
|
|
|
|
/* check if we entered a new month? */
|
|
ConvertDayToYMD(&ymd, _date);
|
|
if ((byte)ymd.month == _cur_month)
|
|
return;
|
|
_cur_month = ymd.month;
|
|
|
|
/* yes, call various monthly loops */
|
|
if (_game_mode != GM_MENU) {
|
|
if (HASBIT(_autosave_months[_opt.autosave], _cur_month)) {
|
|
_do_autosave = true;
|
|
RedrawAutosave();
|
|
}
|
|
|
|
PlayersMonthlyLoop();
|
|
EnginesMonthlyLoop();
|
|
TownsMonthlyLoop();
|
|
IndustryMonthlyLoop();
|
|
StationMonthlyLoop();
|
|
#ifdef ENABLE_NETWORK
|
|
if (_network_server)
|
|
NetworkServerMonthlyLoop();
|
|
#endif /* ENABLE_NETWORK */
|
|
}
|
|
|
|
/* check if we entered a new year? */
|
|
if ((byte)ymd.year == _cur_year)
|
|
return;
|
|
_cur_year = ymd.year;
|
|
|
|
/* yes, call various yearly loops */
|
|
|
|
PlayersYearlyLoop();
|
|
TrainsYearlyLoop();
|
|
RoadVehiclesYearlyLoop();
|
|
AircraftYearlyLoop();
|
|
ShipsYearlyLoop();
|
|
#ifdef ENABLE_NETWORK
|
|
if (_network_server)
|
|
NetworkServerYearlyLoop();
|
|
#endif /* ENABLE_NETWORK */
|
|
|
|
/* check if we reached end of the game (31 dec 2050) */
|
|
if (_cur_year == _patches.ending_date - MAX_YEAR_BEGIN_REAL) {
|
|
ShowEndGameChart();
|
|
/* check if we reached 2090 (MAX_YEAR_END_REAL), that's the maximum year. */
|
|
} else if (_cur_year == (MAX_YEAR_END + 1)) {
|
|
Vehicle *v;
|
|
_cur_year = MAX_YEAR_END;
|
|
_date = 62093;
|
|
FOR_ALL_VEHICLES(v) {
|
|
v->date_of_last_service -= 365; // 1 year is 365 days long
|
|
}
|
|
}
|
|
|
|
if (_patches.auto_euro)
|
|
CheckSwitchToEuro();
|
|
|
|
/* XXX: check if year 2050 was reached */
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
//!We're writing an own sort algorithm here, as
|
|
//!qsort isn't stable
|
|
//!Since the number of elements will be low, a
|
|
//!simple bubble sort will have to do :)
|
|
|
|
void bubblesort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *))
|
|
{
|
|
uint i,k;
|
|
void *buffer = malloc(size);
|
|
char *start = base;
|
|
|
|
nmemb--;
|
|
|
|
for (i = 0; i < nmemb; i++) {
|
|
for (k = 0; k < nmemb; k++) {
|
|
void *a, *b;
|
|
a = start + size * k;
|
|
b = start + size * (k + 1);
|
|
if (compar(a, b) > 0) {
|
|
memcpy(buffer, a, size);
|
|
memcpy(a, b, size);
|
|
memcpy(b, buffer, size);
|
|
}
|
|
}
|
|
}
|
|
|
|
free(buffer);
|
|
buffer = NULL;
|
|
}
|
|
|
|
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], 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 byte _game_opt_desc[] = {
|
|
// added a new difficulty option (town attitude) in version 4
|
|
SLE_CONDARR(GameOptions,diff, SLE_FILE_I16 | SLE_VAR_I32, 17, 0, 3),
|
|
SLE_CONDARR(GameOptions,diff, SLE_FILE_I16 | SLE_VAR_I32, 18, 4, 255),
|
|
SLE_VAR(GameOptions,diff_level, SLE_UINT8),
|
|
SLE_VAR(GameOptions,currency, SLE_UINT8),
|
|
SLE_VAR(GameOptions,kilometers, SLE_UINT8),
|
|
SLE_VAR(GameOptions,town_name, SLE_UINT8),
|
|
SLE_VAR(GameOptions,landscape, SLE_UINT8),
|
|
SLE_VAR(GameOptions,snow_line, SLE_UINT8),
|
|
SLE_VAR(GameOptions,autosave, SLE_UINT8),
|
|
SLE_VAR(GameOptions,road_side, SLE_UINT8),
|
|
SLE_END()
|
|
};
|
|
|
|
// Save load game options
|
|
static void SaveLoad_OPTS(void)
|
|
{
|
|
SlObject(&_opt, _game_opt_desc);
|
|
}
|
|
|
|
|
|
static const SaveLoadGlobVarList _date_desc[] = {
|
|
{&_date, SLE_UINT16, 0, 255},
|
|
{&_date_fract, SLE_UINT16, 0, 255},
|
|
{&_tick_counter, SLE_UINT16, 0, 255},
|
|
{&_vehicle_id_ctr_day, SLE_UINT16, 0, 255},
|
|
{&_age_cargo_skip_counter, SLE_UINT8, 0, 255},
|
|
{&_avail_aircraft, SLE_UINT8, 0, 255},
|
|
{&_cur_tileloop_tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5},
|
|
{&_cur_tileloop_tile, SLE_UINT32, 6, 255},
|
|
{&_disaster_delay, SLE_UINT16, 0, 255},
|
|
{&_station_tick_ctr, SLE_UINT16, 0, 255},
|
|
{&_random_seeds[0][0], SLE_UINT32, 0, 255},
|
|
{&_random_seeds[0][1], SLE_UINT32, 0, 255},
|
|
{&_cur_town_ctr, SLE_UINT8, 0, 255},
|
|
{&_cur_player_tick_index, SLE_FILE_U8 | SLE_VAR_UINT, 0, 255},
|
|
{&_next_competitor_start, SLE_FILE_U16 | SLE_VAR_UINT, 0, 255},
|
|
{&_trees_tick_ctr, SLE_UINT8, 0, 255},
|
|
{&_pause, SLE_UINT8, 4, 255},
|
|
{NULL, 0, 0, 0}
|
|
};
|
|
|
|
// 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[] = {
|
|
{&_saved_scrollpos_x, SLE_FILE_I16 | SLE_VAR_INT, 0, 5},
|
|
{&_saved_scrollpos_x, SLE_INT32, 6, 255},
|
|
{&_saved_scrollpos_y, SLE_FILE_I16 | SLE_VAR_INT, 0, 5},
|
|
{&_saved_scrollpos_y, SLE_INT32, 6, 255},
|
|
{&_saved_scrollpos_zoom, SLE_UINT8, 0, 255},
|
|
{NULL, 0, 0, 0}
|
|
};
|
|
|
|
static void SaveLoad_VIEW(void)
|
|
{
|
|
SlGlobList(_view_desc);
|
|
}
|
|
|
|
static uint32 _map_dim_x;
|
|
static uint32 _map_dim_y;
|
|
|
|
static const SaveLoadGlobVarList _map_dimensions[] = {
|
|
{&_map_dim_x, SLE_UINT32, 6, 255},
|
|
{&_map_dim_y, SLE_UINT32, 6, 255},
|
|
{NULL, 0, 0, 0}
|
|
};
|
|
|
|
static void Save_MAPSIZE(void)
|
|
{
|
|
_map_dim_x = MapSizeX();
|
|
_map_dim_y = MapSizeY();
|
|
SlGlobList(_map_dimensions);
|
|
}
|
|
|
|
static void Load_MAPSIZE(void)
|
|
{
|
|
uint bits_x = 0;
|
|
uint bits_y = 0;
|
|
|
|
SlGlobList(_map_dimensions);
|
|
|
|
for (; _map_dim_x > 1; _map_dim_x >>= 1) ++bits_x;
|
|
for (; _map_dim_y > 1; _map_dim_y >>= 1) ++bits_y;
|
|
|
|
InitMap(bits_x, bits_y);
|
|
}
|
|
|
|
static void SaveLoad_MAPT(void)
|
|
{
|
|
SlArray(_map_type_and_height, MapSize(), SLE_UINT8);
|
|
}
|
|
|
|
static void SaveLoad_MAP2(void)
|
|
{
|
|
if (_sl.version < 5) {
|
|
/* In those versions the _map2 was 8 bits */
|
|
SlArray(_map2, MapSize(), SLE_FILE_U8 | SLE_VAR_U16);
|
|
} else {
|
|
SlArray(_map2, MapSize(), SLE_UINT16);
|
|
}
|
|
}
|
|
|
|
static void SaveLoad_M3LO(void)
|
|
{
|
|
SlArray(_map3_lo, MapSize(), SLE_UINT8);
|
|
}
|
|
|
|
static void SaveLoad_M3HI(void)
|
|
{
|
|
SlArray(_map3_hi, MapSize(), SLE_UINT8);
|
|
}
|
|
|
|
static void SaveLoad_MAPO(void)
|
|
{
|
|
SlArray(_map_owner, MapSize(), SLE_UINT8);
|
|
}
|
|
|
|
static void SaveLoad_MAP5(void)
|
|
{
|
|
SlArray(_map5, MapSize(), SLE_UINT8);
|
|
}
|
|
|
|
static void SaveLoad_MAPE(void)
|
|
{
|
|
SlArray(_map_extra_bits, MapSize() / 4, 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;
|
|
for(; count; count--, cht++)
|
|
{
|
|
cht->been_used = (byte)SlReadByte();
|
|
cht->value = (byte)SlReadByte();
|
|
}
|
|
}
|
|
|
|
|
|
const ChunkHandler _misc_chunk_handlers[] = {
|
|
{ 'MAPS', Save_MAPSIZE, Load_MAPSIZE, CH_RIFF },
|
|
{ 'MAPT', SaveLoad_MAPT, SaveLoad_MAPT, CH_RIFF },
|
|
{ 'MAP2', SaveLoad_MAP2, SaveLoad_MAP2, CH_RIFF },
|
|
{ 'M3LO', SaveLoad_M3LO, SaveLoad_M3LO, CH_RIFF },
|
|
{ 'M3HI', SaveLoad_M3HI, SaveLoad_M3HI, CH_RIFF },
|
|
{ 'MAPO', SaveLoad_MAPO, SaveLoad_MAPO, CH_RIFF },
|
|
{ 'MAP5', SaveLoad_MAP5, SaveLoad_MAP5, CH_RIFF },
|
|
{ 'MAPE', SaveLoad_MAPE, SaveLoad_MAPE, CH_RIFF },
|
|
|
|
{ 'NAME', Save_NAME, Load_NAME, CH_ARRAY},
|
|
{ 'DATE', SaveLoad_DATE, SaveLoad_DATE, CH_RIFF},
|
|
{ 'VIEW', SaveLoad_VIEW, SaveLoad_VIEW, CH_RIFF},
|
|
{ 'OPTS', SaveLoad_OPTS, SaveLoad_OPTS, CH_RIFF},
|
|
{ 'CHTS', Save_CHTS, Load_CHTS, CH_RIFF | CH_LAST}
|
|
};
|