/* Caller should assert this. */
void *w_get_data_from_preferences(
WadDataType tag, /* Tag to read */
size_t expected_size, /* Data size */
prefs_initializer initialize, /* Call if I have to allocate it.. */
prefs_validater validate) /* Verify function-> fixes if bad and returns true */
{
void *data;
size_t length;
assert(prefInfo->wad);
data= extract_type_from_wad(prefInfo->wad, tag, &length);
/* If we got the data, but it was the wrong size, or we didn't get the data... */
if((data && length != expected_size) || (!data))
{
/* I have a copy of this pointer in the wad-> it's okay to do this */
data= malloc(expected_size);
if(data)
{
/* Initialize it */
initialize(data);
/* Append it to the file, for writing out.. */
append_data_to_wad(prefInfo->wad, tag, data, expected_size, 0);
/* Free our private pointer */
free(data);
/* Return the real one. */
data= extract_type_from_wad(prefInfo->wad, tag, &length);
}
}
if(data)
{
/* Only call the validation function if it is present. */
if(validate && validate(data))
{
char *new_data;
/* We can't hand append_data_to_wad a copy of the data pointer it */
/* contains */
new_data= (char *)malloc(expected_size);
assert(new_data);
memcpy(new_data, data, expected_size);
/* Changed in the validation. Save to our wad. */
append_data_to_wad(prefInfo->wad, tag, new_data, expected_size, 0);
/* Free the new copy */
free(new_data);
/* And reextract the pointer.... */
data= extract_type_from_wad(prefInfo->wad, tag, &length);
}
}
return data;
}
static void import_physics_wad_data(
struct wad_data *wad)
{
// LP: this code is copied out of game_wad.c
size_t data_length;
byte *data;
size_t count;
bool PhysicsModelLoaded = false;
data= (unsigned char *)extract_type_from_wad(wad, MONSTER_PHYSICS_TAG, &data_length);
count = data_length/SIZEOF_monster_definition;
assert(count*SIZEOF_monster_definition == data_length);
assert(count <= NUMBER_OF_MONSTER_TYPES);
if (data_length > 0)
{
PhysicsModelLoaded = true;
unpack_monster_definition(data,count);
}
data= (unsigned char *)extract_type_from_wad(wad, EFFECTS_PHYSICS_TAG, &data_length);
count = data_length/SIZEOF_effect_definition;
assert(count*SIZEOF_effect_definition == data_length);
assert(count <= NUMBER_OF_EFFECT_TYPES);
if (data_length > 0)
{
PhysicsModelLoaded = true;
unpack_effect_definition(data,count);
}
data= (unsigned char *)extract_type_from_wad(wad, PROJECTILE_PHYSICS_TAG, &data_length);
count = data_length/SIZEOF_projectile_definition;
assert(count*SIZEOF_projectile_definition == data_length);
assert(count <= NUMBER_OF_PROJECTILE_TYPES);
if (data_length > 0)
{
PhysicsModelLoaded = true;
unpack_projectile_definition(data,count);
}
data= (unsigned char *)extract_type_from_wad(wad, PHYSICS_PHYSICS_TAG, &data_length);
count = data_length/SIZEOF_physics_constants;
assert(count*SIZEOF_physics_constants == data_length);
assert(count <= get_number_of_physics_models());
if (data_length > 0)
{
PhysicsModelLoaded = true;
unpack_physics_constants(data,count);
}
data= (unsigned char*) extract_type_from_wad(wad, WEAPONS_PHYSICS_TAG, &data_length);
count = data_length/SIZEOF_weapon_definition;
assert(count*SIZEOF_weapon_definition == data_length);
assert(count <= get_number_of_weapon_types());
if (data_length > 0)
{
PhysicsModelLoaded = true;
unpack_weapon_definition(data,count);
}
}
SDL_Surface *WadImageCache::image_from_desc(WadImageDescriptor& desc)
{
SDL_Surface *surface = NULL;
OpenedFile wad_file;
if (open_wad_file_for_reading(desc.file, wad_file))
{
struct wad_header header;
if (read_wad_header(wad_file, &header))
{
struct wad_data *wad;
wad = read_indexed_wad_from_file(wad_file, &header, desc.index, true);
if (wad)
{
void *data;
size_t length;
data = extract_type_from_wad(wad, desc.tag, &length);
if (data && length)
{
SDL_RWops *rwops = SDL_RWFromConstMem(data, length);
#ifdef HAVE_SDL_IMAGE
surface = IMG_Load_RW(rwops, 1);
#else
surface = SDL_LoadBMP_RW(rwops, 1);
#endif
}
free_wad(wad);
}
}
close_wad_file(wad_file);
}
clear_game_error();
return surface;
}
bool QuickSaveLoader::ParseQuickSave(FileSpecifier& file_name)
{
struct wad_header header;
struct wad_data *wad;
OpenedFile file;
if (file_name.Open(file))
{
if (read_wad_header(file, &header))
{
wad = read_indexed_wad_from_file(file, &header, SAVE_GAME_METADATA_INDEX, true);
if (wad)
{
size_t data_length;
char *raw_metadata = (char *)extract_type_from_wad(wad, SAVE_META_TAG, &data_length);
std::string metadata = std::string(raw_metadata, data_length);
boost::property_tree::ptree pt;
std::istringstream strm(metadata);
try {
boost::property_tree::ini_parser::read_ini(strm, pt);
} catch (...) {
return false;
}
QuickSave Data = QuickSave();
Data.save_file = file_name;
Data.name = pt.get("name", Data.name);
Data.level_name = pt.get("level_name", Data.level_name);
Data.ticks = pt.get("ticks", Data.ticks);
Data.formatted_ticks = pt.get("ticks_formatted", Data.formatted_ticks);
Data.save_time = pt.get("time", Data.save_time);
Data.formatted_time = pt.get("time_formatted", Data.formatted_time);
Data.players = pt.get("players", Data.players);
QuickSaves::instance()->add(Data);
free_wad(wad);
}
}
return true;
}
return false;
}
void create_updated_save(QuickSave& save)
{
// read data from existing save file
struct wad_header header;
struct wad_data *game_wad, *orig_meta_wad, *new_meta_wad;
int32 game_wad_length;
std::string imagedata;
OpenedFile currentFile;
if (save.save_file.Open(currentFile))
{
if (read_wad_header(currentFile, &header))
{
game_wad = read_indexed_wad_from_file(currentFile, &header, 0, false);
if (game_wad) game_wad_length = calculate_wad_length(&header, game_wad);
orig_meta_wad = read_indexed_wad_from_file(currentFile, &header, SAVE_GAME_METADATA_INDEX, true);
if (orig_meta_wad)
{
size_t data_length;
char *raw_imagedata = (char *)extract_type_from_wad(orig_meta_wad, SAVE_IMG_TAG, &data_length);
imagedata = std::string(raw_imagedata, data_length);
}
}
close_wad_file(currentFile);
}
// create updated save file
short err = 0;
int32 offset, meta_wad_length;
struct directory_entry entries[2];
FileSpecifier TempFile;
TempFile.SetTempName(save.save_file);
if (create_wadfile(TempFile, _typecode_savegame))
{
OpenedFile SaveFile;
if(open_wad_file_for_writing(TempFile, SaveFile))
{
if (write_wad_header(SaveFile, &header))
{
offset = SIZEOF_wad_header;
set_indexed_directory_offset_and_length(&header, entries, 0, offset, game_wad_length, 0);
if (write_wad(SaveFile, &header, game_wad, offset))
{
offset += game_wad_length;
header.directory_offset= offset;
new_meta_wad = build_meta_game_wad(build_save_metadata(save), imagedata, &header, &meta_wad_length);
if (new_meta_wad)
{
set_indexed_directory_offset_and_length(&header, entries, 1, offset, meta_wad_length, SAVE_GAME_METADATA_INDEX);
if (write_wad(SaveFile, &header, new_meta_wad, offset))
{
offset += meta_wad_length;
header.directory_offset= offset;
if (write_wad_header(SaveFile, &header) && write_directorys(SaveFile, &header, entries))
{
}
}
free_wad(new_meta_wad);
}
}
free_wad(game_wad);
free_wad(orig_meta_wad);
}
err = SaveFile.GetError();
close_wad_file(SaveFile);
}
if (!err)
{
if (!TempFile.Rename(save.save_file))
{
err = 1;
}
}
}
if (err || error_pending())
{
if (!err) err = get_game_error(NULL);
alert_user(infoError, strERRORS, fileError, err);
clear_game_error();
}
}
