bool physics_file_is_m1(void)
{
bool m1_physics = false;
// check for M1 physics
OpenedFile PhysicsFile;
short SavedType, SavedError = get_game_error(&SavedType);
if (PhysicsFileSpec.Open(PhysicsFile))
{
uint32 tag = SDL_ReadBE32(PhysicsFile.GetRWops());
switch (tag)
{
case M1_MONSTER_PHYSICS_TAG:
case M1_EFFECTS_PHYSICS_TAG:
case M1_PROJECTILE_PHYSICS_TAG:
case M1_PHYSICS_PHYSICS_TAG:
case M1_WEAPONS_PHYSICS_TAG:
m1_physics = true;
break;
default:
break;
}
PhysicsFile.Close();
}
set_game_error(SavedType, SavedError);
return m1_physics;
}
static void load_preferences(
void)
{
/* If it was already allocated, we are reloading, so free the old one.. */
if(prefInfo->wad) {
free_wad(prefInfo->wad);
prefInfo->wad= NULL;
}
OpenedFile PrefsFile;
if (open_wad_file_for_reading(prefInfo->PrefsFile,PrefsFile)) {
struct wad_header header;
/* Read the header from the wad file */
if(read_wad_header(PrefsFile, &header)) {
/* Read the indexed wad from the file */
prefInfo->wad= read_indexed_wad_from_file(PrefsFile, &header, 0, false);
// LP change: more graceful degradation
if (!prefInfo->wad) {
set_game_error(gameError, errUnknownWadVersion);
}
}
/* Close the file.. */
close_wad_file(PrefsFile);
}
}
/* --------- local code */
static struct wad_data *get_physics_wad_data(
bool *bungie_physics)
{
struct wad_data *wad= NULL;
// dprintf("Open is: %d %d %.*s", physics_file.vRefNum, physics_file.parID, physics_file.name[0], physics_file.name+1);
OpenedFile PhysicsFile;
if(open_wad_file_for_reading(PhysicsFileSpec,PhysicsFile))
{
struct wad_header header;
if(read_wad_header(PhysicsFile, &header))
{
if(header.data_version==BUNGIE_PHYSICS_DATA_VERSION || header.data_version==PHYSICS_DATA_VERSION)
{
wad= read_indexed_wad_from_file(PhysicsFile, &header, 0, true);
if(header.data_version==BUNGIE_PHYSICS_DATA_VERSION)
{
*bungie_physics= true;
} else {
*bungie_physics= false;
}
}
}
close_wad_file(PhysicsFile);
}
/* Reset any errors that might have occurred.. */
set_game_error(systemError, errNone);
return wad;
}
// Open resource file
bool FileSpecifier::Open(OpenedResourceFile &OFile, bool Writable)
{
OFile.Close();
OFile.f = open_res_file(*this);
err = OFile.f ? 0 : errno;
if (OFile.f == NULL) {
set_game_error(systemError, err);
return false;
} else
return true;
}
// Open data file
bool FileSpecifier::Open(OpenedFile &OFile, bool Writable)
{
OFile.Close();
SDL_RWops *f;
#ifdef __MACOS__
if (!Writable)
f = OFile.f = open_fork_from_existing_path(GetPath(), false);
else
#endif
{
#ifdef HAVE_ZZIP
if (!Writable)
{
f = OFile.f = SDL_RWFromZZIP(unix_path_separators(GetPath()).c_str(), "rb");
}
else
#endif
f = OFile.f = SDL_RWFromFile(GetPath(), Writable ? "wb+" : "rb");
}
err = f ? 0 : errno;
if (f == NULL) {
set_game_error(systemError, err);
return false;
}
if (Writable)
return true;
// Transparently handle AppleSingle and MacBinary files on reading
int32 offset, data_length, rsrc_length;
if (is_applesingle(f, false, offset, data_length)) {
OFile.is_forked = true;
OFile.fork_offset = offset;
OFile.fork_length = data_length;
SDL_RWseek(f, offset, SEEK_SET);
return true;
} else if (is_macbinary(f, data_length, rsrc_length)) {
OFile.is_forked = true;
OFile.fork_offset = 128;
OFile.fork_length = data_length;
SDL_RWseek(f, 128, SEEK_SET);
return true;
}
SDL_RWseek(f, 0, SEEK_SET);
return true;
}
void *get_network_physics_buffer(
int32 *physics_length)
{
if (physics_file_is_m1())
{
bool success = false;
uint8 *data = NULL;
OpenedFile PhysicsFile;
if (PhysicsFileSpec.Open(PhysicsFile) &&
PhysicsFile.GetLength(*physics_length))
{
data = (uint8 *)malloc(*physics_length + 4);
SDL_RWops *ops = SDL_RWFromMem(data, *physics_length + 4);
success = SDL_WriteBE32(ops, uint32(M1_PHYSICS_MAGIC_COOKIE));
if (success)
success = SDL_WriteBE32(ops, uint32(*physics_length));
SDL_RWclose(ops);
if (success)
success = PhysicsFile.Read(*physics_length, &data[8]);
if (!success)
free(data);
}
if (!success)
{
*physics_length = 0;
return NULL;
}
return data;
}
short SavedType, SavedError = get_game_error(&SavedType);
void *data= get_flat_data(PhysicsFileSpec, false, 0);
set_game_error(SavedType, SavedError);
if(data)
{
*physics_length= get_flat_data_length(data);
} else {
*physics_length= 0;
}
return data;
}
/* preferences pointer.. */
bool w_open_preferences_file(
char *PrefName,
Typecode Type)
{
int error = 0;
bool success= true;
/* allocate space for our global structure to keep track of the prefs file */
prefInfo = NULL;
try {
prefInfo = new preferences_info;
#if defined(mac)
prefInfo->PrefsFile.SetParentToPreferences();
prefInfo->PrefsFile.SetName(PrefName,Type);
/* check for the preferences folder using FindFolder, creating it if necessary */
#elif defined(SDL)
prefInfo->PrefsFile.SetToPreferencesDir();
prefInfo->PrefsFile += PrefName;
#endif
/* does the preferences file exist? */
load_preferences(); /* Uses prefInfo.. */
if(error_pending()) {
short type;
error= get_game_error(&type);
if(type==systemError) {
if (!prefInfo->PrefsFile.Exists()) {
prefInfo->PrefsFile.Create(Type);
prefInfo->wad = create_empty_wad();
set_game_error(systemError,prefInfo->PrefsFile.GetError());
w_write_preferences_file();
}
}
else {
/* Something was invalid.. */
if (prefInfo->PrefsFile.Delete()) {
prefInfo->wad= create_empty_wad();
set_game_error(systemError, error);
w_write_preferences_file();
}
set_game_error(systemError, errNone);
}
}
} catch (...) {
dprintf("In \"catch\"");
set_game_error(systemError, memory_error());
}
if (error) {
/* if something is broken, make sure we at least return valid prefs */
if(prefInfo && !prefInfo->wad) {
prefInfo->wad= create_empty_wad();
}
}
/* Gotta bail... */
if(!prefInfo || !prefInfo->wad) {
success= false;
}
// dump_wad(prefInfo->wad);
return success;
}
void w_write_preferences_file(
void)
{
struct wad_header header;
/* We can be called atexit. */
if(error_pending()) {
set_game_error(systemError, errNone);
}
assert(!error_pending());
// LP: need to re-create that file to avoid
// nonexistence-induced errors in the MacOS version
Typecode Type = prefInfo->PrefsFile.GetType();
// Setting to default if _typecode_unknown
if (Type == _typecode_unknown) {
Type = _typecode_preferences;
}
// CB: delete old prefs file, we're overwriting it
// (writing can go wrong when the old file is still in place)
prefInfo->PrefsFile.Delete();
// Re-creating the file
// CB: is Create() supposed to truncate the file to zero length
// if it already exists? Then the Delete() call above can go away.
prefInfo->PrefsFile.Create(Type);
OpenedFile PrefsFile;
if (open_wad_file_for_writing(prefInfo->PrefsFile,PrefsFile)) {
struct directory_entry entry;
fill_default_wad_header(prefInfo->PrefsFile,
CURRENT_WADFILE_VERSION,
CURRENT_PREF_WADFILE_VERSION,
1, 0l,
&header);
if (write_wad_header(PrefsFile, &header)) {
int32 wad_length;
int32 offset= sizeof(struct wad_header);
/* Length? */
wad_length= calculate_wad_length(&header, prefInfo->wad);
/* Set the entry data..... (and put into correct byte-order for writing) */
set_indexed_directory_offset_and_length(&header,
&entry, 0, offset, wad_length, 0);
/* Now write it.. */
if (write_wad(PrefsFile, &header, prefInfo->wad, offset)) {
offset+= wad_length;
header.directory_offset= offset;
if (write_wad_header(PrefsFile, &header) &&
write_directorys(PrefsFile, &header, &entry)) {
/* Success! */
}
else {
assert(error_pending());
}
}
else {
assert(error_pending());
}
/* Since we don't free it, it is opened.. */
}
else {
assert(error_pending());
}
close_wad_file(PrefsFile);
}
}
