void dl_index_write(dl_index *di, PHYSFS_file *fp)
{
PHYSFS_writeSLE16(fp, di->segnum);
PHYSFSX_writeU8(fp, di->sidenum);
PHYSFSX_writeU8(fp, di->count);
PHYSFS_writeSLE16(fp, di->index);
}
int control_center_triggers_write(control_center_triggers *cct, PHYSFS_file *fp)
{
int j;
PHYSFS_writeSLE16(fp, cct->num_links);
for (j = 0; j < MAX_CONTROLCEN_LINKS; j++)
PHYSFS_writeSLE16(fp, cct->seg[j]);
for (j = 0; j < MAX_CONTROLCEN_LINKS; j++)
PHYSFS_writeSLE16(fp, cct->side[j]);
return 1;
}
static void write_children(const vcsegptr_t seg, ubyte bit_mask, PHYSFS_File *SaveFile)
{
for (int bit = 0; bit < MAX_SIDES_PER_SEGMENT; bit++)
{
if (bit_mask & (1 << bit))
PHYSFS_writeSLE16(SaveFile, seg->children[bit]);
}
}
//writes out an uncompressed RGB .tga file
//if we got really spiffy, we could optionally link in libpng or something, and use that.
void write_bmp(char *savename,int w,int h,unsigned char *buf){
PHYSFS_file *f;
f = PHYSFSX_openWriteBuffered(savename);
if (f) {
GLubyte targaMagic[12] = { 0, //no identification field
0,//no colormap
2,//RGB image (well, BGR, actually)
0, 0, 0, 0, 0, 0, 0, 0, 0 };//no colormap or image origin stuff.
GLubyte blah;
int r;
GLubyte *s;
int x,y;
//write .TGA header.
PHYSFS_write(f, targaMagic, sizeof(targaMagic), 1);
PHYSFS_writeSLE16(f, w);
PHYSFS_writeSLE16(f, h);
PHYSFSX_writeU8(f, 24); // 24 bpp
PHYSFSX_writeU8(f, 0); // no attribute bits, origin is lowerleft, no interleave
s=buf;
for (y=0;y<h;y++){//TGAs use BGR ordering of data.
for (x=0;x<w;x++){
blah=s[0];
s[0]=s[2];
s[2]=blah;
s+=3;
}
}
x=0;y=w*h*3;
while (y > 0)
{
r = (int)PHYSFS_write(f, buf + x, 1, y);
if (r<=0){
mprintf((0,"screenshot error, couldn't write to %s (err %i)\n",savename,errno));
break;
}
x+=r;y-=r;
}
PHYSFS_close(f);
}else{
mprintf((0,"screenshot error, couldn't open %s (err %i)\n",savename,errno));
}
}
static void write_special(const vcsegptr_t seg, ubyte bit_mask, PHYSFS_File *SaveFile)
{
if (bit_mask & (1 << MAX_SIDES_PER_SEGMENT))
{
PHYSFSX_writeU8(SaveFile, seg->special);
PHYSFSX_writeU8(SaveFile, seg->matcen_num);
PHYSFS_writeSLE16(SaveFile, seg->value);
}
}
void delta_light_write(delta_light *dl, PHYSFS_file *fp)
{
PHYSFS_writeSLE16(fp, dl->segnum);
PHYSFSX_writeU8(fp, dl->sidenum);
PHYSFSX_writeU8(fp, dl->dummy);
PHYSFSX_writeU8(fp, dl->vert_light[0]);
PHYSFSX_writeU8(fp, dl->vert_light[1]);
PHYSFSX_writeU8(fp, dl->vert_light[2]);
PHYSFSX_writeU8(fp, dl->vert_light[3]);
}
void FileStream::add16(int16 v)
{
if(!m_caching) {
if(PHYSFS_writeSLE16(m_fileHandle, v) == 0)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 2);
stdext::writeSLE16(&m_data[m_pos], v);
m_pos += 2;
}
}
static void dump_fix_as_short( fix value, int nbits, PHYSFS_File *SaveFile )
{
short short_value;
auto int_value = value >> nbits;
if( int_value > 0x7fff ) {
short_value = 0x7fff;
}
else if( int_value < -0x7fff ) {
short_value = -0x7fff;
}
else
short_value = static_cast<short>(int_value);
PHYSFS_writeSLE16(SaveFile, short_value);
}
static void write_verts(const vcsegptr_t seg, PHYSFS_File *SaveFile)
{
range_for (auto &i, seg->verts)
PHYSFS_writeSLE16(SaveFile, i);
}
//writes one object to the given file
void write_object(object *obj, PHYSFS_file *f)
{
PHYSFSX_writeU8(f, obj->type);
PHYSFSX_writeU8(f, obj->id);
PHYSFSX_writeU8(f, obj->control_type);
PHYSFSX_writeU8(f, obj->movement_type);
PHYSFSX_writeU8(f, obj->render_type);
PHYSFSX_writeU8(f, obj->flags);
PHYSFS_writeSLE16(f, obj->segnum);
PHYSFSX_writeVector(f, &obj->pos);
PHYSFSX_writeMatrix(f, &obj->orient);
PHYSFSX_writeFix(f, obj->size);
PHYSFSX_writeFix(f, obj->shields);
PHYSFSX_writeVector(f, &obj->last_pos);
PHYSFSX_writeU8(f, obj->contains_type);
PHYSFSX_writeU8(f, obj->contains_id);
PHYSFSX_writeU8(f, obj->contains_count);
switch (obj->movement_type) {
case MT_PHYSICS:
PHYSFSX_writeVector(f, &obj->mtype.phys_info.velocity);
PHYSFSX_writeVector(f, &obj->mtype.phys_info.thrust);
PHYSFSX_writeFix(f, obj->mtype.phys_info.mass);
PHYSFSX_writeFix(f, obj->mtype.phys_info.drag);
PHYSFSX_writeFix(f, obj->mtype.phys_info.brakes);
PHYSFSX_writeVector(f, &obj->mtype.phys_info.rotvel);
PHYSFSX_writeVector(f, &obj->mtype.phys_info.rotthrust);
PHYSFSX_writeFixAng(f, obj->mtype.phys_info.turnroll);
PHYSFS_writeSLE16(f, obj->mtype.phys_info.flags);
break;
case MT_SPINNING:
PHYSFSX_writeVector(f, &obj->mtype.spin_rate);
break;
case MT_NONE:
break;
default:
Int3();
}
switch (obj->control_type) {
case CT_AI: {
int i;
PHYSFSX_writeU8(f, obj->ctype.ai_info.behavior);
for (i = 0; i < MAX_AI_FLAGS; i++)
PHYSFSX_writeU8(f, obj->ctype.ai_info.flags[i]);
PHYSFS_writeSLE16(f, obj->ctype.ai_info.hide_segment);
PHYSFS_writeSLE16(f, obj->ctype.ai_info.hide_index);
PHYSFS_writeSLE16(f, obj->ctype.ai_info.path_length);
PHYSFS_writeSLE16(f, obj->ctype.ai_info.cur_path_index);
PHYSFS_writeSLE16(f, obj->ctype.ai_info.follow_path_start_seg);
PHYSFS_writeSLE16(f, obj->ctype.ai_info.follow_path_end_seg);
break;
}
case CT_EXPLOSION:
PHYSFSX_writeFix(f, obj->ctype.expl_info.spawn_time);
PHYSFSX_writeFix(f, obj->ctype.expl_info.delete_time);
PHYSFS_writeSLE16(f, obj->ctype.expl_info.delete_objnum);
break;
case CT_WEAPON:
//do I really need to write these objects?
PHYSFS_writeSLE16(f, obj->ctype.laser_info.parent_type);
PHYSFS_writeSLE16(f, obj->ctype.laser_info.parent_num);
PHYSFS_writeSLE32(f, obj->ctype.laser_info.parent_signature);
break;
case CT_LIGHT:
PHYSFSX_writeFix(f, obj->ctype.light_info.intensity);
break;
case CT_POWERUP:
PHYSFS_writeSLE32(f, obj->ctype.powerup_info.count);
break;
case CT_NONE:
case CT_FLYING:
case CT_DEBRIS:
break;
case CT_SLEW: //the player is generally saved as slew
break;
case CT_CNTRLCEN:
break; //control center object.
case CT_MORPH:
case CT_REPAIRCEN:
case CT_FLYTHROUGH:
default:
Int3();
}
switch (obj->render_type) {
case RT_NONE:
break;
case RT_MORPH:
case RT_POLYOBJ: {
int i;
PHYSFS_writeSLE32(f, obj->rtype.pobj_info.model_num);
for (i = 0; i < MAX_SUBMODELS; i++)
PHYSFSX_writeAngleVec(f, &obj->rtype.pobj_info.anim_angles[i]);
PHYSFS_writeSLE32(f, obj->rtype.pobj_info.subobj_flags);
PHYSFS_writeSLE32(f, obj->rtype.pobj_info.tmap_override);
break;
}
case RT_WEAPON_VCLIP:
case RT_HOSTAGE:
case RT_POWERUP:
case RT_FIREBALL:
PHYSFS_writeSLE32(f, obj->rtype.vclip_info.vclip_num);
PHYSFSX_writeFix(f, obj->rtype.vclip_info.frametime);
PHYSFSX_writeU8(f, obj->rtype.vclip_info.framenum);
break;
case RT_LASER:
break;
default:
Int3();
}
}
// -----------------------------------------------------------------------------
// Save game
int save_game_data(PHYSFS_file *SaveFile)
{
short game_top_fileinfo_version = Gamesave_current_version >= 5 ? 31 : GAME_VERSION;
int player_offset=0, object_offset=0, walls_offset=0, doors_offset=0, triggers_offset=0, control_offset=0, matcen_offset=0; //, links_offset;
int offset_offset=0, end_offset=0;
int i;
//===================== SAVE FILE INFO ========================
PHYSFS_writeSLE16(SaveFile, 0x6705); // signature
PHYSFS_writeSLE16(SaveFile, game_top_fileinfo_version);
PHYSFS_writeSLE32(SaveFile, sizeof(game_fileinfo));
PHYSFS_write(SaveFile, Current_level_name, 15, 1);
PHYSFS_writeSLE32(SaveFile, Current_level_num);
offset_offset = PHYSFS_tell(SaveFile); // write the offsets later
PHYSFS_writeSLE32(SaveFile, -1);
PHYSFS_writeSLE32(SaveFile, sizeof(player));
#define WRITE_HEADER_ENTRY(t, n) do { PHYSFS_writeSLE32(SaveFile, -1); PHYSFS_writeSLE32(SaveFile, n); PHYSFS_writeSLE32(SaveFile, sizeof(t)); } while(0)
WRITE_HEADER_ENTRY(object, Highest_object_index + 1);
WRITE_HEADER_ENTRY(wall, Num_walls);
WRITE_HEADER_ENTRY(active_door, Num_open_doors);
WRITE_HEADER_ENTRY(trigger, Num_triggers);
WRITE_HEADER_ENTRY(0, 0); // links (removed by Parallax)
WRITE_HEADER_ENTRY(control_center_triggers, 1);
WRITE_HEADER_ENTRY(matcen_info, Num_robot_centers);
// Write the mine name
PHYSFSX_printf(SaveFile, "%s\n", Current_level_name);
PHYSFS_writeSLE16(SaveFile, N_polygon_models);
PHYSFS_write(SaveFile, Pof_names, sizeof(*Pof_names), N_polygon_models);
//==================== SAVE PLAYER INFO ===========================
player_offset = PHYSFS_tell(SaveFile);
PHYSFS_write(SaveFile, &Players[Player_num], sizeof(player), 1); // not endian friendly, but not used either
//==================== SAVE OBJECT INFO ===========================
object_offset = PHYSFS_tell(SaveFile);
//fwrite( &Objects, sizeof(object), game_fileinfo.object_howmany, SaveFile );
for (i = 0; i <= Highest_object_index; i++)
write_object(&Objects[i], SaveFile);
//==================== SAVE WALL INFO =============================
walls_offset = PHYSFS_tell(SaveFile);
for (i = 0; i < Num_walls; i++)
wall_write(&Walls[i], game_top_fileinfo_version, SaveFile);
//==================== SAVE DOOR INFO =============================
#if 0 // FIXME: okay to leave this out?
doors_offset = PHYSFS_tell(SaveFile);
for (i = 0; i < Num_open_doors; i++)
door_write(&ActiveDoors[i], game_top_fileinfo_version, SaveFile);
#endif
//==================== SAVE TRIGGER INFO =============================
triggers_offset = PHYSFS_tell(SaveFile);
for (i = 0; i < Num_triggers; i++)
trigger_write(&Triggers[i], game_top_fileinfo_version, SaveFile);
//================ SAVE CONTROL CENTER TRIGGER INFO ===============
control_offset = PHYSFS_tell(SaveFile);
control_center_triggers_write(&ControlCenterTriggers, SaveFile);
//================ SAVE MATERIALIZATION CENTER TRIGGER INFO ===============
matcen_offset = PHYSFS_tell(SaveFile);
for (i = 0; i < Num_robot_centers; i++)
matcen_info_write(&RobotCenters[i], game_top_fileinfo_version, SaveFile);
//============= REWRITE FILE INFO, TO SAVE OFFSETS ===============
end_offset = PHYSFS_tell(SaveFile);
// Update the offset fields
#define WRITE_OFFSET(o, n) do { PHYSFS_seek(SaveFile, offset_offset); PHYSFS_writeSLE32(SaveFile, o ## _offset); offset_offset += sizeof(int)*n; } while (0)
WRITE_OFFSET(player, 2);
WRITE_OFFSET(object, 3);
WRITE_OFFSET(walls, 3);
WRITE_OFFSET(doors, 3);
WRITE_OFFSET(triggers, 6);
WRITE_OFFSET(control, 3);
WRITE_OFFSET(matcen, 3);
// Go back to end of data
PHYSFS_seek(SaveFile, end_offset);
return 0;
}
void WriteFile::writeSLE16(Sint16 val)
{
if(!PHYSFS_writeSLE16(file, val))
throw Exception("couldn't write: %s", PHYSFS_getLastError());
}