static void CheatDebugFunc(player_t *player, cheat_t * cheat)
{
char lumpName[9];
char textBuffer[256];
subsector_t *sub;
if(!player->plr->mo || !usergame)
return;
P_GetMapLumpName(gameepisode, gamemap, lumpName);
sprintf(textBuffer, "MAP [%s] X:%5d Y:%5d Z:%5d",
lumpName,
player->plr->mo->pos[VX] >> FRACBITS,
player->plr->mo->pos[VY] >> FRACBITS,
player->plr->mo->pos[VZ] >> FRACBITS);
P_SetMessage(player, textBuffer, false);
// Also print some information to the console.
Con_Message(textBuffer);
sub = player->plr->mo->subsector;
Con_Message("\nSubsector %i:\n", P_ToIndex(sub));
Con_Message(" Floorz:%d pic:%d\n", P_GetIntp(sub, DMU_FLOOR_HEIGHT),
P_GetIntp(sub, DMU_FLOOR_MATERIAL));
Con_Message(" Ceilingz:%d pic:%d\n", P_GetIntp(sub, DMU_CEILING_HEIGHT),
P_GetIntp(sub, DMU_CEILING_MATERIAL));
Con_Message("Player height:%g Player radius:%x\n",
player->plr->mo->height, player->plr->mo->radius);
}
void fireflicker_s::write(MapStateWriter *msw) const
{
Writer1 *writer = msw->writer();
Writer_WriteByte(writer, 1); // Write a version byte.
// Note we don't bother to save a byte to tell if the function
// is present as we ALWAYS add one when loading.
Writer_WriteInt32(writer, P_ToIndex(sector));
Writer_WriteInt32(writer, (int) (255.0f * maxLight));
Writer_WriteInt32(writer, (int) (255.0f * minLight));
}
void pillar_s::write(MapStateWriter *msw) const
{
Writer1 *writer = msw->writer();
Writer_WriteByte(writer, 1); // Write a version byte.
// Note we don't bother to save a byte to tell if the function
// is present as we ALWAYS add one when loading.
Writer_WriteInt32(writer, P_ToIndex(sector));
Writer_WriteInt32(writer, FLT2FIX(ceilingSpeed));
Writer_WriteInt32(writer, FLT2FIX(floorSpeed));
Writer_WriteInt32(writer, FLT2FIX(floorDest));
Writer_WriteInt32(writer, FLT2FIX(ceilingDest));
Writer_WriteInt32(writer, direction);
Writer_WriteInt32(writer, crush);
}
void light_s::write(MapStateWriter *msw) const
{
Writer1 *writer = msw->writer();
Writer_WriteByte(writer, 1); // Write a version byte.
// Note we don't bother to save a byte to tell if the function
// is present as we ALWAYS add one when loading.
Writer_WriteByte(writer, (byte)type);
Writer_WriteInt32(writer, P_ToIndex(sector));
Writer_WriteInt32(writer, (int) (255.0f * value1));
Writer_WriteInt32(writer, (int) (255.0f * value2));
Writer_WriteInt32(writer, tics1);
Writer_WriteInt32(writer, tics2);
Writer_WriteInt32(writer, count);
}
void waggle_s::write(MapStateWriter *msw) const
{
Writer1 *writer = msw->writer();
Writer_WriteByte(writer, 1); // Write a version byte.
// Note we don't bother to save a byte to tell if the function
// is present as we ALWAYS add one when loading.
Writer_WriteInt32(writer, P_ToIndex(sector));
Writer_WriteInt32(writer, FLT2FIX(originalHeight));
Writer_WriteInt32(writer, FLT2FIX(accumulator));
Writer_WriteInt32(writer, FLT2FIX(accDelta));
Writer_WriteInt32(writer, FLT2FIX(targetScale));
Writer_WriteInt32(writer, FLT2FIX(scale));
Writer_WriteInt32(writer, FLT2FIX(scaleDelta));
Writer_WriteInt32(writer, ticker);
Writer_WriteInt32(writer, state);
}
void plat_t::write(MapStateWriter *msw) const
{
Writer *writer = msw->writer();
Writer_WriteByte(writer, 1); // Write a version byte.
Writer_WriteByte(writer, (byte) type);
Writer_WriteInt32(writer, P_ToIndex(sector));
Writer_WriteInt32(writer, FLT2FIX(speed));
Writer_WriteInt16(writer, (int)low);
Writer_WriteInt16(writer, (int)high);
Writer_WriteInt32(writer, wait);
Writer_WriteInt32(writer, count);
Writer_WriteByte(writer, (byte) state);
Writer_WriteByte(writer, (byte) oldState);
Writer_WriteByte(writer, (byte) crush);
Writer_WriteInt32(writer, tag);
}
/**
* Reads all versions of archived lines.
* Including the old Ver1.
*/
void SV_ReadLine(Line *li, MapStateReader *msr)
{
xline_t *xli = P_ToXLine(li);
Reader1 *reader = msr->reader();
int mapVersion = msr->mapVersion();
bool xgDataFollows = false;
#if __JHEXEN__
if(mapVersion >= 4)
#else
if(mapVersion >= 2)
#endif
{
xgDataFollows = Reader_ReadByte(reader) == 1;
}
#ifdef __JHEXEN__
DENG2_UNUSED(xgDataFollows);
#endif
// A version byte?
int ver = 1;
#if __JHEXEN__
if(mapVersion >= 3)
#else
if(mapVersion >= 5)
#endif
{
ver = (int) Reader_ReadByte(reader);
}
if(ver >= 4)
{
P_SetIntp(li, DMU_FLAGS, Reader_ReadInt16(reader));
}
int flags = Reader_ReadInt16(reader);
if(xli->flags & ML_TWOSIDED)
{
flags |= ML_TWOSIDED;
}
if(ver < 4)
{
// Translate old line flags.
int ddLineFlags = 0;
if(flags & 0x0001) // old ML_BLOCKING flag
{
ddLineFlags |= DDLF_BLOCKING;
flags &= ~0x0001;
}
if(flags & 0x0008) // old ML_DONTPEGTOP flag
{
ddLineFlags |= DDLF_DONTPEGTOP;
flags &= ~0x0008;
}
if(flags & 0x0010) // old ML_DONTPEGBOTTOM flag
{
ddLineFlags |= DDLF_DONTPEGBOTTOM;
flags &= ~0x0010;
}
P_SetIntp(li, DMU_FLAGS, ddLineFlags);
}
if(ver < 3)
{
if(flags & ML_MAPPED)
{
int lineIDX = P_ToIndex(li);
// Set line as having been seen by all players..
de::zap(xli->mapped);
for(int i = 0; i < MAXPLAYERS; ++i)
{
P_SetLineAutomapVisibility(i, lineIDX, true);
}
}
}
xli->flags = flags;
if(ver >= 3)
{
for(int i = 0; i < MAXPLAYERS; ++i)
{
xli->mapped[i] = Reader_ReadByte(reader);
}
}
#if __JHEXEN__
xli->special = Reader_ReadByte(reader);
xli->arg1 = Reader_ReadByte(reader);
xli->arg2 = Reader_ReadByte(reader);
xli->arg3 = Reader_ReadByte(reader);
xli->arg4 = Reader_ReadByte(reader);
xli->arg5 = Reader_ReadByte(reader);
#else
xli->special = Reader_ReadInt16(reader);
/*xli->tag =*/ Reader_ReadInt16(reader);
#endif
// For each side
for(int i = 0; i < 2; ++i)
{
Side *si = (Side *)P_GetPtrp(li, (i? DMU_BACK:DMU_FRONT));
if(!si) continue;
// Versions latter than 2 store per surface texture offsets.
if(ver >= 2)
{
float offset[2];
offset[VX] = (float) Reader_ReadInt16(reader);
offset[VY] = (float) Reader_ReadInt16(reader);
P_SetFloatpv(si, DMU_TOP_MATERIAL_OFFSET_XY, offset);
offset[VX] = (float) Reader_ReadInt16(reader);
offset[VY] = (float) Reader_ReadInt16(reader);
P_SetFloatpv(si, DMU_MIDDLE_MATERIAL_OFFSET_XY, offset);
offset[VX] = (float) Reader_ReadInt16(reader);
offset[VY] = (float) Reader_ReadInt16(reader);
P_SetFloatpv(si, DMU_BOTTOM_MATERIAL_OFFSET_XY, offset);
}
else
{
float offset[2];
offset[VX] = (float) Reader_ReadInt16(reader);
offset[VY] = (float) Reader_ReadInt16(reader);
P_SetFloatpv(si, DMU_TOP_MATERIAL_OFFSET_XY, offset);
P_SetFloatpv(si, DMU_MIDDLE_MATERIAL_OFFSET_XY, offset);
P_SetFloatpv(si, DMU_BOTTOM_MATERIAL_OFFSET_XY, offset);
}
if(ver >= 3)
{
P_SetIntp(si, DMU_TOP_FLAGS, Reader_ReadInt16(reader));
P_SetIntp(si, DMU_MIDDLE_FLAGS, Reader_ReadInt16(reader));
P_SetIntp(si, DMU_BOTTOM_FLAGS, Reader_ReadInt16(reader));
}
world_Material *topMaterial = 0, *bottomMaterial = 0, *middleMaterial = 0;
#if !__JHEXEN__
if(mapVersion >= 4)
#endif
{
topMaterial = msr->material(Reader_ReadInt16(reader), 1);
bottomMaterial = msr->material(Reader_ReadInt16(reader), 1);
middleMaterial = msr->material(Reader_ReadInt16(reader), 1);
}
P_SetPtrp(si, DMU_TOP_MATERIAL, topMaterial);
P_SetPtrp(si, DMU_BOTTOM_MATERIAL, bottomMaterial);
P_SetPtrp(si, DMU_MIDDLE_MATERIAL, middleMaterial);
// Ver2 includes surface colours
if(ver >= 2)
{
float rgba[4];
int flags;
for(int k = 0; k < 3; ++k)
rgba[k] = (float) Reader_ReadByte(reader) / 255.f;
rgba[3] = 1;
P_SetFloatpv(si, DMU_TOP_COLOR, rgba);
for(int k = 0; k < 3; ++k)
rgba[k] = (float) Reader_ReadByte(reader) / 255.f;
rgba[3] = 1;
P_SetFloatpv(si, DMU_BOTTOM_COLOR, rgba);
for(int k = 0; k < 4; ++k)
rgba[k] = (float) Reader_ReadByte(reader) / 255.f;
P_SetFloatpv(si, DMU_MIDDLE_COLOR, rgba);
P_SetIntp(si, DMU_MIDDLE_BLENDMODE, Reader_ReadInt32(reader));
flags = Reader_ReadInt16(reader);
if(mapVersion < 12)
{
if(P_GetIntp(si, DMU_FLAGS) & SDF_SUPPRESS_BACK_SECTOR)
flags |= SDF_SUPPRESS_BACK_SECTOR;
}
P_SetIntp(si, DMU_FLAGS, flags);
}
}
#if !__JHEXEN__
if(xgDataFollows)
{
SV_ReadXGLine(li, msr);
}
#endif
}
