void SV_LoadGameClient(uint /*sessionId*/)
{
throw de::Error("SV_LoadGameClient", "Not currently implemented");
#if 0
#if !__JHEXEN__ // unsupported in libhexen
player_t *cpl = players + CONSOLEPLAYER;
mobj_t *mo = cpl->plr->mo;
if(!IS_CLIENT || !mo)
return;
de::game::GameStateFolder *session = new de::game::GameStateFolder(saveNameForClientSessionId(sessionId));
de::game::GameStateMetadata *metadata = new de::game::GameStateMetadata;
//G_ReadLegacySessionMetadata(metadata, reader);
metadata->set("sessionId", sessionId);
session->replaceMetadata(metadata);
de::Path path = de::String("/savegame") / "client" / session->path();
if(!SV_OpenFileForRead(path))
{
delete session;
App_Log(DE2_RES_WARNING, "SV_LoadGameClient: Failed opening \"%s\" for reading",
path.toString().toLatin1().constData());
return;
}
if((*metadata)["magic"].value().asNumber() != MY_CLIENT_SAVE_MAGIC)
{
SV_CloseFile();
delete session;
App_Log(DE2_RES_ERROR, "Client save file format not recognized");
return;
}
Reader1 *reader = SV_NewReader();
int const saveVersion = (*metadata)["version"].value().asNumber();
Uri *mapUri = Uri_NewWithPath2((*metadata)["mapUri"].value().asText().toUtf8().constData(), RC_NULL);
GameRules *rules = 0;
if(metadata->hasSubrecord("gameRules"))
{
rules = GameRules::fromRecord(metadata->subrecord("gameRules"));
}
// Do we need to change the map?
if(gfw_Session()->mapUri() != *reinterpret_cast<de::Uri *>(mapUri))
{
gfw_Session()->begin(*mapUri, 0/*default*/, *rules);
}
else if(rules)
{
gfw_Session()->rules() = *rules;
}
delete rules; rules = 0;
Uri_Delete(mapUri); mapUri = 0;
mapTime = (*metadata)["mapTime"].value().asNumber();
P_MobjUnlink(mo);
mo->origin[VX] = FIX2FLT(Reader_ReadInt32(reader));
mo->origin[VY] = FIX2FLT(Reader_ReadInt32(reader));
mo->origin[VZ] = FIX2FLT(Reader_ReadInt32(reader));
P_MobjLink(mo);
mo->floorZ = FIX2FLT(Reader_ReadInt32(reader));
mo->ceilingZ = FIX2FLT(Reader_ReadInt32(reader));
mo->angle = Reader_ReadInt32(reader); /* $unifiedangles */
cpl->plr->lookDir = Reader_ReadFloat(reader); /* $unifiedangles */
#if __JHEXEN__
if(saveVersion >= 4)
#else
if(saveVersion >= 5)
#endif
{
SV_AssertSegment(ASEG_PLAYER_HEADER);
}
playerheader_t plrHdr;
plrHdr.read(reader, saveVersion);
cpl->read(reader, plrHdr);
MapStateReader(*session).read(Str_Text(Uri_Resolved(mapUri)));
SV_CloseFile();
Reader_Delete(reader);
delete session;
#else
DENG2_UNUSED(sessionId);
#endif
#endif
}
void Cl_Frame2Received(int packetType)
{
// The first thing in the frame is the gameTime.
frameGameTime = Reader_ReadFloat(msgReader);
// All frames that arrive before the first frame are ignored.
// They are most likely from the wrong map.
if (packetType == PSV_FIRST_FRAME2)
{
gotFirstFrame = true;
}
else if (!gotFirstFrame)
{
// Just ignore. If this was a legitimate frame, the server will
// send it again when it notices no ack is coming.
return;
}
// Read and process the message.
while (!Reader_AtEnd(msgReader))
{
byte const deltaType = Reader_ReadByte(msgReader);
switch (deltaType)
{
case DT_CREATE_MOBJ:
// The mobj will be created/shown.
ClMobj_ReadDelta();
break;
case DT_MOBJ:
// The mobj will be hidden if it's not yet Created.
ClMobj_ReadDelta();
break;
case DT_NULL_MOBJ:
// The mobj will be removed.
ClMobj_ReadNullDelta();
break;
case DT_PLAYER:
ClPlayer_ReadDelta();
break;
case DT_SECTOR:
Cl_ReadSectorDelta(deltaType);
break;
//case DT_SIDE_R6: // Old format.
case DT_SIDE:
Cl_ReadSideDelta(deltaType);
break;
case DT_POLY:
Cl_ReadPolyDelta();
break;
case DT_SOUND:
case DT_MOBJ_SOUND:
case DT_SECTOR_SOUND:
case DT_SIDE_SOUND:
case DT_POLY_SOUND:
Cl_ReadSoundDelta((deltatype_t) deltaType);
break;
default:
LOG_NET_ERROR("Received unknown delta type %i (message size: %i bytes)")
<< deltaType << netBuffer.length;
return;
}
}
if (!gotFrame)
{
LOGDEV_NET_NOTE("First frame received");
}
// We have now received a frame.
gotFrame = true;
}
void SV_ReadSector(Sector *sec, MapStateReader *msr)
{
xsector_t *xsec = P_ToXSector(sec);
Reader1 *reader = msr->reader();
int mapVersion = msr->mapVersion();
// A type byte?
int type = 0;
#if __JHEXEN__
if(mapVersion < 4)
type = sc_ploff;
else
#else
if(mapVersion <= 1)
type = sc_normal;
else
#endif
type = Reader_ReadByte(reader);
// A version byte?
int ver = 1;
#if __JHEXEN__
if(mapVersion > 2)
#else
if(mapVersion > 4)
#endif
{
ver = Reader_ReadByte(reader);
}
int fh = Reader_ReadInt16(reader);
int ch = Reader_ReadInt16(reader);
P_SetIntp(sec, DMU_FLOOR_HEIGHT, fh);
P_SetIntp(sec, DMU_CEILING_HEIGHT, ch);
#if __JHEXEN__
// Update the "target heights" of the planes.
P_SetIntp(sec, DMU_FLOOR_TARGET_HEIGHT, fh);
P_SetIntp(sec, DMU_CEILING_TARGET_HEIGHT, ch);
// The move speed is not saved; can cause minor problems.
P_SetIntp(sec, DMU_FLOOR_SPEED, 0);
P_SetIntp(sec, DMU_CEILING_SPEED, 0);
#endif
world_Material *floorMaterial = 0, *ceilingMaterial = 0;
#if !__JHEXEN__
if(mapVersion == 1)
{
// The flat numbers are absolute lump indices.
de::Uri uri("Flats:", RC_NULL);
uri.setPath(CentralLumpIndex()[Reader_ReadInt16(reader)].name().fileNameWithoutExtension());
floorMaterial = (world_Material *)P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(reinterpret_cast<uri_s *>(&uri)));
uri.setPath(CentralLumpIndex()[Reader_ReadInt16(reader)].name().fileNameWithoutExtension());
ceilingMaterial = (world_Material *)P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(reinterpret_cast<uri_s *>(&uri)));
}
else if(mapVersion >= 4)
#endif
{
// The flat numbers are actually archive numbers.
floorMaterial = msr->material(Reader_ReadInt16(reader), 0);
ceilingMaterial = msr->material(Reader_ReadInt16(reader), 0);
}
P_SetPtrp(sec, DMU_FLOOR_MATERIAL, floorMaterial);
P_SetPtrp(sec, DMU_CEILING_MATERIAL, ceilingMaterial);
if(ver >= 3)
{
P_SetIntp(sec, DMU_FLOOR_FLAGS, Reader_ReadInt16(reader));
P_SetIntp(sec, DMU_CEILING_FLAGS, Reader_ReadInt16(reader));
}
byte lightlevel;
#if __JHEXEN__
lightlevel = (byte) Reader_ReadInt16(reader);
#else
// In Ver1 the light level is a short
if(mapVersion == 1)
{
lightlevel = (byte) Reader_ReadInt16(reader);
}
else
{
lightlevel = Reader_ReadByte(reader);
}
#endif
P_SetFloatp(sec, DMU_LIGHT_LEVEL, (float) lightlevel / 255.f);
#if !__JHEXEN__
if(mapVersion > 1)
#endif
{
byte rgb[3];
Reader_Read(reader, rgb, 3);
for(int i = 0; i < 3; ++i)
P_SetFloatp(sec, DMU_COLOR_RED + i, rgb[i] / 255.f);
}
// Ver 2 includes surface colours
if(ver >= 2)
{
byte rgb[3];
Reader_Read(reader, rgb, 3);
for(int i = 0; i < 3; ++i)
P_SetFloatp(sec, DMU_FLOOR_COLOR_RED + i, rgb[i] / 255.f);
Reader_Read(reader, rgb, 3);
for(int i = 0; i < 3; ++i)
P_SetFloatp(sec, DMU_CEILING_COLOR_RED + i, rgb[i] / 255.f);
}
xsec->special = Reader_ReadInt16(reader);
/*xsec->tag =*/ Reader_ReadInt16(reader);
#if __JHEXEN__
xsec->seqType = seqtype_t(Reader_ReadInt16(reader));
#endif
if(type == sc_ploff
#if !__JHEXEN__
|| type == sc_xg1
#endif
)
{
P_SetFloatp(sec, DMU_FLOOR_MATERIAL_OFFSET_X, Reader_ReadFloat(reader));
P_SetFloatp(sec, DMU_FLOOR_MATERIAL_OFFSET_Y, Reader_ReadFloat(reader));
P_SetFloatp(sec, DMU_CEILING_MATERIAL_OFFSET_X, Reader_ReadFloat(reader));
P_SetFloatp(sec, DMU_CEILING_MATERIAL_OFFSET_Y, Reader_ReadFloat(reader));
}
#if !__JHEXEN__
if(type == sc_xg1)
{
SV_ReadXGSector(sec, reader, mapVersion);
}
#endif
#if !__JHEXEN__
if(mapVersion <= 1)
#endif
{
xsec->specialData = 0;
}
// We'll restore the sound targets latter on
xsec->soundTarget = 0;
}
