Changeset - r1913:56982b97fe91
Parent rev.
Child rev.
[Not reviewed]
master
0 1 0
Darkvater - 19 years ago 2005-06-06 13:11:35
darkvater@openttd.org
(svn r2419) - Fix: saving no longer changes your cursor if it is in a non-mouse state.
- Fix: autosaving/loading; it no longer returns a fail code when saving is already in progress. In the case of a load, the game pauses to wait for the save to finish. (glx)
- Fix (regression): fix a bug in the 'buggy load' code where a wrong offset was used for the LZO format.
1 file changed with 58 insertions and 41 deletions:
saveload.c
58
41
0 comments (0 inline, 0 general)
saveload.c
➞
Show inline comments
 
@@ -822,37 +822,54 @@ static void UninitNoComp(void)
 
//********************************************
 

			




	
	
	
		
 
enum {

			




	
	
	
		
 
	SAVELOAD_POOL_BLOCK_SIZE_BITS = 17,

			




	
	
	
		
 
	SAVELOAD_POOL_MAX_BLOCKS = 500

			




	
	
	
		
 
	SAVE_POOL_BLOCK_SIZE_BITS = 17,

			




	
	
	
		
 
	SAVE_POOL_MAX_BLOCKS = 500

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#include "network.h"

			




	
	
	
		
 
#include "table/strings.h"

			




	
	
	
		
 
#include "table/sprites.h"

			




	
	
	
		
 
#include "gfx.h"

			




	
	
	
		
 
#include "gui.h"

			




	
	
	
		
 

			




	
	
	
		
 
typedef struct ThreadedSave {

			




	
	
	
		
 
	MemoryPool *save;

			




	
	
	
		
 
	uint count;

			




	
	
	
		
 
	bool ff_state;

			




	
	
	
		
 
	bool saveinprogress;

			




	
	
	
		
 
	uint32 cursor;

			




	
	
	
		
 
} ThreadedSave;

			




	
	
	
		
 

			




	
	
	
		
 
/* A maximum size of of 128K * 500 = 64.000KB savegames */

			




	
	
	
		
 
static MemoryPool _saveload_pool = {"Savegame", SAVELOAD_POOL_MAX_BLOCKS, SAVELOAD_POOL_BLOCK_SIZE_BITS, sizeof(byte), NULL, 0, 0, NULL};

			




	
	
	
		
 
static uint _save_byte_count;

			




	
	
	
		
 
static MemoryPool _save_pool = {"Savegame", SAVE_POOL_MAX_BLOCKS, SAVE_POOL_BLOCK_SIZE_BITS, sizeof(byte), NULL, 0, 0, NULL};

			




	
	
	
		
 
static ThreadedSave _ts;

			




	
	
	
		
 

			




	
	
	
		
 
static bool InitMem(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
	CleanPool(&_saveload_pool);

			




	
	
	
		
 
	AddBlockToPool(&_saveload_pool);

			




	
	
	
		
 
	_ts.save = &_save_pool;

			




	
	
	
		
 
	_ts.count = 0;

			




	
	
	
		
 

			




	
	
	
		
 
	CleanPool(_ts.save);

			




	
	
	
		
 
	AddBlockToPool(_ts.save);

			




	
	
	
		
 

			




	
	
	
		
 
	/* A block from the pool is a contigious area of memory, so it is safe to write to it sequentially */

			




	
	
	
		
 
	_save_byte_count = 0;

			




	
	
	
		
 
	_sl.bufsize = _saveload_pool.total_items;

			




	
	
	
		
 
	_sl.buf = (byte*)GetItemFromPool(&_saveload_pool, _save_byte_count);

			




	
	
	
		
 
	_sl.bufsize = _ts.save->total_items;

			




	
	
	
		
 
	_sl.buf = (byte*)GetItemFromPool(_ts.save, _ts.count);

			




	
	
	
		
 
	return true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static void UnInitMem(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
	CleanPool(&_saveload_pool);

			




	
	
	
		
 
	CleanPool(_ts.save);

			




	
	
	
		
 
	_ts.save = NULL;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static void WriteMem(uint size)

			




	
	
	
		
 
{

			




	
	
	
		
 
	_save_byte_count += size;

			




	
	
	
		
 
	_ts.count += size;

			




	
	
	
		
 
	/* Allocate new block and new buffer-pointer */

			




	
	
	
		
 
	AddBlockIfNeeded(&_saveload_pool, _save_byte_count);

			




	
	
	
		
 
	_sl.buf = (byte*)GetItemFromPool(&_saveload_pool, _save_byte_count);

			




	
	
	
		
 
	AddBlockIfNeeded(_ts.save, _ts.count);

			




	
	
	
		
 
	_sl.buf = (byte*)GetItemFromPool(_ts.save, _ts.count);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
//********************************************

			




	
	
		
 
@@ -1152,33 +1169,31 @@ static inline int AbortSaveLoad(void)

			




	
	
	
		
 
	return SL_ERROR;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
#include "network.h"

			




	
	
	
		
 
#include "table/strings.h"

			




	
	
	
		
 
#include "table/sprites.h"

			




	
	
	
		
 
#include "gfx.h"

			




	
	
	
		
 
#include "gui.h"

			




	
	
	
		
 

			




	
	
	
		
 
static bool _saving_game = false;

			




	
	
	
		
 

			




	
	
	
		
 
/** Update the gui accordingly when starting saving

			




	
	
	
		
 
 * and set locks on saveload */

			




	
	
	
		
 
 * and set locks on saveload. Also turn off fast-forward cause with that

			




	
	
	
		
 
 * saving takes Aaaaages */

			




	
	
	
		
 
static inline void SaveFileStart(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
	SetMouseCursor(SPR_CURSOR_ZZZ);

			




	
	
	
		
 
	_ts.ff_state = _fast_forward;

			




	
	
	
		
 
	_fast_forward = false;

			




	
	
	
		
 
	if (_cursor.sprite == SPR_CURSOR_MOUSE) SetMouseCursor(SPR_CURSOR_ZZZ);

			




	
	
	
		
 

			




	
	
	
		
 
	SendWindowMessage(WC_STATUS_BAR, 0, true, 0, 0);

			




	
	
	
		
 
	_saving_game = true;

			




	
	
	
		
 
	_ts.saveinprogress = true;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
/** Update the gui accordingly when saving is done and release locks

			




	
	
	
		
 
 * on saveload */

			




	
	
	
		
 
static inline void SaveFileDone(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
	_fast_forward = _ts.ff_state;

			




	
	
	
		
 
	if (_cursor.sprite == SPR_CURSOR_ZZZ) SetMouseCursor(SPR_CURSOR_MOUSE);

			




	
	
	
		
 

			




	
	
	
		
 
	SendWindowMessage(WC_STATUS_BAR, 0, false, 0, 0);

			




	
	
	
		
 
	_saving_game = false;

			




	
	
	
		
 
	_ts.saveinprogress = false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
/** We have written the whole game into memory, _saveload_pool, now find

			




	
	
	
		
 
/** We have written the whole game into memory, _save_pool, now find

			




	
	
	
		
 
 * and appropiate compressor and start writing to file.

			




	
	
	
		
 
 */

			




	
	
	
		
 
static bool SaveFileToDisk(void *ptr)

			




	
	
		
 
@@ -1215,24 +1230,24 @@ static bool SaveFileToDisk(void *ptr)

			




	
	
	
		
 

			




	
	
	
		
 
	{

			




	
	
	
		
 
		uint i;

			




	
	
	
		
 
		uint count = 1 << _saveload_pool.block_size_bits;

			




	
	
	
		
 
		uint count = 1 << _ts.save->block_size_bits;

			




	
	
	
		
 

			




	
	
	
		
 
		assert(_save_byte_count == _sl.offs_base);

			




	
	
	
		
 
		for (i = 0; i != _saveload_pool.current_blocks - 1; i++) {

			




	
	
	
		
 
			_sl.buf = _saveload_pool.blocks[i];

			




	
	
	
		
 
		assert(_ts.count == _sl.offs_base);

			




	
	
	
		
 
		for (i = 0; i != _ts.save->current_blocks - 1; i++) {

			




	
	
	
		
 
			_sl.buf = _ts.save->blocks[i];

			




	
	
	
		
 
			fmt->writer(count);

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		/* The last block is (almost) always not fully filled, so only write away

			




	
	
	
		
 
		 * as much data as it is in there */

			




	
	
	
		
 
		_sl.buf = _saveload_pool.blocks[i];

			




	
	
	
		
 
		fmt->writer(_save_byte_count - (i * count));

			




	
	
	
		
 
		_sl.buf = _ts.save->blocks[i];

			




	
	
	
		
 
		fmt->writer(_ts.count - (i * count));

			




	
	
	
		
 

			




	
	
	
		
 
		_sl.buf = tmp; // XXX - reset _sl.buf to its original value to let it continue its internal usage

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	fmt->uninit_write();

			




	
	
	
		
 
	assert(_save_byte_count == _sl.offs_base);

			




	
	
	
		
 
	assert(_ts.count == _sl.offs_base);

			




	
	
	
		
 
	GetSavegameFormat("memory")->uninit_write(); // clean the memorypool

			




	
	
	
		
 
	fclose(_sl.fh);

			




	
	
	
		
 

			




	
	
		
 
@@ -1254,7 +1269,15 @@ int SaveOrLoad(const char *filename, int

			




	
	
	
		
 
	const SaveLoadFormat *fmt;

			




	
	
	
		
 
  uint version;

			




	
	
	
		
 

			




	
	
	
		
 
	/* Load a TTDLX or TTDPatch game */

			




	
	
	
		
 
	/* An instance of saving is already active, so wait until it is done */

			




	
	
	
		
 
	if (_ts.saveinprogress) {

			




	
	
	
		
 
		if (!_do_autosave) ShowErrorMessage(_error_message, STR_SAVE_STILL_IN_PROGRESS, 0, 0);

			




	
	
	
		
 
		JoinOTTDThread(); // synchronize and wait until save is finished to continue

			




	
	
	
		
 
		// nonsense to do an autosave while we were still saving our game, so skip it

			




	
	
	
		
 
		if (_do_autosave) return SL_OK;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
  /* Load a TTDLX or TTDPatch game */

			




	
	
	
		
 
	if (mode == SL_OLD_LOAD) {

			




	
	
	
		
 
		InitializeGame(8, 8); // set a mapsize of 256x256 for TTDPatch games or it might get confused

			




	
	
	
		
 
		if (!LoadOldSaveGame(filename)) return SL_REINIT;

			




	
	
		
 
@@ -1262,12 +1285,6 @@ int SaveOrLoad(const char *filename, int

			




	
	
	
		
 
		return SL_OK;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	/* An instance of saving is already active, don't start any other cause of global variables */

			




	
	
	
		
 
	if (_saving_game == true) {

			




	
	
	
		
 
		if (!_do_autosave) ShowErrorMessage(_error_message, STR_SAVE_STILL_IN_PROGRESS, 0, 0);

			




	
	
	
		
 
		return SL_ERROR;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	_sl.fh = fopen(filename, (mode == SL_SAVE) ? "wb" : "rb");

			




	
	
	
		
 
	if (_sl.fh == NULL) {

			




	
	
	
		
 
		DEBUG(misc, 0) ("Cannot open savegame for saving/loading.");

			




	
	
		
 
@@ -1344,7 +1361,7 @@ int SaveOrLoad(const char *filename, int

			




	
	
	
		
 
				rewind(_sl.fh);

			




	
	
	
		
 
				_sl.version = version = 0;

			




	
	
	
		
 
				_sl.full_version = 0;

			




	
	
	
		
 
				fmt = _saveload_formats + 0; // LZO

			




	
	
	
		
 
				fmt = _saveload_formats + 1; // LZO

			




	
	
	
		
 
				break;

			




	
	
	
		
 
			}

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: code.theleruby.com-48
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support