static void drawEnteringTitle(void)
{
int x = SCREENWIDTH/2, y = WI_TITLEY;
char* mapName = NULL;
uint mapNum;
ddmapinfo_t minfo;
patchid_t patchId;
patchinfo_t info;
AutoStr* mapPath;
Uri* mapUri;
/// @kludge We need to properly externalize the map progression.
if((gameModeBits & (GM_DOOM2|GM_DOOM2_PLUT|GM_DOOM2_TNT)) && wbs->nextMap == 30)
{
return;
}
/// kludge end.
// See if there is a map name.
mapUri = G_ComposeMapUri(wbs->episode, wbs->nextMap);
mapPath = Uri_Compose(mapUri);
if(Def_Get(DD_DEF_MAP_INFO, Str_Text(mapPath), &minfo) && minfo.name)
{
if(Def_Get(DD_DEF_TEXT, minfo.name, &mapName) == -1)
mapName = minfo.name;
}
Uri_Delete(mapUri);
// Skip the E#M# or Map #.
if(mapName)
{
char* ptr = strchr(mapName, ':');
if(ptr)
{
mapName = M_SkipWhite(ptr + 1);
}
}
DGL_Enable(DGL_TEXTURE_2D);
DGL_Color4f(1, 1, 1, 1);
FR_SetFont(FID(GF_FONTB));
FR_LoadDefaultAttrib();
FR_SetColorAndAlpha(defFontRGB2[CR], defFontRGB2[CG], defFontRGB2[CB], 1);
// Draw "Entering"
WI_DrawPatchXY3(pEntering, Hu_ChoosePatchReplacement(cfg.inludePatchReplaceMode, pEntering), x, y, ALIGN_TOP, 0, DTF_NO_TYPEIN);
if(R_GetPatchInfo(pMapNames[wbs->nextMap], &info))
y += (5 * info.geometry.size.height) / 4;
// Draw map.
mapNum = (wbs->episode * 9) + wbs->nextMap;
patchId = (mapNum < pMapNamesSize? pMapNames[mapNum] : 0);
FR_SetColorAndAlpha(defFontRGB[CR], defFontRGB[CG], defFontRGB[CB], 1);
WI_DrawPatchXY3(patchId, Hu_ChoosePatchReplacement2(cfg.inludePatchReplaceMode, patchId, mapName), x, y, ALIGN_TOP, 0, DTF_NO_TYPEIN);
DGL_Disable(DGL_TEXTURE_2D);
}
static int SV_ReadFloor(floor_t *floor)
{
/* Original Heretic format:
typedef struct {
thinker_t thinker; // was 12 bytes
floortype_e type; // was 32bit int
boolean crush;
Sector *sector;
int direction;
int newspecial;
short texture;
fixed_t floordestheight;
fixed_t speed;
} v13_floormove_t;
*/
Uri *newTextureUrn;
// Padding at the start (an old thinker_t struct)
Reader_Read(svReader, NULL, SIZEOF_V13_THINKER_T);
// Start of used data members.
floor->type = Reader_ReadInt32(svReader);
floor->crush = Reader_ReadInt32(svReader);
// A 32bit pointer to sector, serialized.
floor->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));
if(!floor->sector)
Con_Error("tc_floor: bad sector number\n");
floor->state = (int) Reader_ReadInt32(svReader);
floor->newSpecial = Reader_ReadInt32(svReader);
newTextureUrn = readTextureUrn(svReader, "Flats");
floor->material = DD_MaterialForTextureUri(newTextureUrn);
Uri_Delete(newTextureUrn);
floor->floorDestHeight = FIX2FLT(Reader_ReadInt32(svReader));
floor->speed = FIX2FLT(Reader_ReadInt32(svReader));
floor->thinker.function = T_MoveFloor;
P_ToXSector(floor->sector)->specialData = T_MoveFloor;
return true; // Add this thinker.
}
static void P_v13_UnArchiveWorld(void)
{
int i, j;
fixed_t offx, offy;
Sector* sec;
xsector_t* xsec;
Line* line;
xline_t* xline;
// Do sectors.
for(i = 0; i < numsectors; ++i)
{
Uri *floorTextureUrn, *ceilingTextureUrn;
sec = P_ToPtr(DMU_SECTOR, i);
xsec = P_ToXSector(sec);
P_SetDoublep(sec, DMU_FLOOR_HEIGHT, (coord_t)Reader_ReadInt16(svReader));
P_SetDoublep(sec, DMU_CEILING_HEIGHT, (coord_t)Reader_ReadInt16(svReader));
floorTextureUrn = readTextureUrn(svReader, "Flats");
P_SetPtrp(sec, DMU_FLOOR_MATERIAL, DD_MaterialForTextureUri(floorTextureUrn));
Uri_Delete(floorTextureUrn);
ceilingTextureUrn = readTextureUrn(svReader, "Flats");
P_SetPtrp(sec, DMU_CEILING_MATERIAL, DD_MaterialForTextureUri(ceilingTextureUrn));
Uri_Delete(ceilingTextureUrn);
P_SetFloatp(sec, DMU_LIGHT_LEVEL, (float) (Reader_ReadInt16(svReader)) / 255.0f);
xsec->special = Reader_ReadInt16(svReader); // needed?
/*xsec->tag = **/Reader_ReadInt16(svReader); // needed?
xsec->specialData = 0;
xsec->soundTarget = 0;
}
// Do lines.
for(i = 0; i < numlines; ++i)
{
line = P_ToPtr(DMU_LINE, i);
xline = P_ToXLine(line);
xline->flags = Reader_ReadInt16(svReader);
xline->special = Reader_ReadInt16(svReader);
/*xline->tag =*/Reader_ReadInt16(svReader);
for(j = 0; j < 2; ++j)
{
Uri *topTextureUrn, *bottomTextureUrn, *middleTextureUrn;
Side* sdef = P_GetPtrp(line, j == 0? DMU_FRONT : DMU_BACK);
if(!sdef) continue;
offx = Reader_ReadInt16(svReader) << FRACBITS;
offy = Reader_ReadInt16(svReader) << FRACBITS;
P_SetFixedp(sdef, DMU_TOP_MATERIAL_OFFSET_X, offx);
P_SetFixedp(sdef, DMU_TOP_MATERIAL_OFFSET_Y, offy);
P_SetFixedp(sdef, DMU_MIDDLE_MATERIAL_OFFSET_X, offx);
P_SetFixedp(sdef, DMU_MIDDLE_MATERIAL_OFFSET_Y, offy);
P_SetFixedp(sdef, DMU_BOTTOM_MATERIAL_OFFSET_X, offx);
P_SetFixedp(sdef, DMU_BOTTOM_MATERIAL_OFFSET_Y, offy);
topTextureUrn = readTextureUrn(svReader, "Textures");
P_SetPtrp(sdef, DMU_TOP_MATERIAL, DD_MaterialForTextureUri(topTextureUrn));
Uri_Delete(topTextureUrn);
bottomTextureUrn = readTextureUrn(svReader, "Textures");
P_SetPtrp(sdef, DMU_BOTTOM_MATERIAL, DD_MaterialForTextureUri(bottomTextureUrn));
Uri_Delete(bottomTextureUrn);
middleTextureUrn = readTextureUrn(svReader, "Textures");
P_SetPtrp(sdef, DMU_MIDDLE_MATERIAL, DD_MaterialForTextureUri(middleTextureUrn));
Uri_Delete(middleTextureUrn);
}
}
}
/**
* Post Game Initialization routine.
* All game-specific actions that should take place at this time go here.
*/
void D_PostInit(void)
{
AutoStr* path;
Uri* uri;
int p;
/// @todo Kludge: Border background is different in DOOM2.
/// @todo Do this properly!
if(gameModeBits & GM_ANY_DOOM2)
borderGraphics[0] = "Flats:GRNROCK";
else
borderGraphics[0] = "Flats:FLOOR7_2";
// Common post init routine
G_CommonPostInit();
// Initialize ammo info.
P_InitAmmoInfo();
// Initialize weapon info.
P_InitWeaponInfo();
// Game parameters.
monsterInfight = GetDefInt("AI|Infight", 0);
// Get skill / episode / map from parms.
gameSkill = startSkill = SM_NOITEMS;
startEpisode = 0;
startMap = 0;
autoStart = false;
// Command line options.
noMonstersParm = CommandLine_Check("-nomonsters")? true : false;
respawnParm = CommandLine_Check("-respawn")? true : false;
fastParm = CommandLine_Check("-fast")? true : false;
devParm = CommandLine_Check("-devparm")? true : false;
if(CommandLine_Check("-altdeath"))
cfg.netDeathmatch = 2;
else if(CommandLine_Check("-deathmatch"))
cfg.netDeathmatch = 1;
p = CommandLine_Check("-timer");
if(p && p < myargc - 1 && deathmatch)
{
int time = atoi(CommandLine_At(p + 1));
Con_Message("Maps will end after %d %s", time, time == 1? "minute" : "minutes");
}
// Turbo option.
p = CommandLine_Check("-turbo");
turboMul = 1.0f;
if(p)
{
int scale = 200;
turboParm = true;
if(p < myargc - 1)
scale = atoi(CommandLine_At(p + 1));
if(scale < 10)
scale = 10;
if(scale > 400)
scale = 400;
Con_Message("turbo scale: %i%%", scale);
turboMul = scale / 100.f;
}
// Load a saved game?
p = CommandLine_Check("-loadgame");
if(p && p < myargc - 1)
{
const int saveSlot = SV_ParseSlotIdentifier(CommandLine_At(p + 1));
if(SV_IsUserWritableSlot(saveSlot) && G_LoadGame(saveSlot))
{
// No further initialization is to be done.
return;
}
}
p = CommandLine_Check("-skill");
if(p && p < myargc - 1)
{
startSkill = CommandLine_At(p + 1)[0] - '1';
autoStart = true;
}
p = CommandLine_Check("-episode");
if(p && p < myargc - 1)
{
startEpisode = CommandLine_At(p + 1)[0] - '1';
startMap = 0;
autoStart = true;
}
p = CommandLine_Check("-warp");
if(p && p < myargc - 1)
{
if(gameModeBits & (GM_ANY_DOOM2|GM_DOOM_CHEX))
{
startMap = atoi(CommandLine_At(p + 1)) - 1;
autoStart = true;
}
else if(p < myargc - 2)
{
startEpisode = CommandLine_At(p + 1)[0] - '1';
startMap = CommandLine_At(p + 2)[0] - '1';
autoStart = true;
}
}
// Are we autostarting?
if(autoStart)
{
if(gameModeBits & (GM_ANY_DOOM2|GM_DOOM_CHEX))
Con_Message("Warp to Map %d, Skill %d", startMap+1, startSkill + 1);
else
Con_Message("Warp to Episode %d, Map %d, Skill %d", startEpisode+1, startMap+1, startSkill + 1);
}
// Validate episode and map.
uri = G_ComposeMapUri((gameModeBits & (GM_DOOM|GM_DOOM_SHAREWARE|GM_DOOM_ULTIMATE))? startEpisode : 0, startMap);
path = Uri_Compose(uri);
if((autoStart || IS_NETGAME) && !P_MapExists(Str_Text(path)))
{
startEpisode = 0;
startMap = 0;
}
Uri_Delete(uri);
if(autoStart || IS_NETGAME)
{
G_DeferredNewGame(startSkill, startEpisode, startMap, 0/*default*/);
}
else
{
G_StartTitle(); // Start up intro loop.
}
}
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
}
static void parseParamaterBlock(char** strPtr, drawtextstate_t* state, int* numBreaks)
{
(*strPtr)++;
while(*(*strPtr) && *(*strPtr) != '}')
{
(*strPtr) = M_SkipWhite((*strPtr));
// What do we have here?
if(!strnicmp((*strPtr), "flash", 5))
{
(*strPtr) += 5;
state->typeIn = true;
}
else if(!strnicmp((*strPtr), "noflash", 7))
{
(*strPtr) += 7;
state->typeIn = false;
}
else if(!strnicmp((*strPtr), "case", 4))
{
(*strPtr) += 4;
state->caseScale = true;
}
else if(!strnicmp((*strPtr), "nocase", 6))
{
(*strPtr) += 6;
state->caseScale = false;
}
else if(!strnicmp((*strPtr), "ups", 3))
{
(*strPtr) += 3;
state->caseMod[1].scale = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "upo", 3))
{
(*strPtr) += 3;
state->caseMod[1].offset = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "los", 3))
{
(*strPtr) += 3;
state->caseMod[0].scale = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "loo", 3))
{
(*strPtr) += 3;
state->caseMod[0].offset = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "break", 5))
{
(*strPtr) += 5;
++(*numBreaks);
}
else if(!strnicmp((*strPtr), "r", 1))
{
(*strPtr)++;
state->rgba[CR] = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "g", 1))
{
(*strPtr)++;
state->rgba[CG] = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "b", 1))
{
(*strPtr)++;
state->rgba[CB] = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "a", 1))
{
(*strPtr)++;
state->rgba[CA] = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "x", 1))
{
(*strPtr)++;
state->offX = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "y", 1))
{
(*strPtr)++;
state->offY = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "scalex", 6))
{
(*strPtr) += 6;
state->scaleX = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "scaley", 6))
{
(*strPtr) += 6;
state->scaleY = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "scale", 5))
{
(*strPtr) += 5;
state->scaleX = state->scaleY = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "angle", 5))
{
(*strPtr) += 5;
state->angle = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "glitter", 7))
{
(*strPtr) += 7;
state->glitterStrength = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "shadow", 6))
{
(*strPtr) += 6;
state->shadowStrength = parseFloat(&(*strPtr));
}
else if(!strnicmp((*strPtr), "tracking", 8))
{
(*strPtr) += 8;
state->tracking = parseFloat(&(*strPtr));
}
else
{
// Perhaps a font name?
fontid_t fontId;
if(!strnicmp((*strPtr), "font", 4))
{
char buf[80];
(*strPtr) += 4;
if(parseString(&(*strPtr), buf, 80))
{
Uri* uri = Uri_NewWithPath2(buf, RC_NULL);
fontId = Fonts_ResolveUri2(uri, true/*quiet please*/);
Uri_Delete(uri);
if(fontId != NOFONTID)
{
state->fontNum = fontId;
continue;
}
}
Con_Message("Warning:parseParamaterBlock: Unknown font '%s'.", (*strPtr));
continue;
}
// Unknown, skip it.
if(*(*strPtr) != '}')
(*strPtr)++;
}
}
// Skip over the closing brace.
if(*(*strPtr))
(*strPtr)++;
}
