thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
RingRacers/src/p_setup.cpp
Eidolon 1a8467fdaf Merge public master
2025-02-12 19:02:38 -06:00

9665 lines
287 KiB
C++
Raw Blame History

// DR. ROBOTNIK'S RING RACERS
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Kart Krew.
// Copyright (C) 2020 by Sonic Team Junior.
// Copyright (C) 2000 by DooM Legacy Team.
// Copyright (C) 1996 by id Software, Inc.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file p_setup.cpp
/// \brief Do all the WAD I/O, get map description, set up initial state and misc. LUTs
#include <algorithm>
#include <string>
#include <vector>
#include <fmt/format.h>
#include "cxxutil.hpp"
#include "doomdef.h"
#include "d_main.h"
#include "byteptr.h"
#include "g_game.h"
#include "p_local.h"
#include "p_setup.h"
#include "p_spec.h"
#include "p_saveg.h"
#include "i_time.h"
#include "i_video.h" // for I_FinishUpdate()..
#include "r_sky.h"
#include "i_system.h"
#include "r_data.h"
#include "r_things.h" // for R_AddSpriteDefs
#include "r_textures.h"
#include "r_patch.h"
#include "r_picformats.h"
#include "r_sky.h"
#include "r_draw.h"
#include "r_fps.h" // R_ResetViewInterpolation in level load
#include "s_sound.h"
#include "i_sound.h" // I_FreeSfx
#include "st_stuff.h"
#include "w_wad.h"
#include "z_zone.h"
#include "r_splats.h"
#include "hu_stuff.h"
#include "console.h"
#include "m_misc.h"
#include "m_fixed.h"
#include "m_random.h"
#include "dehacked.h" // for map headers
#include "r_main.h"
#include "m_cond.h" // for emblems
#include "m_argv.h"
#include "p_polyobj.h"
#include "v_video.h"
#include "filesrch.h" // refreshdirmenu
#include "lua_hud.h" // level title
#include "f_finale.h" // wipes
#include "md5.h" // map MD5
// for MapLoad hook
#include "lua_script.h"
#include "lua_hook.h"
#ifdef _WIN32
#include <malloc.h>
#include <math.h>
#endif
#ifdef HWRENDER
#include "hardware/hw_main.h"
#include "hardware/hw_light.h"
#include "hardware/hw_model.h"
#endif
#include "p_slopes.h"
#include "fastcmp.h" // textmap parsing
#include "taglist.h"
// SRB2Kart
#include "k_kart.h"
#include "k_race.h"
#include "k_battle.h" // K_BattleInit
#include "k_pwrlv.h"
#include "k_waypoint.h"
#include "k_bot.h"
#include "k_grandprix.h"
#include "k_boss.h"
#include "k_terrain.h" // TRF_TRIPWIRE
#include "k_brightmap.h"
#include "k_director.h" // K_InitDirector
#include "k_specialstage.h"
#include "acs/interface.h"
#include "doomstat.h" // MAXMUSNAMES
#include "k_podium.h"
#include "k_rank.h"
#include "k_mapuser.h"
#include "music.h"
#include "k_dialogue.h"
#include "k_hud.h" // K_ClearPersistentMessages
#include "k_endcam.h"
#include "k_credits.h"
#include "k_objects.h"
#include "p_deepcopy.h"
// Replay names have time
#if !defined (UNDER_CE)
#include <time.h>
#endif
#include <tracy/tracy/TracyC.h>
extern "C" consvar_t cv_continuousmusic;
boolean g_reloadinggamestate = false;
//
// Map MD5, calculated on level load.
// Sent to clients in PT_SERVERINFO.
//
unsigned char mapmd5[16];
//
// MAP related Lookup tables.
// Store VERTEXES, LINEDEFS, SIDEDEFS, etc.
//
boolean udmf;
INT32 udmf_version;
size_t numvertexes, numsegs, numsectors, numsubsectors, numnodes, numlines, numsides, nummapthings;
size_t num_orig_vertexes;
vertex_t *vertexes;
seg_t *segs;
sector_t *sectors;
subsector_t *subsectors;
node_t *nodes;
line_t *lines;
side_t *sides;
mapthing_t *mapthings;
sector_t *spawnsectors;
line_t *spawnlines;
side_t *spawnsides;
INT32 numcheatchecks;
UINT16 bossdisabled;
boolean stoppedclock;
boolean levelloading;
UINT8 levelfadecol;
tic_t oldbest;
// I cannot fucking believe this is needed, but gamedata is updated at exactly
// the wrong time to check your record in the tally screen.
virtres_t *curmapvirt;
// BLOCKMAP
// Created from axis aligned bounding box
// of the map, a rectangular array of
// blocks of size ...
// Used to speed up collision detection
// by spatial subdivision in 2D.
//
// Blockmap size.
INT32 bmapwidth, bmapheight; // size in mapblocks
INT32 *blockmap; // INT32 for large maps
// offsets in blockmap are from here
INT32 *blockmaplump; // Big blockmap
// origin of block map
fixed_t bmaporgx, bmaporgy;
// for thing chains
mobj_t **blocklinks;
precipmobj_t **precipblocklinks;
// REJECT
// For fast sight rejection.
// Speeds up enemy AI by skipping detailed LineOf Sight calculation.
// Without special effect, this could be used as a PVS lookup as well.
//
UINT8 *rejectmatrix;
// Maintain single and multi player starting spots.
INT32 numdmstarts, numcoopstarts, numteamstarts[TEAM__MAX];
INT32 numfaultstarts;
mapthing_t *deathmatchstarts[MAX_DM_STARTS];
mapthing_t *playerstarts[MAXPLAYERS];
mapthing_t *teamstarts[TEAM__MAX][MAXPLAYERS];
mapthing_t *faultstart;
// Global state for PartialAddWadFile/MultiSetupWadFiles
// Might be replacable with parameters, but non-trivial when the functions are called on separate tics
static SINT8 partadd_stage = -1;
static boolean partadd_important = false;
UINT16 partadd_earliestfile = UINT16_MAX;
// Maintain *ZOOM TUBE* waypoints
// Renamed because SRB2Kart owns real waypoints.
mobj_t *tubewaypoints[NUMTUBEWAYPOINTSEQUENCES][TUBEWAYPOINTSEQUENCESIZE];
UINT16 numtubewaypoints[NUMTUBEWAYPOINTSEQUENCES];
void P_AddTubeWaypoint(UINT8 sequence, UINT8 id, mobj_t *waypoint)
{
P_SetTarget(&tubewaypoints[sequence][id], waypoint);
if (id >= numtubewaypoints[sequence])
numtubewaypoints[sequence] = id + 1;
}
static void P_ResetTubeWaypoints(void)
{
UINT16 sequence, id;
for (sequence = 0; sequence < NUMTUBEWAYPOINTSEQUENCES; sequence++)
{
for (id = 0; id < numtubewaypoints[sequence]; id++)
tubewaypoints[sequence][id] = NULL;
numtubewaypoints[sequence] = 0;
}
}
mobj_t *P_GetFirstTubeWaypoint(UINT8 sequence)
{
return tubewaypoints[sequence][0];
}
mobj_t *P_GetLastTubeWaypoint(UINT8 sequence)
{
return tubewaypoints[sequence][numtubewaypoints[sequence] - 1];
}
mobj_t *P_GetPreviousTubeWaypoint(mobj_t *current, boolean wrap)
{
UINT8 sequence = current->threshold;
UINT8 id = current->health;
if (id == 0)
{
if (!wrap)
return NULL;
id = numtubewaypoints[sequence] - 1;
}
else
id--;
return tubewaypoints[sequence][id];
}
mobj_t *P_GetNextTubeWaypoint(mobj_t *current, boolean wrap)
{
UINT8 sequence = current->threshold;
UINT8 id = current->health;
if (id == numtubewaypoints[sequence] - 1)
{
if (!wrap)
return NULL;
id = 0;
}
else
id++;
return tubewaypoints[sequence][id];
}
mobj_t *P_GetClosestTubeWaypoint(UINT8 sequence, mobj_t *mo)
{
UINT8 wp;
mobj_t *mo2, *result = NULL;
fixed_t bestdist = 0;
fixed_t curdist;
for (wp = 0; wp < numtubewaypoints[sequence]; wp++)
{
mo2 = tubewaypoints[sequence][wp];
if (!mo2)
continue;
curdist = P_AproxDistance(P_AproxDistance(mo->x - mo2->x, mo->y - mo2->y), mo->z - mo2->z);
if (result && curdist > bestdist)
continue;
result = mo2;
bestdist = curdist;
}
return result;
}
// Return true if all waypoints are in the same location
boolean P_IsDegeneratedTubeWaypointSequence(UINT8 sequence)
{
mobj_t *first, *waypoint;
UINT8 wp;
if (numtubewaypoints[sequence] <= 1)
return true;
first = tubewaypoints[sequence][0];
for (wp = 1; wp < numtubewaypoints[sequence]; wp++)
{
waypoint = tubewaypoints[sequence][wp];
if (!waypoint)
continue;
if (waypoint->x != first->x)
return false;
if (waypoint->y != first->y)
return false;
if (waypoint->z != first->z)
return false;
}
return true;
}
/** Logs an error about a map being corrupt, then terminate.
* This allows reporting highly technical errors for usefulness, without
* confusing a novice map designer who simply needs to run ZenNode.
*
* If logging is disabled in this compile, or the log file is not opened, the
* full technical details are printed in the I_Error() message.
*
* \param msg The message to log. This message can safely result from a call
* to va(), since that function is not used here.
* \todo Fix the I_Error() message. On some implementations the logfile may
* not be called log.txt.
* \sa CON_LogMessage, I_Error
*/
FUNCNORETURN static ATTRNORETURN void CorruptMapError(const char *msg)
{
// don't use va() because the calling function probably uses it
char mapname[MAXMAPLUMPNAME];
if (gamemap > 0 && gamemap <= nummapheaders && mapheaderinfo[gamemap-1])
{
sprintf(mapname, "%s", mapheaderinfo[gamemap-1]->lumpname);
}
else
{
sprintf(mapname, "ID %d", gamemap-1);
}
CON_LogMessage("Map ");
CON_LogMessage(mapname);
CON_LogMessage(" is corrupt: ");
CON_LogMessage(msg);
CON_LogMessage("\n");
I_Error("Invalid or corrupt map.\nLook in log file or text console for technical details.");
}
/** Sets a header's followers to the default list
*
* \param i The header to set followers for
*/
void P_SetDefaultHeaderFollowers(UINT16 i)
{
static INT16 defaultfollowers[MAXHEADERFOLLOWERS];
static UINT8 validdefaultfollowers = 0;
if (validdefaultfollowers == 0)
{
const char *defaultfollowernames[] =
{
"Flicky",
"Chao",
"Motobuddy",
NULL
};
for (validdefaultfollowers = 0; defaultfollowernames[validdefaultfollowers]; validdefaultfollowers++)
{
defaultfollowers[validdefaultfollowers] = K_FollowerAvailable(defaultfollowernames[validdefaultfollowers]);
}
I_Assert(validdefaultfollowers != 0);
}
mapheaderinfo[i]->followers = static_cast<INT16*>(Z_Realloc(mapheaderinfo[i]->followers, sizeof(INT16) * validdefaultfollowers, PU_STATIC, NULL));
for (mapheaderinfo[i]->numFollowers = 0; mapheaderinfo[i]->numFollowers < validdefaultfollowers; mapheaderinfo[i]->numFollowers++)
{
mapheaderinfo[i]->followers[mapheaderinfo[i]->numFollowers] = defaultfollowers[mapheaderinfo[i]->numFollowers];
}
}
/** Clears a header's followers
*
* \param i The header to clear followers for
*/
void P_DeleteHeaderFollowers(UINT16 i)
{
if (mapheaderinfo[i]->followers)
Z_Free(mapheaderinfo[i]->followers);
mapheaderinfo[i]->followers = NULL;
mapheaderinfo[i]->numFollowers = 0;
}
#define NUMLAPS_DEFAULT 3
static void P_ClearMapHeaderLighting(mapheader_lighting_t *lighting)
{
lighting->light_contrast = 16;
lighting->sprite_backlight = 0;
lighting->use_light_angle = false;
lighting->light_angle = 0;
}
/** Clears the data from a single map header.
*
* \param i Map number to clear header for.
* \sa P_ClearMapHeaderInfo
*/
static void P_ClearSingleMapHeaderInfo(INT16 num)
{
int i;
mapheaderinfo[num]->lvlttl[0] = '\0';
mapheaderinfo[num]->menuttl[0] = '\0';
mapheaderinfo[num]->zonttl[0] = '\0';
mapheaderinfo[num]->actnum = 0;
mapheaderinfo[num]->typeoflevel = 0;
mapheaderinfo[num]->gravity = DEFAULT_GRAVITY;
mapheaderinfo[num]->keywords[0] = '\0';
mapheaderinfo[num]->relevantskin[0] = '\0';
mapheaderinfo[num]->musname[0][0] = 0;
mapheaderinfo[num]->musname_size = 0;
mapheaderinfo[num]->encoremusname[0][0] = 0;
mapheaderinfo[num]->encoremusname_size = 0;
for (i = 0; i < MAXMUSNAMES-1; i++)
{
mapheaderinfo[num]->cache_muslock[i] = MAXUNLOCKABLES;
}
mapheaderinfo[num]->positionmus[0] = '\0';
mapheaderinfo[num]->associatedmus[0][0] = 0;
mapheaderinfo[num]->associatedmus_size = 0;
mapheaderinfo[num]->mustrack = 0;
mapheaderinfo[num]->muspos = 0;
mapheaderinfo[num]->weather = PRECIP_NONE;
snprintf(mapheaderinfo[num]->skytexture, 5, "SKY1");
mapheaderinfo[num]->skytexture[4] = 0;
mapheaderinfo[num]->skybox_scalex = 16;
mapheaderinfo[num]->skybox_scaley = 16;
mapheaderinfo[num]->skybox_scalez = 16;
mapheaderinfo[num]->darkness = FRACUNIT;
mapheaderinfo[num]->runsoc[0] = '#';
mapheaderinfo[num]->scriptname[0] = '#';
mapheaderinfo[num]->precutscenenum = 0;
mapheaderinfo[num]->cutscenenum = 0;
mapheaderinfo[num]->palette = UINT16_MAX;
mapheaderinfo[num]->encorepal = UINT16_MAX;
mapheaderinfo[num]->numlaps = NUMLAPS_DEFAULT;
mapheaderinfo[num]->lapspersection = 1;
mapheaderinfo[num]->levelselect = 0;
mapheaderinfo[num]->levelflags = 0;
mapheaderinfo[num]->menuflags = 0;
mapheaderinfo[num]->playerLimit = MAXPLAYERS;
mapheaderinfo[num]->mobj_scale = FRACUNIT;
mapheaderinfo[num]->default_waypoint_radius = 0;
P_ClearMapHeaderLighting(&mapheaderinfo[num]->lighting);
P_ClearMapHeaderLighting(&mapheaderinfo[num]->lighting_encore);
mapheaderinfo[num]->use_encore_lighting = false;
#if 1 // equivalent to "Followers = DEFAULT"
P_SetDefaultHeaderFollowers(num);
#else
P_DeleteHeaderFollowers(num);
#endif
memset(&mapheaderinfo[num]->records, 0, sizeof(recorddata_t));
mapheaderinfo[num]->justPlayed = 0;
mapheaderinfo[num]->anger = 0;
mapheaderinfo[num]->destroyforchallenge_size = 0;
mapheaderinfo[num]->cache_spraycan = UINT16_MAX;
mapheaderinfo[num]->cache_maplock = MAXUNLOCKABLES;
mapheaderinfo[num]->customopts = NULL;
mapheaderinfo[num]->numCustomOptions = 0;
if (mapheaderinfo[num]->ghostBrief != NULL)
{
for (i = 0; i < mapheaderinfo[num]->ghostCount; i++)
{
Z_Free(mapheaderinfo[num]->ghostBrief[i]);
}
Z_Free(mapheaderinfo[num]->ghostBrief);
}
mapheaderinfo[num]->ghostBrief = NULL;
mapheaderinfo[num]->ghostCount = 0;
mapheaderinfo[num]->ghostBriefSize = 0;
mapheaderinfo[num]->automedaltime[0] = 1;
mapheaderinfo[num]->automedaltime[1] = 2;
mapheaderinfo[num]->automedaltime[2] = 3;
mapheaderinfo[num]->automedaltime[3] = 4;
}
/** Allocates a new map-header structure.
*
* \param i Index of header to allocate.
*/
void P_AllocMapHeader(INT16 i)
{
if (i > nummapheaders)
I_Error("P_AllocMapHeader: Called on %d, should be %d", i, nummapheaders);
if (i >= NEXTMAP_SPECIAL)
{
I_Error("P_AllocMapHeader: Too many maps!");
}
if (i >= mapallocsize)
{
if (!mapallocsize)
{
mapallocsize = 16;
}
else
{
mapallocsize *= 2;
}
mapheaderinfo = static_cast<mapheader_t**>(Z_ReallocAlign(
(void*) mapheaderinfo,
sizeof(mapheader_t*) * mapallocsize,
PU_STATIC,
NULL,
sizeof(mapheader_t*) * 8
));
if (!mapheaderinfo)
I_Error("P_AllocMapHeader: Not enough memory to realloc mapheaderinfo (size %d)", mapallocsize);
}
if (!mapheaderinfo[i])
{
mapheaderinfo[i] = static_cast<mapheader_t*>(Z_Malloc(sizeof(mapheader_t), PU_STATIC, NULL));
if (!mapheaderinfo[i])
I_Error("P_AllocMapHeader: Not enough memory to allocate new mapheader (ID %d)", i);
mapheaderinfo[i]->lumpnum = LUMPERROR;
mapheaderinfo[i]->lumpname = NULL;
mapheaderinfo[i]->thumbnailPic = NULL;
mapheaderinfo[i]->minimapPic = NULL;
mapheaderinfo[i]->ghostCount = 0;
mapheaderinfo[i]->ghostBriefSize = 0;
mapheaderinfo[i]->ghostBrief = NULL;
mapheaderinfo[i]->cup = NULL;
mapheaderinfo[i]->followers = NULL;
nummapheaders++;
}
P_ClearSingleMapHeaderInfo(i);
}
//
// levelflats
//
#define MAXLEVELFLATS 256
size_t numlevelflats;
levelflat_t *levelflats;
levelflat_t *foundflats;
//SoM: Other files want this info.
size_t P_PrecacheLevelFlats(void)
{
lumpnum_t lump;
size_t i;
//SoM: 4/18/2000: New flat code to make use of levelflats.
flatmemory = 0;
for (i = 0; i < numlevelflats; i++)
{
if (levelflats[i].type == LEVELFLAT_FLAT)
{
lump = levelflats[i].u.flat.lumpnum;
if (devparm)
flatmemory += W_LumpLength(lump);
R_GetFlat(lump);
}
}
return flatmemory;
}
/*
levelflat refers to an array of level flats,
or NULL if we want to allocate it now.
*/
static INT32
Ploadflat (levelflat_t *levelflat, const char *flatname, boolean resize)
{
int texturenum;
size_t i;
// Scan through the already found flats, return if it matches.
for (i = 0; i < numlevelflats; i++)
{
if (strnicmp(levelflat[i].name, flatname, 8) == 0)
return i;
}
if (resize)
{
// allocate new flat memory
levelflats = static_cast<levelflat_t*>(Z_Realloc(levelflats, (numlevelflats + 1) * sizeof(*levelflats), PU_LEVEL, NULL));
levelflat = levelflats + numlevelflats;
}
else
{
if (numlevelflats >= MAXLEVELFLATS)
I_Error("Too many flats in level\n");
levelflat += numlevelflats;
}
// Store the name.
strlcpy(levelflat->name, flatname, sizeof (levelflat->name));
strupr(levelflat->name);
if (( texturenum = R_CheckTextureNumForName(levelflat->name) ) == -1)
{
// check for missing texture
if (( texturenum = R_CheckTextureNumForName(MISSING_TEXTURE) ) != -1)
goto texturefound;
// nevermind
levelflat->type = LEVELFLAT_NONE;
}
else
{
texturefound:
levelflat->type = LEVELFLAT_TEXTURE;
levelflat->u.texture. num = texturenum;
levelflat->u.texture.lastnum = texturenum;
/* start out unanimated */
levelflat->u.texture.basenum = -1;
}
levelflat->terrain =
K_GetTerrainForTextureName(levelflat->name);
CONS_Debug(DBG_SETUP, "flat #%03d: %s\n", atoi(sizeu1(numlevelflats)), levelflat->name);
return ( numlevelflats++ );
}
// Auxiliary function. Find a flat in the active wad files,
// allocate an id for it, and set the levelflat (to speedup search)
INT32 P_AddLevelFlat(const char *flatname, levelflat_t *levelflat)
{
return Ploadflat(levelflat, flatname, false);
}
// help function for Lua and $$$.sav reading
// same as P_AddLevelFlat, except this is not setup so we must realloc levelflats to fit in the new flat
// no longer a static func in lua_maplib.c because p_saveg.c also needs it
//
INT32 P_AddLevelFlatRuntime(const char *flatname)
{
return Ploadflat(levelflats, flatname, true);
}
// help function for $$$.sav checking
// this simply returns the flat # for the name given
//
INT32 P_CheckLevelFlat(const char *flatname)
{
size_t i;
levelflat_t *levelflat = levelflats;
//
// scan through the already found flats
//
for (i = 0; i < numlevelflats; i++, levelflat++)
if (strnicmp(levelflat->name,flatname,8)==0)
break;
if (i == numlevelflats)
return 0; // ??? flat was not found, this should not happen!
// level flat id
return (INT32)i;
}
//
// P_ReloadRings
// Used by NiGHTS, clears all ring/sphere/hoop/etc items and respawns them
//
void P_ReloadRings(void)
{
mobj_t *mo;
thinker_t *th;
size_t i, numHoops = 0;
// Okay, if you have more than 4000 hoops in your map,
// you're insane.
mapthing_t *hoopsToRespawn[4096];
mapthing_t *mt = mapthings;
// scan the thinkers to find rings/spheres/hoops to unset
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
{
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
continue;
mo = (mobj_t *)th;
if (mo->type == MT_HOOPCENTER)
{
// Hoops give me a headache
if (mo->threshold == 4242) // Dead hoop
{
hoopsToRespawn[numHoops++] = mo->spawnpoint;
P_RemoveMobj(mo);
}
continue;
}
if (mo->type != MT_RING)
continue;
// Don't auto-disintegrate things being pulled to us
if (mo->flags2 & MF2_NIGHTSPULL)
continue;
P_RemoveMobj(mo);
}
// Reiterate through mapthings
for (i = 0; i < nummapthings; i++, mt++)
{
// Notice an omission? We handle hoops differently.
if (mt->type == mobjinfo[MT_RING].doomednum)
{
mt->mobj = NULL;
P_SpawnMapThing(mt);
}
else if (mt->type >= 600 && mt->type <= 611) // Item patterns
{
mt->mobj = NULL;
P_SpawnItemPattern(mt);
}
}
for (i = 0; i < numHoops; i++)
{
P_SpawnHoop(hoopsToRespawn[i]);
}
}
static int cmp_loopends(const void *a, const void *b)
{
const mapthing_t
*mt1 = *(const mapthing_t*const*)a,
*mt2 = *(const mapthing_t*const*)b;
// weighted sorting; tag takes precedence over type
return
intsign(mt1->tid - mt2->tid) * 2 +
intsign(mt1->thing_args[0] - mt2->thing_args[0]);
}
static void P_SpawnMapThings(boolean spawnemblems)
{
size_t i;
mapthing_t *mt;
mapthing_t **loopends;
size_t num_loopends = 0;
// Spawn axis points first so they are at the front of the list for fast searching.
for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
{
switch (mt->type)
{
case 1700: // MT_AXIS
case 1701: // MT_AXISTRANSFER
case 1702: // MT_AXISTRANSFERLINE
case 2021: // MT_LOOPCENTERPOINT
mt->mobj = NULL;
P_SpawnMapThing(mt);
break;
case 2020: // MT_LOOPENDPOINT
num_loopends++;
break;
default:
break;
}
}
Z_Malloc(num_loopends * sizeof *loopends, PU_STATIC,
&loopends);
num_loopends = 0;
for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
{
switch (mt->type)
{
case 1700: // MT_AXIS
case 1701: // MT_AXISTRANSFER
case 1702: // MT_AXISTRANSFERLINE
case 2021: // MT_LOOPCENTERPOINT
continue; // These were already spawned
}
if (mt->type == mobjinfo[MT_ITEMCAPSULE].doomednum)
{
continue; // These will spawn later (in k_battle.c K_BattleInit)
}
if (mt->type == mobjinfo[MT_BATTLECAPSULE].doomednum && gametype != GT_TUTORIAL)
{
continue; // These will spawn later (in k_battle.c K_BattleInit), unless we're in a tutorial
}
if (!spawnemblems && mt->type == mobjinfo[MT_EMBLEM].doomednum)
continue;
mt->mobj = NULL;
if (mt->type == mobjinfo[MT_LOOPENDPOINT].doomednum)
{
loopends[num_loopends] = mt;
num_loopends++;
continue;
}
if (mt->type >= 600 && mt->type <= 611) // item patterns
P_SpawnItemPattern(mt);
else if (mt->type == 1713) // hoops
P_SpawnHoop(mt);
else // Everything else
P_SpawnMapThing(mt);
}
qsort(loopends, num_loopends, sizeof *loopends,
cmp_loopends);
for (i = 1; i < num_loopends; ++i)
{
mapthing_t
*mt1 = loopends[i - 1],
*mt2 = loopends[i];
if (mt1->tid == mt2->tid &&
mt1->thing_args[0] == mt2->thing_args[0])
{
P_SpawnItemLine(mt1, mt2);
i++;
}
}
Z_Free(loopends);
if (spawnemblems
&& gametype != GT_TUTORIAL
&& !modeattacking
&& !(tutorialchallenge == TUTORIALSKIP_INPROGRESS && gamedata->gotspraycans == 0))
{
const UINT8 recommendedcans =
#ifdef DEVELOP
!(mapheaderinfo[gamemap-1]->typeoflevel & TOL_RACE) ? 0 :
#endif
1;
if (nummapspraycans > recommendedcans)
CONS_Alert(CONS_ERROR, "SPRAY CANS: Map has too many Spray Cans (%d)!", nummapspraycans);
#ifdef DEVELOP
else if (nummapspraycans != recommendedcans)
CONS_Alert(CONS_ERROR, "SPRAY CANS: Krew-made Race maps need a Spray Can placed!");
#endif
}
}
// Experimental groovy write function!
/*
void P_WriteThings(void)
{
const char * filename;
size_t i, length;
mapthing_t *mt;
savebuffer_t save = {0};
INT16 temp;
if (P_SaveBufferAlloc(&save, nummapthings * sizeof (mapthing_t)) == false)
{
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for thing writing!\n"));
return;
}
save.end = save.buffer + save.size;
mt = mapthings;
for (i = 0; i < nummapthings; i++, mt++)
{
WRITEINT16(save.p, mt->x);
WRITEINT16(save.p, mt->y);
WRITEINT16(save.p, mt->angle);
temp = (INT16)(mt->type + ((INT16)mt->extrainfo << 12));
WRITEINT16(save.p, temp);
WRITEUINT16(save.p, mt->options);
}
length = save.p - save.buffer;
filename = va("newthings-%s.lmp", G_BuildMapName(gamemap));
FIL_WriteFile(filename, save.buffer, length);
P_SaveBufferFree(&save);
CONS_Printf(M_GetText("%s saved.\n"), filename);
}
*/
//
// MAP LOADING FUNCTIONS
//
static void P_LoadVertices(UINT8 *data)
{
mapvertex_t *mv = (mapvertex_t *)data;
vertex_t *v = vertexes;
size_t i;
// Copy and convert vertex coordinates, internal representation as fixed.
for (i = 0; i < numvertexes; i++, v++, mv++)
{
v->x = SHORT(mv->x)<<FRACBITS;
v->y = SHORT(mv->y)<<FRACBITS;
v->floorzset = v->ceilingzset = false;
v->floorz = v->ceilingz = 0;
}
}
static void P_InitializeSector(sector_t *ss)
{
memset(&ss->soundorg, 0, sizeof(ss->soundorg));
ss->validcount = 0;
ss->thinglist = NULL;
ss->floordata = NULL;
ss->ceilingdata = NULL;
ss->lightingdata = NULL;
ss->fadecolormapdata = NULL;
ss->heightsec = -1;
ss->camsec = -1;
ss->floorlightsec = ss->ceilinglightsec = -1;
ss->crumblestate = CRUMBLE_NONE;
ss->touching_thinglist = NULL;
ss->linecount = 0;
ss->lines = NULL;
ss->ffloors = NULL;
ss->attached = NULL;
ss->attachedsolid = NULL;
ss->numattached = 0;
ss->maxattached = 1;
ss->lightlist = NULL;
ss->numlights = 0;
ss->moved = true;
ss->extra_colormap = NULL;
ss->gravityptr = NULL;
ss->cullheight = NULL;
ss->floorspeed = ss->ceilspeed = 0;
ss->touching_preciplist = NULL;
ss->f_slope = NULL;
ss->c_slope = NULL;
ss->hasslope = false;
ss->spawn_lightlevel = ss->lightlevel;
ss->spawn_extra_colormap = NULL;
memset(&ss->botController, 0, sizeof(ss->botController));
}
static void P_LoadSectors(UINT8 *data)
{
mapsector_t *ms = (mapsector_t *)data;
sector_t *ss = sectors;
size_t i;
// For each counted sector, copy the sector raw data from our cache pointer ms, to the global table pointer ss.
for (i = 0; i < numsectors; i++, ss++, ms++)
{
ss->floorheight = SHORT(ms->floorheight)<<FRACBITS;
ss->ceilingheight = SHORT(ms->ceilingheight)<<FRACBITS;
ss->floorpic = P_AddLevelFlat(ms->floorpic, foundflats);
ss->ceilingpic = P_AddLevelFlat(ms->ceilingpic, foundflats);
ss->lightlevel = SHORT(ms->lightlevel);
ss->special = SHORT(ms->special);
Tag_FSet(&ss->tags, SHORT(ms->tag));
ss->floor_xoffs = ss->floor_yoffs = 0;
ss->ceiling_xoffs = ss->ceiling_yoffs = 0;
ss->floorpic_angle = ss->ceilingpic_angle = 0;
ss->floorlightlevel = ss->ceilinglightlevel = 0;
ss->floorlightabsolute = ss->ceilinglightabsolute = false;
ss->colormap_protected = false;
ss->gravity = FRACUNIT;
ss->flags = MSF_FLIPSPECIAL_FLOOR;
ss->specialflags = static_cast<sectorspecialflags_t>(0);
ss->damagetype = SD_NONE;
ss->triggertag = 0;
ss->triggerer = TO_PLAYER;
ss->friction = ORIG_FRICTION;
ss->action = 0;
memset(ss->args, 0, NUM_SCRIPT_ARGS*sizeof(*ss->args));
memset(ss->stringargs, 0x00, NUM_SCRIPT_STRINGARGS*sizeof(*ss->stringargs));
ss->activation = static_cast<sectoractionflags_t>(0);
P_InitializeSector(ss);
}
}
static void P_InitializeLinedef(line_t *ld)
{
vertex_t *v1 = ld->v1;
vertex_t *v2 = ld->v2;
UINT8 j;
ld->dx = v2->x - v1->x;
ld->dy = v2->y - v1->y;
ld->angle = R_PointToAngle2(0, 0, ld->dx, ld->dy);
ld->bbox[BOXLEFT] = std::min(v1->x, v2->x);
ld->bbox[BOXRIGHT] = std::max(v1->x, v2->x);
ld->bbox[BOXBOTTOM] = std::min(v1->y, v2->y);
ld->bbox[BOXTOP] = std::max(v1->y, v2->y);
if (!ld->dx)
ld->slopetype = ST_VERTICAL;
else if (!ld->dy)
ld->slopetype = ST_HORIZONTAL;
else if ((ld->dy > 0) == (ld->dx > 0))
ld->slopetype = ST_POSITIVE;
else
ld->slopetype = ST_NEGATIVE;
ld->frontsector = ld->backsector = NULL;
ld->validcount = 0;
ld->polyobj = NULL;
ld->tripwire = false;
ld->callcount = 0;
// cph 2006/09/30 - fix sidedef errors right away.
// cph 2002/07/20 - these errors are fatal if not fixed, so apply them
for (j = 0; j < 2; j++)
if (ld->sidenum[j] != 0xffff && ld->sidenum[j] >= (UINT16)numsides)
{
ld->sidenum[j] = 0xffff;
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has out-of-range sidedef number\n", sizeu1((size_t)(ld - lines)));
}
// killough 11/98: fix common wad errors (missing sidedefs):
if (ld->sidenum[0] == 0xffff)
{
ld->sidenum[0] = 0; // Substitute dummy sidedef for missing right side
// cph - print a warning about the bug
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s missing first sidedef\n", sizeu1((size_t)(ld - lines)));
}
if ((ld->sidenum[1] == 0xffff) && (ld->flags & ML_TWOSIDED))
{
ld->flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left side
// cph - print a warning about the bug
CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has two-sided flag set, but no second sidedef\n", sizeu1((size_t)(ld - lines)));
}
if (ld->sidenum[0] != 0xffff)
{
sides[ld->sidenum[0]].special = ld->special;
sides[ld->sidenum[0]].line = ld;
}
if (ld->sidenum[1] != 0xffff)
{
sides[ld->sidenum[1]].special = ld->special;
sides[ld->sidenum[1]].line = ld;
}
}
static void P_SetLinedefV1(size_t i, UINT16 vertex_num)
{
if (vertex_num >= numvertexes)
{
CONS_Debug(DBG_SETUP, "P_SetLinedefV1: linedef %s has out-of-range v1 num %u\n", sizeu1(i), vertex_num);
vertex_num = 0;
}
lines[i].v1 = &vertexes[vertex_num];
}
static void P_SetLinedefV2(size_t i, UINT16 vertex_num)
{
if (vertex_num >= numvertexes)
{
CONS_Debug(DBG_SETUP, "P_SetLinedefV2: linedef %s has out-of-range v2 num %u\n", sizeu1(i), vertex_num);
vertex_num = 0;
}
lines[i].v2 = &vertexes[vertex_num];
}
static void P_LoadLinedefs(UINT8 *data)
{
maplinedef_t *mld = (maplinedef_t *)data;
line_t *ld = lines;
size_t i;
for (i = 0; i < numlines; i++, mld++, ld++)
{
ld->flags = (UINT32)(SHORT(mld->flags));
ld->special = SHORT(mld->special);
Tag_FSet(&ld->tags, SHORT(mld->tag));
memset(ld->args, 0, NUM_SCRIPT_ARGS*sizeof(*ld->args));
memset(ld->stringargs, 0x00, NUM_SCRIPT_STRINGARGS*sizeof(*ld->stringargs));
ld->alpha = FRACUNIT;
ld->executordelay = 0;
ld->activation = 0;
P_SetLinedefV1(i, SHORT(mld->v1));
P_SetLinedefV2(i, SHORT(mld->v2));
ld->sidenum[0] = SHORT(mld->sidenum[0]);
ld->sidenum[1] = SHORT(mld->sidenum[1]);
P_InitializeLinedef(ld);
}
}
static void P_SetSidedefSector(size_t i, UINT16 sector_num)
{
// cph 2006/09/30 - catch out-of-range sector numbers; use sector 0 instead
if (sector_num >= numsectors)
{
CONS_Debug(DBG_SETUP, "P_SetSidedefSector: sidedef %s has out-of-range sector num %u\n", sizeu1(i), sector_num);
sector_num = 0;
}
sides[i].sector = &sectors[sector_num];
}
static void P_InitializeSidedef(side_t *sd)
{
if (!sd->line)
{
CONS_Debug(DBG_SETUP, "P_LoadSidedefs: Sidedef %s is not used by any linedef\n", sizeu1((size_t)(sd - sides)));
sd->line = &lines[0];
sd->special = sd->line->special;
}
sd->colormap_data = NULL;
}
/* -- Reference implementation
static void P_WriteConstant(INT32 constant, char **target)
{
char buffer[12];
size_t len;
sprintf(buffer, "%d", constant);
len = strlen(buffer) + 1;
*target = Z_Malloc(len, PU_LEVEL, NULL);
M_Memcpy(*target, buffer, len);
} */
static void P_WriteDuplicateText(const char *text, char **target)
{
if (text == NULL || text[0] == '\0')
return;
size_t len = strlen(text) + 1;
*target = static_cast<char*>(Z_Malloc(len, PU_LEVEL, NULL));
M_Memcpy(*target, text, len);
}
static void P_WriteSkincolor(INT32 constant, char **target)
{
if (constant <= SKINCOLOR_NONE
|| constant >= (INT32)numskincolors)
return;
P_WriteDuplicateText(
va("SKINCOLOR_%s", skincolors[constant].name),
target
);
}
static void P_WriteSfx(INT32 constant, char **target)
{
if (constant <= sfx_None
|| constant >= (INT32)sfxfree)
return;
P_WriteDuplicateText(
va("sfx_%s", S_sfx[constant].name),
target
);
}
static void P_LoadSidedefs(UINT8 *data)
{
mapsidedef_t *msd = (mapsidedef_t*)data;
side_t *sd = sides;
size_t i;
for (i = 0; i < numsides; i++, sd++, msd++)
{
INT16 textureoffset = SHORT(msd->textureoffset);
boolean isfrontside;
P_InitializeSidedef(sd);
isfrontside = sd->line->sidenum[0] == i;
// Repeat count for midtexture
if (((sd->line->flags & (ML_TWOSIDED|ML_WRAPMIDTEX)) == (ML_TWOSIDED|ML_WRAPMIDTEX))
&& !(sd->special >= 300 && sd->special < 500)) // exempt linedef exec specials
{
sd->repeatcnt = (INT16)(((UINT16)textureoffset) >> 12);
sd->textureoffset = (((UINT16)textureoffset) & 2047) << FRACBITS;
}
else
{
sd->repeatcnt = 0;
sd->textureoffset = textureoffset << FRACBITS;
}
sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
P_SetSidedefSector(i, SHORT(msd->sector));
// Special info stored in texture fields!
switch (sd->special)
{
case 606: //SoM: 4/4/2000: Just colormap transfer
case 447: // Change colormap of tagged sectors! -- Monster Iestyn 14/06/18
case 455: // Fade colormaps! mazmazz 9/12/2018 (:flag_us:)
// SoM: R_CreateColormap will only create a colormap in software mode...
// Perhaps we should just call it instead of doing the calculations here.
sd->colormap_data = R_CreateColormapFromLinedef(msd->toptexture, msd->midtexture, msd->bottomtexture);
sd->toptexture = sd->midtexture = sd->bottomtexture = 0;
break;
case 414: // Play SFX
{
sd->toptexture = sd->midtexture = sd->bottomtexture = 0;
if (!isfrontside)
break;
if (msd->toptexture[0] != '-' || msd->toptexture[1] != '\0')
{
char process[8 + 1];
M_Memcpy(process, msd->toptexture, 8);
process[8] = '\0';
P_WriteDuplicateText(process, &sd->line->stringargs[0]);
}
break;
}
case 9: // Mace parameters
case 14: // Bustable block parameters
case 15: // Fan particle spawner parameters
{
if (msd->toptexture[7] == '\0' && strcasecmp(msd->toptexture, "MT_NULL") == 0)
{
// Don't bulk the conversion with irrelevant types
break;
}
}
// FALLTHRU
case 331: // Trigger linedef executor: Skin - Continuous
case 332: // Trigger linedef executor: Skin - Each time
case 333: // Trigger linedef executor: Skin - Once
case 334: // Trigger linedef executor: Object dye - Continuous
case 335: // Trigger linedef executor: Object dye - Each time
case 336: // Trigger linedef executor: Object dye - Once
case 425: // Calls P_SetMobjState on calling mobj
case 442: // Calls P_SetMobjState on mobjs of a given type in the tagged sectors
case 443: // Calls a named Lua function
case 461: // Spawns an object on the map based on texture offsets
case 463: // Colorizes an object
case 475: // ACS_Execute
case 476: // ACS_ExecuteAlways
case 477: // ACS_Suspend
case 478: // ACS_Terminate
{
char process[8*3+1];
memset(process,0,8*3+1);
sd->toptexture = sd->midtexture = sd->bottomtexture = 0;
if (msd->toptexture[0] == '-' && msd->toptexture[1] == '\0')
break;
else
M_Memcpy(process,msd->toptexture,8);
if (msd->midtexture[0] != '-' || msd->midtexture[1] != '\0')
M_Memcpy(process+strlen(process), msd->midtexture, 8);
if (msd->bottomtexture[0] != '-' || msd->bottomtexture[1] != '\0')
M_Memcpy(process+strlen(process), msd->bottomtexture, 8);
P_WriteDuplicateText(
process,
&sd->line->stringargs[(isfrontside) ? 0 : 1]
);
break;
}
case 259: // Custom FOF
if (!isfrontside)
{
if ((msd->toptexture[0] >= '0' && msd->toptexture[0] <= '9')
|| (msd->toptexture[0] >= 'A' && msd->toptexture[0] <= 'F'))
sd->toptexture = axtoi(msd->toptexture);
else
I_Error("Custom FOF (line id %s) needs a value in the linedef's back side upper texture field.", sizeu1(sd->line - lines));
sd->midtexture = R_TextureNumForName(msd->midtexture);
sd->bottomtexture = R_TextureNumForName(msd->bottomtexture);
break;
}
// FALLTHRU
default: // normal cases
if (msd->toptexture[0] == '#')
{
char *col = msd->toptexture;
sd->toptexture =
((col[1]-'0')*100 + (col[2]-'0')*10 + col[3]-'0')+1;
if (col[4]) // extra num for blendmode
sd->toptexture += (col[4]-'0')*1000;
sd->bottomtexture = sd->toptexture;
sd->midtexture = R_TextureNumForName(msd->midtexture);
}
else
{
sd->midtexture = R_TextureNumForName(msd->midtexture);
sd->toptexture = R_TextureNumForName(msd->toptexture);
sd->bottomtexture = R_TextureNumForName(msd->bottomtexture);
}
break;
}
}
}
static void P_LoadThings(UINT8 *data)
{
mapthing_t *mt;
size_t i;
for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
{
mt->x = READINT16(data);
mt->y = READINT16(data);
mt->angle = READINT16(data);
mt->type = READUINT16(data);
mt->options = READUINT16(data);
mt->extrainfo = (UINT8)(mt->type >> 12);
mt->tid = 0;
mt->scale = FRACUNIT;
mt->spritexscale = mt->spriteyscale = FRACUNIT;
memset(mt->thing_args, 0, NUM_MAPTHING_ARGS*sizeof(*mt->thing_args));
memset(mt->thing_stringargs, 0x00, NUM_MAPTHING_STRINGARGS*sizeof(*mt->thing_stringargs));
mt->special = 0;
memset(mt->script_args, 0, NUM_SCRIPT_ARGS*sizeof(*mt->script_args));
memset(mt->script_stringargs, 0x00, NUM_SCRIPT_STRINGARGS*sizeof(*mt->script_stringargs));
mt->pitch = mt->roll = 0;
mt->layer = 0;
mt->type &= 4095;
if (mt->type == 1705 || (mt->type == 750 && mt->extrainfo))
mt->z = mt->options; // NiGHTS Hoops use the full flags bits to set the height.
else
mt->z = mt->options >> ZSHIFT;
mt->adjusted_z = INT32_MAX;
mt->mobj = NULL;
}
}
// Stores positions for relevant map data spread through a TEXTMAP.
UINT32 mapthingsPos[UINT16_MAX];
UINT32 linesPos[UINT16_MAX];
UINT32 sidesPos[UINT16_MAX];
UINT32 vertexesPos[UINT16_MAX];
UINT32 sectorsPos[UINT16_MAX];
// Determine total amount of map data in TEXTMAP.
static boolean TextmapCount(size_t size)
{
TracyCZone(__zone, true);
const char *tkn = M_TokenizerRead(0);
UINT8 brackets = 0;
nummapthings = 0;
numlines = 0;
numsides = 0;
numvertexes = 0;
numsectors = 0;
// Look for namespace at the beginning.
if (!fastcmp(tkn, "namespace"))
{
CONS_Alert(CONS_ERROR, "No namespace at beginning of lump!\n");
TracyCZoneEnd(__zone);
return false;
}
// Check if namespace is valid.
tkn = M_TokenizerRead(0);
if (!fastcmp(tkn, "ringracers"))
CONS_Alert(CONS_WARNING, "Invalid namespace '%s', only 'ringracers' is supported. This map may have issues loading.\n", tkn);
while ((tkn = M_TokenizerRead(0)) && M_TokenizerGetEndPos() < size)
{
// Avoid anything inside bracketed stuff, only look for external keywords.
if (brackets)
{
if (fastcmp(tkn, "}"))
brackets--;
}
else if (fastcmp(tkn, "{"))
brackets++;
// Check for valid fields.
else if (fastcmp(tkn, "thing"))
mapthingsPos[nummapthings++] = M_TokenizerGetEndPos();
else if (fastcmp(tkn, "linedef"))
linesPos[numlines++] = M_TokenizerGetEndPos();
else if (fastcmp(tkn, "sidedef"))
sidesPos[numsides++] = M_TokenizerGetEndPos();
else if (fastcmp(tkn, "vertex"))
vertexesPos[numvertexes++] = M_TokenizerGetEndPos();
else if (fastcmp(tkn, "sector"))
sectorsPos[numsectors++] = M_TokenizerGetEndPos();
else if (fastcmp(tkn, "version"))
{
tkn = M_TokenizerRead(0);
udmf_version = atoi(tkn);
if (udmf_version > UDMF_CURRENT_VERSION)
CONS_Alert(CONS_WARNING, "Map is intended for future UDMF version '%d', current supported version is '%d'. This map may have issues loading.\n", udmf_version, UDMF_CURRENT_VERSION);
}
else
CONS_Alert(CONS_NOTICE, "Unknown field '%s'.\n", tkn);
}
if (brackets)
{
CONS_Alert(CONS_ERROR, "Unclosed brackets detected in textmap lump.\n");
TracyCZoneEnd(__zone);
return false;
}
TracyCZoneEnd(__zone);
return true;
}
enum
{
PROP_NUM_TYPE_NA,
PROP_NUM_TYPE_INT,
PROP_NUM_TYPE_FLOAT
};
static void ParseUserProperty(mapUserProperties_t *user, const char *param, const char *val)
{
if (fastncmp(param, "user_", 5) && strlen(param) > 5)
{
const boolean valIsString = M_TokenizerJustReadString();
const char *key = param + 5;
const size_t valLen = strlen(val);
UINT8 numberType = PROP_NUM_TYPE_INT;
size_t i = 0;
if (valIsString == true)
{
// Value is a string. Upload directly!
K_UserPropertyPush(user, key, USER_PROP_STR, &val);
return;
}
for (i = 0; i < valLen; i++)
{
if (val[i] == '.')
{
numberType = PROP_NUM_TYPE_FLOAT;
}
else if (val[i] < '0' || val[i] > '9')
{
numberType = PROP_NUM_TYPE_NA;
break;
}
}
switch (numberType)
{
case PROP_NUM_TYPE_INT:
{
// Value is an integer.
INT32 vInt = atol(val);
K_UserPropertyPush(user, key, USER_PROP_INT, &vInt);
break;
}
case PROP_NUM_TYPE_FLOAT:
{
// Value is a float. Convert to fixed.
fixed_t vFixed = FLOAT_TO_FIXED(atof(val));
K_UserPropertyPush(user, key, USER_PROP_FIXED, &vFixed);
break;
}
case PROP_NUM_TYPE_NA:
default:
{
// Value is some other kind of type.
// Currently we just support bool.
boolean vBool = fastcmp("true", val);
if (vBool == true || fastcmp("false", val))
{
// Value is a boolean.
K_UserPropertyPush(user, key, USER_PROP_BOOL, &vBool);
}
else
{
// Value is invalid.
CONS_Alert(CONS_WARNING, "Could not interpret user property \"%s\" value (%s)\n", param, val);
}
break;
}
}
}
}
static void ParseTextmapVertexParameter(UINT32 i, const char *param, const char *val)
{
if (fastcmp(param, "x"))
vertexes[i].x = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "y"))
vertexes[i].y = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "zfloor"))
{
vertexes[i].floorz = FLOAT_TO_FIXED(atof(val));
vertexes[i].floorzset = true;
}
else if (fastcmp(param, "zceiling"))
{
vertexes[i].ceilingz = FLOAT_TO_FIXED(atof(val));
vertexes[i].ceilingzset = true;
}
}
typedef struct textmap_colormap_s {
boolean used;
INT32 lightcolor;
UINT8 lightalpha;
INT32 fadecolor;
UINT8 fadealpha;
UINT8 fadestart;
UINT8 fadeend;
UINT8 flags;
} textmap_colormap_t;
textmap_colormap_t textmap_colormap = { false, 0, 25, 0, 25, 0, 31, 0 };
typedef enum
{
PD_A = 1,
PD_B = 1<<1,
PD_C = 1<<2,
PD_D = 1<<3,
} planedef_t;
typedef struct textmap_plane_s {
UINT8 defined;
fixed_t a, b, c, d;
} textmap_plane_t;
textmap_plane_t textmap_planefloor = {0, 0, 0, 0, 0};
textmap_plane_t textmap_planeceiling = {0, 0, 0, 0, 0};
static void ParseTextmapSectorParameter(UINT32 i, const char *param, const char *val)
{
if (fastcmp(param, "heightfloor"))
sectors[i].floorheight = atol(val) << FRACBITS;
else if (fastcmp(param, "heightceiling"))
sectors[i].ceilingheight = atol(val) << FRACBITS;
if (fastcmp(param, "texturefloor"))
sectors[i].floorpic = P_AddLevelFlat(val, foundflats);
else if (fastcmp(param, "textureceiling"))
sectors[i].ceilingpic = P_AddLevelFlat(val, foundflats);
else if (fastcmp(param, "lightlevel"))
sectors[i].lightlevel = atol(val);
else if (fastcmp(param, "lightfloor"))
sectors[i].floorlightlevel = atol(val);
else if (fastcmp(param, "lightfloorabsolute") && fastcmp("true", val))
sectors[i].floorlightabsolute = true;
else if (fastcmp(param, "lightceiling"))
sectors[i].ceilinglightlevel = atol(val);
else if (fastcmp(param, "lightceilingabsolute") && fastcmp("true", val))
sectors[i].ceilinglightabsolute = true;
else if (fastcmp(param, "id"))
Tag_FSet(&sectors[i].tags, atol(val));
else if (fastcmp(param, "moreids"))
{
const char* id = val;
while (id)
{
Tag_Add(&sectors[i].tags, atol(id));
if ((id = strchr(id, ' ')))
id++;
}
}
else if (fastcmp(param, "xpanningfloor"))
sectors[i].floor_xoffs = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "ypanningfloor"))
sectors[i].floor_yoffs = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "xpanningceiling"))
sectors[i].ceiling_xoffs = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "ypanningceiling"))
sectors[i].ceiling_yoffs = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "rotationfloor"))
sectors[i].floorpic_angle = FixedAngle(FLOAT_TO_FIXED(atof(val)));
else if (fastcmp(param, "rotationceiling"))
sectors[i].ceilingpic_angle = FixedAngle(FLOAT_TO_FIXED(atof(val)));
else if (fastcmp(param, "floorplane_a"))
{
textmap_planefloor.defined |= PD_A;
textmap_planefloor.a = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "floorplane_b"))
{
textmap_planefloor.defined |= PD_B;
textmap_planefloor.b = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "floorplane_c"))
{
textmap_planefloor.defined |= PD_C;
textmap_planefloor.c = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "floorplane_d"))
{
textmap_planefloor.defined |= PD_D;
textmap_planefloor.d = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "ceilingplane_a"))
{
textmap_planeceiling.defined |= PD_A;
textmap_planeceiling.a = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "ceilingplane_b"))
{
textmap_planeceiling.defined |= PD_B;
textmap_planeceiling.b = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "ceilingplane_c"))
{
textmap_planeceiling.defined |= PD_C;
textmap_planeceiling.c = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "ceilingplane_d"))
{
textmap_planeceiling.defined |= PD_D;
textmap_planeceiling.d = FLOAT_TO_FIXED(atof(val));
}
else if (fastcmp(param, "lightcolor"))
{
textmap_colormap.used = true;
textmap_colormap.lightcolor = atol(val);
}
else if (fastcmp(param, "lightalpha"))
{
textmap_colormap.used = true;
textmap_colormap.lightalpha = atol(val);
}
else if (fastcmp(param, "fadecolor"))
{
textmap_colormap.used = true;
textmap_colormap.fadecolor = atol(val);
}
else if (fastcmp(param, "fadealpha"))
{
textmap_colormap.used = true;
textmap_colormap.fadealpha = atol(val);
}
else if (fastcmp(param, "fadestart"))
{
textmap_colormap.used = true;
textmap_colormap.fadestart = atol(val);
}
else if (fastcmp(param, "fadeend"))
{
textmap_colormap.used = true;
textmap_colormap.fadeend = atol(val);
}
else if (fastcmp(param, "colormapfog") && fastcmp("true", val))
{
textmap_colormap.used = true;
textmap_colormap.flags |= CMF_FOG;
}
else if (fastcmp(param, "colormapfadesprites") && fastcmp("true", val))
{
textmap_colormap.used = true;
textmap_colormap.flags |= CMF_FADEFULLBRIGHTSPRITES;
}
else if (fastcmp(param, "colormapprotected") && fastcmp("true", val))
sectors[i].colormap_protected = true;
else if (fastcmp(param, "flipspecial_nofloor") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags & ~MSF_FLIPSPECIAL_FLOOR);
else if (fastcmp(param, "flipspecial_ceiling") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_FLIPSPECIAL_CEILING);
else if (fastcmp(param, "triggerspecial_touch") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_TRIGGERSPECIAL_TOUCH);
else if (fastcmp(param, "triggerspecial_headbump") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_TRIGGERSPECIAL_HEADBUMP);
else if (fastcmp(param, "invertprecip") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_INVERTPRECIP);
else if (fastcmp(param, "gravityflip") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_GRAVITYFLIP);
else if (fastcmp(param, "heatwave") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_HEATWAVE);
else if (fastcmp(param, "noclipcamera") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_NOCLIPCAMERA);
else if (fastcmp(param, "ripple_floor") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_RIPPLE_FLOOR);
else if (fastcmp(param, "ripple_ceiling") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_RIPPLE_CEILING);
else if (fastcmp(param, "invertencore") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_INVERTENCORE);
else if (fastcmp(param, "flatlighting") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_FLATLIGHTING);
else if (fastcmp(param, "forcedirectionallighting") && fastcmp("true", val))
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_DIRECTIONLIGHTING);
else if (fastcmp(param, "nostepup") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_NOSTEPUP);
else if (fastcmp(param, "doublestepup") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_DOUBLESTEPUP);
else if (fastcmp(param, "nostepdown") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_NOSTEPDOWN);
else if ((fastcmp(param, "cheatcheckactivator") || fastcmp(param, "starpostactivator")) && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_CHEATCHECKACTIVATOR);
else if (fastcmp(param, "exit") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_EXIT);
else if (fastcmp(param, "deleteitems") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_DELETEITEMS);
else if (fastcmp(param, "fan") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_FAN);
else if (fastcmp(param, "zoomtubestart") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_ZOOMTUBESTART);
else if (fastcmp(param, "zoomtubeend") && fastcmp("true", val))
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_ZOOMTUBEEND);
else if (fastcmp(param, "friction"))
sectors[i].friction = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "gravity"))
sectors[i].gravity = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "damagetype"))
{
if (fastcmp(val, "Generic"))
sectors[i].damagetype = SD_GENERIC;
if (fastcmp(val, "Lava"))
sectors[i].damagetype = SD_LAVA;
if (fastcmp(val, "DeathPit"))
sectors[i].damagetype = SD_DEATHPIT;
if (fastcmp(val, "Instakill"))
sectors[i].damagetype = SD_INSTAKILL;
if (fastcmp(val, "Stumble"))
sectors[i].damagetype = SD_STUMBLE;
}
else if (fastcmp(param, "action"))
sectors[i].action = atol(val);
else if (fastncmp(param, "stringarg", 9) && strlen(param) > 9)
{
size_t argnum = atol(param + 9);
if (argnum >= NUM_SCRIPT_STRINGARGS)
return;
sectors[i].stringargs[argnum] = static_cast<char*>(Z_Malloc(strlen(val) + 1, PU_LEVEL, NULL));
M_Memcpy(sectors[i].stringargs[argnum], val, strlen(val) + 1);
}
else if (fastncmp(param, "arg", 3) && strlen(param) > 3)
{
size_t argnum = atol(param + 3);
if (argnum >= NUM_SCRIPT_ARGS)
return;
sectors[i].args[argnum] = atol(val);
}
else if (fastcmp(param, "repeatspecial") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | ((sectors[i].activation & ~SECSPAC_TRIGGERMASK) | SECSPAC_REPEATSPECIAL));
else if (fastcmp(param, "continuousspecial") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | ((sectors[i].activation & ~SECSPAC_TRIGGERMASK) | SECSPAC_CONTINUOUSSPECIAL));
else if (fastcmp(param, "playerenter") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_ENTER);
else if (fastcmp(param, "playerfloor") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_FLOOR);
else if (fastcmp(param, "playerceiling") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_CEILING);
else if (fastcmp(param, "monsterenter") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_ENTERMONSTER);
else if (fastcmp(param, "monsterfloor") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_FLOORMONSTER);
else if (fastcmp(param, "monsterceiling") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_CEILINGMONSTER);
else if (fastcmp(param, "missileenter") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_ENTERMISSILE);
else if (fastcmp(param, "missilefloor") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_FLOORMISSILE);
else if (fastcmp(param, "missileceiling") && fastcmp("true", val))
sectors[i].activation = static_cast<sectoractionflags_t>(sectors[i].activation | SECSPAC_CEILINGMISSILE);
else
ParseUserProperty(&sectors[i].user, param, val);
}
static void ParseTextmapSidedefParameter(UINT32 i, const char *param, const char *val)
{
if (fastcmp(param, "offsetx"))
sides[i].textureoffset = atol(val)<<FRACBITS;
else if (fastcmp(param, "offsety"))
sides[i].rowoffset = atol(val)<<FRACBITS;
else if (fastcmp(param, "texturetop"))
sides[i].toptexture = R_TextureNumForName(val);
else if (fastcmp(param, "texturebottom"))
sides[i].bottomtexture = R_TextureNumForName(val);
else if (fastcmp(param, "texturemiddle"))
sides[i].midtexture = R_TextureNumForName(val);
else if (fastcmp(param, "sector"))
P_SetSidedefSector(i, atol(val));
else if (fastcmp(param, "repeatcnt"))
sides[i].repeatcnt = atol(val);
else
ParseUserProperty(&sides[i].user, param, val);
}
static void ParseTextmapLinedefParameter(UINT32 i, const char *param, const char *val)
{
if (fastcmp(param, "id"))
Tag_FSet(&lines[i].tags, atol(val));
else if (fastcmp(param, "moreids"))
{
const char* id = val;
while (id)
{
Tag_Add(&lines[i].tags, atol(id));
if ((id = strchr(id, ' ')))
id++;
}
}
else if (fastcmp(param, "special"))
lines[i].special = atol(val);
else if (fastcmp(param, "v1"))
P_SetLinedefV1(i, atol(val));
else if (fastcmp(param, "v2"))
P_SetLinedefV2(i, atol(val));
else if (fastncmp(param, "stringarg", 9) && strlen(param) > 9)
{
size_t argnum = atol(param + 9);
if (argnum >= NUM_SCRIPT_STRINGARGS)
return;
lines[i].stringargs[argnum] = static_cast<char*>(Z_Malloc(strlen(val) + 1, PU_LEVEL, NULL));
M_Memcpy(lines[i].stringargs[argnum], val, strlen(val) + 1);
}
else if (fastncmp(param, "arg", 3) && strlen(param) > 3)
{
size_t argnum = atol(param + 3);
if (argnum >= NUM_SCRIPT_ARGS)
return;
lines[i].args[argnum] = atol(val);
}
else if (fastcmp(param, "sidefront"))
lines[i].sidenum[0] = atol(val);
else if (fastcmp(param, "sideback"))
lines[i].sidenum[1] = atol(val);
else if (fastcmp(param, "alpha"))
lines[i].alpha = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "blendmode") || fastcmp(param, "renderstyle"))
{
if (fastcmp(val, "translucent"))
lines[i].blendmode = AST_COPY;
else if (fastcmp(val, "add"))
lines[i].blendmode = AST_ADD;
else if (fastcmp(val, "subtract"))
lines[i].blendmode = AST_SUBTRACT;
else if (fastcmp(val, "reversesubtract"))
lines[i].blendmode = AST_REVERSESUBTRACT;
else if (fastcmp(val, "modulate"))
lines[i].blendmode = AST_MODULATE;
if (fastcmp(val, "fog"))
lines[i].blendmode = AST_FOG;
}
// Flags
else if (fastcmp(param, "blocking") && fastcmp("true", val))
lines[i].flags |= ML_IMPASSABLE;
else if (fastcmp(param, "blockplayers") && fastcmp("true", val))
lines[i].flags |= ML_BLOCKPLAYERS;
else if (fastcmp(param, "twosided") && fastcmp("true", val))
lines[i].flags |= ML_TWOSIDED;
else if (fastcmp(param, "dontpegtop") && fastcmp("true", val))
lines[i].flags |= ML_DONTPEGTOP;
else if (fastcmp(param, "dontpegbottom") && fastcmp("true", val))
lines[i].flags |= ML_DONTPEGBOTTOM;
else if (fastcmp(param, "skewtd") && fastcmp("true", val))
lines[i].flags |= ML_SKEWTD;
else if (fastcmp(param, "noclimb") && fastcmp("true", val))
lines[i].flags |= ML_NOCLIMB;
else if (fastcmp(param, "noskew") && fastcmp("true", val))
lines[i].flags |= ML_NOSKEW;
else if (fastcmp(param, "midpeg") && fastcmp("true", val))
lines[i].flags |= ML_MIDPEG;
else if (fastcmp(param, "midsolid") && fastcmp("true", val))
lines[i].flags |= ML_MIDSOLID;
else if (fastcmp(param, "wrapmidtex") && fastcmp("true", val))
lines[i].flags |= ML_WRAPMIDTEX;
else if (fastcmp(param, "blockmonsters") && fastcmp("true", val))
lines[i].flags |= ML_BLOCKMONSTERS;
else if (fastcmp(param, "nonet") && fastcmp("true", val))
lines[i].flags |= ML_NONET;
else if (fastcmp(param, "netonly") && fastcmp("true", val))
lines[i].flags |= ML_NETONLY;
else if (fastcmp(param, "notbouncy") && fastcmp("true", val))
lines[i].flags |= ML_NOTBOUNCY;
else if (fastcmp(param, "transfer") && fastcmp("true", val))
lines[i].flags |= ML_TFERLINE;
// Activation flags
else if (fastcmp(param, "repeatspecial") && fastcmp("true", val))
lines[i].activation |= SPAC_REPEATSPECIAL;
else if (fastcmp(param, "playercross") && fastcmp("true", val))
lines[i].activation |= SPAC_CROSS;
else if (fastcmp(param, "monstercross") && fastcmp("true", val))
lines[i].activation |= SPAC_CROSSMONSTER;
else if (fastcmp(param, "missilecross") && fastcmp("true", val))
lines[i].activation |= SPAC_CROSSMISSILE;
else if (fastcmp(param, "playerpush") && fastcmp("true", val))
lines[i].activation |= SPAC_PUSH;
else if (fastcmp(param, "monsterpush") && fastcmp("true", val))
lines[i].activation |= SPAC_PUSHMONSTER;
else if (fastcmp(param, "impact") && fastcmp("true", val))
lines[i].activation |= SPAC_IMPACT;
else
ParseUserProperty(&lines[i].user, param, val);
}
static void ParseTextmapThingParameter(UINT32 i, const char *param, const char *val)
{
if (fastcmp(param, "id"))
mapthings[i].tid = atol(val);
else if (fastcmp(param, "x"))
mapthings[i].x = atol(val);
else if (fastcmp(param, "y"))
mapthings[i].y = atol(val);
else if (fastcmp(param, "height"))
mapthings[i].z = atol(val);
else if (fastcmp(param, "angle"))
mapthings[i].angle = atol(val);
else if (fastcmp(param, "pitch"))
mapthings[i].pitch = atol(val);
else if (fastcmp(param, "roll"))
mapthings[i].roll = atol(val);
else if (fastcmp(param, "type"))
mapthings[i].type = atol(val);
else if (fastcmp(param, "scale"))
{
if (udmf_version < 1)
{
mapthings[i].scale = FLOAT_TO_FIXED(atof(val));
}
else
{
mapthings[i].spritexscale = mapthings[i].spriteyscale = FLOAT_TO_FIXED(atof(val));
}
}
else if (fastcmp(param, "scalex"))
{
if (udmf_version < 1)
{
mapthings[i].scale = FLOAT_TO_FIXED(atof(val));
}
else
{
mapthings[i].spritexscale = FLOAT_TO_FIXED(atof(val));
}
}
else if (fastcmp(param, "scaley"))
{
if (udmf_version < 1)
{
mapthings[i].scale = FLOAT_TO_FIXED(atof(val));
}
else
{
mapthings[i].spriteyscale = FLOAT_TO_FIXED(atof(val));
}
}
else if (fastcmp(param, "mobjscale"))
mapthings[i].scale = FLOAT_TO_FIXED(atof(val));
// Flags
else if (fastcmp(param, "flip") && fastcmp("true", val))
mapthings[i].options |= MTF_OBJECTFLIP;
else if (fastcmp(param, "special"))
mapthings[i].special = atol(val);
else if (fastcmp(param, "foflayer"))
mapthings[i].layer = atol(val);
else if (fastncmp(param, "stringarg", 9) && strlen(param) > 9)
{
if (udmf_version < 1)
{
size_t argnum = atol(param + 9);
if (argnum >= NUM_MAPTHING_STRINGARGS)
return;
size_t len = strlen(val);
mapthings[i].thing_stringargs[argnum] = static_cast<char*>(Z_Malloc(len + 1, PU_LEVEL, NULL));
M_Memcpy(mapthings[i].thing_stringargs[argnum], val, len);
mapthings[i].thing_stringargs[argnum][len] = '\0';
}
else
{
size_t argnum = atol(param + 9);
if (argnum >= NUM_SCRIPT_STRINGARGS)
return;
size_t len = strlen(val);
mapthings[i].script_stringargs[argnum] = static_cast<char*>(Z_Malloc(len + 1, PU_LEVEL, NULL));
M_Memcpy(mapthings[i].script_stringargs[argnum], val, len);
mapthings[i].script_stringargs[argnum][len] = '\0';
}
}
else if (fastncmp(param, "arg", 3) && strlen(param) > 3)
{
if (udmf_version < 1)
{
size_t argnum = atol(param + 3);
if (argnum >= NUM_MAPTHING_ARGS)
return;
mapthings[i].thing_args[argnum] = atol(val);
}
else
{
size_t argnum = atol(param + 3);
if (argnum >= NUM_SCRIPT_ARGS)
return;
mapthings[i].script_args[argnum] = atol(val);
}
}
else if (fastncmp(param, "thingstringarg", 14) && strlen(param) > 14)
{
size_t argnum = atol(param + 14);
if (argnum >= NUM_MAPTHING_STRINGARGS)
return;
size_t len = strlen(val);
mapthings[i].thing_stringargs[argnum] = static_cast<char*>(Z_Malloc(len + 1, PU_LEVEL, NULL));
M_Memcpy(mapthings[i].thing_stringargs[argnum], val, len);
mapthings[i].thing_stringargs[argnum][len] = '\0';
}
else if (fastncmp(param, "thingarg", 8) && strlen(param) > 8)
{
size_t argnum = atol(param + 8);
if (argnum >= NUM_MAPTHING_ARGS)
return;
mapthings[i].thing_args[argnum] = atol(val);
}
else
ParseUserProperty(&mapthings[i].user, param, val);
}
/** From a given position table, run a specified parser function through a {}-encapsuled text.
*
* \param Position of the data to parse, in the textmap.
* \param Structure number (mapthings, sectors, ...).
* \param Parser function pointer.
*/
static void TextmapParse(UINT32 dataPos, size_t num, void (*parser)(UINT32, const char *, const char *))
{
const char *param, *val;
M_TokenizerSetEndPos(dataPos);
param = M_TokenizerRead(0);
if (!fastcmp(param, "{"))
{
CONS_Alert(CONS_WARNING, "Invalid UDMF data capsule!\n");
return;
}
while (true)
{
param = M_TokenizerRead(0);
if (fastcmp(param, "}"))
break;
val = M_TokenizerRead(1);
parser(num, param, val);
}
}
/** Provides a fix to the flat alignment coordinate transform from standard Textmaps.
*/
static void TextmapFixFlatOffsets(sector_t *sec)
{
if (sec->floorpic_angle)
{
fixed_t pc = FINECOSINE(sec->floorpic_angle>>ANGLETOFINESHIFT);
fixed_t ps = FINESINE (sec->floorpic_angle>>ANGLETOFINESHIFT);
fixed_t xoffs = sec->floor_xoffs;
fixed_t yoffs = sec->floor_yoffs;
sec->floor_xoffs = (FixedMul(xoffs, pc) % MAXFLATSIZE) - (FixedMul(yoffs, ps) % MAXFLATSIZE);
sec->floor_yoffs = (FixedMul(xoffs, ps) % MAXFLATSIZE) + (FixedMul(yoffs, pc) % MAXFLATSIZE);
}
if (sec->ceilingpic_angle)
{
fixed_t pc = FINECOSINE(sec->ceilingpic_angle>>ANGLETOFINESHIFT);
fixed_t ps = FINESINE (sec->ceilingpic_angle>>ANGLETOFINESHIFT);
fixed_t xoffs = sec->ceiling_xoffs;
fixed_t yoffs = sec->ceiling_yoffs;
sec->ceiling_xoffs = (FixedMul(xoffs, pc) % MAXFLATSIZE) - (FixedMul(yoffs, ps) % MAXFLATSIZE);
sec->ceiling_yoffs = (FixedMul(xoffs, ps) % MAXFLATSIZE) + (FixedMul(yoffs, pc) % MAXFLATSIZE);
}
}
static void TextmapUnfixFlatOffsets(sector_t *sec)
{
if (sec->floorpic_angle)
{
fixed_t pc = FINECOSINE(sec->floorpic_angle>>ANGLETOFINESHIFT);
fixed_t ps = -FINESINE (sec->floorpic_angle>>ANGLETOFINESHIFT);
fixed_t xoffs = sec->floor_xoffs;
fixed_t yoffs = sec->floor_yoffs;
sec->floor_xoffs = (FixedMul(xoffs, pc) % MAXFLATSIZE) - (FixedMul(yoffs, ps) % MAXFLATSIZE);
sec->floor_yoffs = (FixedMul(xoffs, ps) % MAXFLATSIZE) + (FixedMul(yoffs, pc) % MAXFLATSIZE);
}
if (sec->ceilingpic_angle)
{
fixed_t pc = FINECOSINE(sec->ceilingpic_angle>>ANGLETOFINESHIFT);
fixed_t ps = -FINESINE (sec->ceilingpic_angle>>ANGLETOFINESHIFT);
fixed_t xoffs = sec->ceiling_xoffs;
fixed_t yoffs = sec->ceiling_yoffs;
sec->ceiling_xoffs = (FixedMul(xoffs, pc) % MAXFLATSIZE) - (FixedMul(yoffs, ps) % MAXFLATSIZE);
sec->ceiling_yoffs = (FixedMul(xoffs, ps) % MAXFLATSIZE) + (FixedMul(yoffs, pc) % MAXFLATSIZE);
}
}
static INT32 P_ColorToRGBA(INT32 color, UINT8 alpha)
{
UINT8 r = (color >> 16) & 0xFF;
UINT8 g = (color >> 8) & 0xFF;
UINT8 b = color & 0xFF;
return R_PutRgbaRGBA(r, g, b, alpha);
}
static INT32 P_RGBAToColor(INT32 rgba)
{
UINT8 r = R_GetRgbaR(rgba);
UINT8 g = R_GetRgbaG(rgba);
UINT8 b = R_GetRgbaB(rgba);
return (r << 16) | (g << 8) | b;
}
static void TextmapWriteSlopeConstants(FILE *f, sector_t *sec)
{
if (sec->f_slope != NULL)
{
const pslope_t *slope = sec->f_slope;
fprintf(f, "floorplane_a = %f;\n", FIXED_TO_FLOAT(slope->constants[0]));
fprintf(f, "floorplane_b = %f;\n", FIXED_TO_FLOAT(slope->constants[1]));
fprintf(f, "floorplane_c = %f;\n", FIXED_TO_FLOAT(slope->constants[2]));
fprintf(f, "floorplane_d = %f;\n", FIXED_TO_FLOAT(slope->constants[3]));
}
if (sec->c_slope != NULL)
{
const pslope_t *slope = sec->c_slope;
fprintf(f, "ceilingplane_a = %f;\n", FIXED_TO_FLOAT(slope->constants[0]));
fprintf(f, "ceilingplane_b = %f;\n", FIXED_TO_FLOAT(slope->constants[1]));
fprintf(f, "ceilingplane_c = %f;\n", FIXED_TO_FLOAT(slope->constants[2]));
fprintf(f, "ceilingplane_d = %f;\n", FIXED_TO_FLOAT(slope->constants[3]));
}
}
typedef struct
{
mapthing_t *teleport;
mapthing_t *altview;
mapthing_t *angleanchor;
} sectorspecialthings_t;
static boolean P_CanWriteTextmap(void)
{
return roundqueue.writetextmap == true && roundqueue.size > 0;
}
static FILE *P_OpenTextmap(const char *mode, const char *error)
{
FILE *f;
char *filepath = va("%s" PATHSEP "TEXTMAP.%s.txt", srb2home, mapheaderinfo[gamemap-1]->lumpname);
f = fopen(filepath, mode);
if (!f)
{
CONS_Alert(CONS_ERROR, M_GetText("%s %s\n"), error, filepath);
}
return f;
}
static void P_WriteTextmapThing(FILE *f, mapthing_t *wmapthings, size_t i, size_t k)
{
size_t j;
fprintf(f, "thing // %s\n", sizeu1(k));
fprintf(f, "{\n");
if (wmapthings[i].tid != 0)
fprintf(f, "id = %d;\n", wmapthings[i].tid);
fprintf(f, "x = %d;\n", wmapthings[i].x);
fprintf(f, "y = %d;\n", wmapthings[i].y);
if (wmapthings[i].z != 0)
fprintf(f, "height = %d;\n", wmapthings[i].z);
fprintf(f, "angle = %d;\n", wmapthings[i].angle);
if (wmapthings[i].pitch != 0)
fprintf(f, "pitch = %d;\n", wmapthings[i].pitch);
if (wmapthings[i].roll != 0)
fprintf(f, "roll = %d;\n", wmapthings[i].roll);
if (wmapthings[i].type != 0)
fprintf(f, "type = %d;\n", wmapthings[i].type);
if (wmapthings[i].spritexscale != FRACUNIT)
fprintf(f, "scalex = %f;\n", FIXED_TO_FLOAT(wmapthings[i].spritexscale));
if (wmapthings[i].spriteyscale != FRACUNIT)
fprintf(f, "scaley = %f;\n", FIXED_TO_FLOAT(wmapthings[i].spriteyscale));
if (wmapthings[i].scale != FRACUNIT)
fprintf(f, "mobjscale = %f;\n", FIXED_TO_FLOAT(wmapthings[i].scale));
if (wmapthings[i].options & MTF_OBJECTFLIP)
fprintf(f, "flip = true;\n");
if (wmapthings[i].special != 0)
fprintf(f, "special = %d;\n", wmapthings[i].special);
for (j = 0; j < NUM_SCRIPT_ARGS; j++)
if (wmapthings[i].script_args[j] != 0)
fprintf(f, "arg%s = %d;\n", sizeu1(j), wmapthings[i].script_args[j]);
for (j = 0; j < NUM_SCRIPT_STRINGARGS; j++)
if (mapthings[i].script_stringargs[j])
fprintf(f, "stringarg%s = \"%s\";\n", sizeu1(j), mapthings[i].script_stringargs[j]);
for (j = 0; j < NUM_MAPTHING_ARGS; j++)
if (wmapthings[i].thing_args[j] != 0)
fprintf(f, "thingarg%s = %d;\n", sizeu1(j), wmapthings[i].thing_args[j]);
for (j = 0; j < NUM_MAPTHING_STRINGARGS; j++)
if (mapthings[i].thing_stringargs[j])
fprintf(f, "thingstringarg%s = \"%s\";\n", sizeu1(j), mapthings[i].thing_stringargs[j]);
if (wmapthings[i].user.length > 0)
{
for (j = 0; j < wmapthings[i].user.length; j++)
{
mapUserProperty_t *const prop = &wmapthings[i].user.properties[j];
switch (prop->type)
{
case USER_PROP_BOOL:
fprintf(f, "user_%s = %s;\n", prop->key, (prop->valueBool == true) ? "true" : "false");
break;
case USER_PROP_INT:
fprintf(f, "user_%s = %d;\n", prop->key, prop->valueInt);
break;
case USER_PROP_FIXED:
fprintf(f, "user_%s = %f;\n", prop->key, FIXED_TO_FLOAT(prop->valueFixed));
break;
case USER_PROP_STR:
fprintf(f, "user_%s = \"%s\";\n", prop->key, prop->valueStr);
break;
}
}
}
fprintf(f, "}\n");
fprintf(f, "\n");
}
static void P_WriteTextmap(void)
{
size_t i, j, k;
FILE *f;
mtag_t firsttag;
mapthing_t *wmapthings;
vertex_t *wvertexes;
sector_t *wsectors;
line_t *wlines;
side_t *wsides;
mtag_t freetag;
sectorspecialthings_t *specialthings;
boolean *wusedvertexes;
f = P_OpenTextmap("w", "Couldn't save map file");
if (!f)
{
return;
}
wmapthings = static_cast<mapthing_t*>(Z_Calloc(nummapthings * sizeof(*mapthings), PU_LEVEL, NULL));
wvertexes = static_cast<vertex_t*>(Z_Calloc(num_orig_vertexes * sizeof(*vertexes), PU_LEVEL, NULL));
wsectors = static_cast<sector_t*>(Z_Calloc(numsectors * sizeof(*sectors), PU_LEVEL, NULL));
wlines = static_cast<line_t*>(Z_Calloc(numlines * sizeof(*lines), PU_LEVEL, NULL));
wsides = static_cast<side_t*>(Z_Calloc(numsides * sizeof(*sides), PU_LEVEL, NULL));
specialthings = static_cast<sectorspecialthings_t*>(Z_Calloc(numsectors * sizeof(*sectors), PU_LEVEL, NULL));
wusedvertexes = static_cast<boolean*>(Z_Calloc(num_orig_vertexes * sizeof(boolean), PU_LEVEL, NULL));
memcpy(wmapthings, mapthings, nummapthings * sizeof(*mapthings));
memcpy(wvertexes, vertexes, num_orig_vertexes * sizeof(*vertexes));
memcpy(wsectors, sectors, numsectors * sizeof(*sectors));
memcpy(wlines, lines, numlines * sizeof(*lines));
memcpy(wsides, sides, numsides * sizeof(*sides));
for (i = 0; i < nummapthings; i++)
{
if (mapthings[i].user.length)
{
wmapthings[i].user.properties = static_cast<mapUserProperty_t*>(memcpy(
Z_Malloc(mapthings[i].user.length * sizeof(mapUserProperty_t), PU_LEVEL, NULL),
mapthings[i].user.properties,
mapthings[i].user.length * sizeof(mapUserProperty_t)
));
}
}
for (i = 0; i < numsectors; i++)
{
if (sectors[i].tags.count)
wsectors[i].tags.tags = static_cast<mtag_t*>(memcpy(Z_Malloc(sectors[i].tags.count*sizeof(mtag_t), PU_LEVEL, NULL), sectors[i].tags.tags, sectors[i].tags.count*sizeof(mtag_t)));
if (sectors[i].user.length)
{
wsectors[i].user.properties = static_cast<mapUserProperty_t*>(memcpy(
Z_Malloc(sectors[i].user.length * sizeof(mapUserProperty_t), PU_LEVEL, NULL),
sectors[i].user.properties,
sectors[i].user.length * sizeof(mapUserProperty_t)
));
}
}
for (i = 0; i < numlines; i++)
{
size_t v;
if (lines[i].tags.count)
wlines[i].tags.tags = static_cast<mtag_t*>(memcpy(Z_Malloc(lines[i].tags.count * sizeof(mtag_t), PU_LEVEL, NULL), lines[i].tags.tags, lines[i].tags.count * sizeof(mtag_t)));
if (lines[i].user.length)
{
wlines[i].user.properties = static_cast<mapUserProperty_t*>(memcpy(
Z_Malloc(lines[i].user.length * sizeof(mapUserProperty_t), PU_LEVEL, NULL),
lines[i].user.properties,
lines[i].user.length * sizeof(mapUserProperty_t)
));
}
v = lines[i].v1 - vertexes;
wusedvertexes[v] = true;
v = lines[i].v2 - vertexes;
wusedvertexes[v] = true;
}
for (i = 0; i < numsides; i++)
{
if (sides[i].user.length)
{
wsides[i].user.properties = static_cast<mapUserProperty_t*>(memcpy(
Z_Malloc(sides[i].user.length * sizeof(mapUserProperty_t), PU_LEVEL, NULL),
sides[i].user.properties,
sides[i].user.length * sizeof(mapUserProperty_t)
));
}
}
if (!udmf)
{
freetag = Tag_NextUnused(0);
for (i = 0; i < nummapthings; i++)
{
subsector_t *ss;
INT32 s;
if (wmapthings[i].type != 751 && wmapthings[i].type != 752 && wmapthings[i].type != 758)
continue;
ss = R_PointInSubsector(wmapthings[i].x << FRACBITS, wmapthings[i].y << FRACBITS);
if (!ss)
continue;
s = ss->sector - sectors;
switch (wmapthings[i].type)
{
case 751:
if (!specialthings[s].teleport)
specialthings[s].teleport = &wmapthings[i];
break;
case 752:
if (!specialthings[s].altview)
specialthings[s].altview = &wmapthings[i];
break;
case 758:
if (!specialthings[s].angleanchor)
specialthings[s].angleanchor = &wmapthings[i];
break;
default:
break;
}
}
for (i = 0; i < numlines; i++)
{
INT32 s;
switch (wlines[i].special)
{
case 1:
TAG_ITER_SECTORS(Tag_FGet(&wlines[i].tags), s)
{
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s applies custom gravity to sector %d. Changes to this gravity at runtime will not be reflected in the converted map. Use linedef type 469 for this.\n"), sizeu1(i), s);
wsectors[s].gravity = FixedDiv(lines[i].frontsector->floorheight >> FRACBITS, 1000);
}
break;
case 2:
CONS_Alert(CONS_WARNING, M_GetText("Custom exit linedef %s detected. Changes to the next map at runtime will not be reflected in the converted map. Use linedef type 468 for this.\n"), sizeu1(i));
wlines[i].args[0] = lines[i].frontsector->floorheight >> FRACBITS;
wlines[i].args[2] = lines[i].frontsector->ceilingheight >> FRACBITS;
break;
case 5:
case 50:
case 51:
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s has type %d, which is not supported in UDMF.\n"), sizeu1(i), wlines[i].special);
break;
case 61:
if (wlines[i].flags & ML_MIDSOLID)
continue;
if (!wlines[i].args[1])
continue;
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s with crusher type 61 rises twice as fast on spawn. This behavior is not supported in UDMF.\n"), sizeu1(i));
break;
case 76:
if (freetag == (mtag_t)MAXTAGS)
{
CONS_Alert(CONS_WARNING, M_GetText("No unused tag found. Linedef %s with type 76 cannot be converted.\n"), sizeu1(i));
break;
}
TAG_ITER_SECTORS(wlines[i].args[0], s)
for (j = 0; (unsigned)j < wsectors[s].linecount; j++)
{
line_t *line = wsectors[s].lines[j] - lines + wlines;
if (line->special < 100 || line->special >= 300)
continue;
Tag_Add(&line->tags, freetag);
}
wlines[i].args[0] = freetag;
freetag = Tag_NextUnused(freetag);
break;
case 259:
if (wlines[i].args[3] & FOF_QUICKSAND)
CONS_Alert(CONS_WARNING, M_GetText("Quicksand properties of custom FOF on linedef %s cannot be converted. Use linedef type 75 instead.\n"), sizeu1(i));
if (wlines[i].args[3] & FOF_BUSTUP)
CONS_Alert(CONS_WARNING, M_GetText("Bustable properties of custom FOF on linedef %s cannot be converted. Use linedef type 74 instead.\n"), sizeu1(i));
break;
case 412:
if ((s = Tag_Iterate_Sectors(wlines[i].args[0], 0)) < 0)
break;
if (!specialthings[s].teleport)
break;
if (freetag == (mtag_t)MAXTAGS)
{
CONS_Alert(CONS_WARNING, M_GetText("No unused tag found. Linedef %s with type 412 cannot be converted.\n"), sizeu1(i));
break;
}
specialthings[s].teleport->tid = freetag;
wlines[i].args[0] = freetag;
freetag = Tag_NextUnused(freetag);
break;
case 422:
if ((s = Tag_Iterate_Sectors(wlines[i].args[0], 0)) < 0)
break;
if (!specialthings[s].altview)
break;
if (freetag == (mtag_t)MAXTAGS)
{
CONS_Alert(CONS_WARNING, M_GetText("No unused tag found. Linedef %s with type 422 cannot be converted.\n"), sizeu1(i));
break;
}
specialthings[s].altview->tid = freetag;
wlines[i].args[0] = freetag;
specialthings[s].altview->pitch = wlines[i].args[2];
freetag = Tag_NextUnused(freetag);
break;
case 447:
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s has change colormap action, which cannot be converted automatically. Tag arg0 to a sector with the desired colormap.\n"), sizeu1(i));
if (wlines[i].flags & ML_TFERLINE)
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s mixes front and back colormaps, which is not supported in UDMF. Copy one colormap to the target sector first, then mix in the second one.\n"), sizeu1(i));
break;
case 455:
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s has fade colormap action, which cannot be converted automatically. Tag arg0 to a sector with the desired colormap.\n"), sizeu1(i));
if (wlines[i].flags & ML_TFERLINE)
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s specifies starting colormap for the fade, which is not supported in UDMF. Change the colormap with linedef type 447 instead.\n"), sizeu1(i));
break;
case 457:
if ((s = Tag_Iterate_Sectors(wlines[i].args[0], 0)) < 0)
break;
if (!specialthings[s].angleanchor)
break;
if (freetag == (mtag_t)MAXTAGS)
{
CONS_Alert(CONS_WARNING, M_GetText("No unused tag found. Linedef %s with type 457 cannot be converted.\n"), sizeu1(i));
break;
}
specialthings[s].angleanchor->tid = freetag;
wlines[i].args[0] = freetag;
freetag = Tag_NextUnused(freetag);
break;
case 606:
if (wlines[i].args[0] == MTAG_GLOBAL)
{
sector_t *sec = wlines[i].frontsector - sectors + wsectors;
sec->extra_colormap = wsides[wlines[i].sidenum[0]].colormap_data;
}
else
{
TAG_ITER_SECTORS(wlines[i].args[0], s)
{
if (wsectors[s].colormap_protected)
continue;
wsectors[s].extra_colormap = wsides[wlines[i].sidenum[0]].colormap_data;
if (freetag == (mtag_t)MAXTAGS)
{
CONS_Alert(CONS_WARNING, M_GetText("No unused tag found. Linedef %s with type 606 cannot be converted.\n"), sizeu1(i));
break;
}
Tag_Add(&wsectors[s].tags, freetag);
wlines[i].args[1] = freetag;
freetag = Tag_NextUnused(freetag);
break;
}
}
break;
default:
break;
}
if (wlines[i].special >= 300 && wlines[i].special < 400)
{
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s is a linedef executor, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
wlines[i].special = 0;
}
if (wlines[i].executordelay != 0)
{
CONS_Alert(CONS_WARNING, M_GetText("Linedef %s has an linedef executor delay, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
}
}
for (i = 0; i < numsectors; i++)
{
if (Tag_Find(&wsectors[i].tags, LE_CAPSULE0))
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has reserved tag %d, which is not supported in UDMF. Use arg3 of the boss mapthing instead.\n"), sizeu1(i), LE_CAPSULE0);
if (Tag_Find(&wsectors[i].tags, LE_CAPSULE1))
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has reserved tag %d, which is not supported in UDMF. Use arg3 of the boss mapthing instead.\n"), sizeu1(i), LE_CAPSULE1);
if (Tag_Find(&wsectors[i].tags, LE_CAPSULE2))
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has reserved tag %d, which is not supported in UDMF. Use arg3 of the boss mapthing instead.\n"), sizeu1(i), LE_CAPSULE2);
switch (GETSECSPECIAL(wsectors[i].special, 1))
{
case 9:
case 10:
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has ring drainer effect, which is not supported in UDMF. Use action 460 instead.\n"), sizeu1(i));
break;
default:
break;
}
switch (GETSECSPECIAL(wsectors[i].special, 2))
{
case 6:
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has emerald check trigger type, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
break;
case 7:
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has NiGHTS mare trigger type, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
break;
case 9:
CONS_Alert(CONS_WARNING, M_GetText("Sector %s has Egg Capsule type, which is not supported in UDMF. Use action 464 instead.\n"), sizeu1(i));
break;
default:
break;
}
if (wsectors[i].triggertag)
{
CONS_Alert(CONS_WARNING, M_GetText("Sector %s uses a linedef executor trigger tag, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
}
if (wsectors[i].triggerer)
{
CONS_Alert(CONS_WARNING, M_GetText("Sector %s uses a linedef executor trigger effect, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
}
if ((wsectors[i].flags & (MSF_TRIGGERLINE_PLANE|MSF_TRIGGERLINE_MOBJ)) != 0)
{
CONS_Alert(CONS_WARNING, M_GetText("Sector %s uses a linedef executor trigger flag, which is not supported in UDMF. Use ACS instead.\n"), sizeu1(i));
}
}
}
fprintf(f, "namespace = \"ringracers\";\n");
fprintf(f, "version = %d;\n", UDMF_CURRENT_VERSION);
for (i = k = 0; i < nummapthings; i++)
{
if (!udmf)
{
if (wmapthings[i].type == mobjinfo[MT_WAYPOINT].doomednum
|| wmapthings[i].type == mobjinfo[MT_WAYPOINT_ANCHOR].doomednum
|| wmapthings[i].type == mobjinfo[MT_WAYPOINT_RISER].doomednum)
{
// Skip waypoints. Because the multi-thing setup was merged into a
// single thing type in UDMF, these must be converted later.
continue;
}
}
P_WriteTextmapThing(f, wmapthings, i, k);
k++;
}
j = 0;
for (i = 0; i < num_orig_vertexes; i++)
{
if (wusedvertexes[i] == false)
{
continue;
}
fprintf(f, "vertex // %s\n", sizeu1(j));
fprintf(f, "{\n");
fprintf(f, "x = %f;\n", FIXED_TO_FLOAT(wvertexes[j].x));
fprintf(f, "y = %f;\n", FIXED_TO_FLOAT(wvertexes[j].y));
if (wvertexes[j].floorzset)
fprintf(f, "zfloor = %f;\n", FIXED_TO_FLOAT(wvertexes[j].floorz));
if (wvertexes[j].ceilingzset)
fprintf(f, "zceiling = %f;\n", FIXED_TO_FLOAT(wvertexes[j].ceilingz));
fprintf(f, "}\n");
fprintf(f, "\n");
j++;
}
for (i = 0; i < numlines; i++)
{
fprintf(f, "linedef // %s\n", sizeu1(i));
fprintf(f, "{\n");
fprintf(f, "v1 = %s;\n", sizeu1(wlines[i].v1 - vertexes));
fprintf(f, "v2 = %s;\n", sizeu1(wlines[i].v2 - vertexes));
fprintf(f, "sidefront = %d;\n", wlines[i].sidenum[0]);
if (wlines[i].sidenum[1] != 0xffff)
fprintf(f, "sideback = %d;\n", wlines[i].sidenum[1]);
firsttag = Tag_FGet(&wlines[i].tags);
if (firsttag != 0)
fprintf(f, "id = %d;\n", firsttag);
if (wlines[i].tags.count > 1)
{
fprintf(f, "moreids = \"");
for (j = 1; j < wlines[i].tags.count; j++)
{
if (j > 1)
fprintf(f, " ");
fprintf(f, "%d", wlines[i].tags.tags[j]);
}
fprintf(f, "\";\n");
}
if (wlines[i].special != 0)
fprintf(f, "special = %d;\n", wlines[i].special);
for (j = 0; j < NUM_SCRIPT_ARGS; j++)
if (wlines[i].args[j] != 0)
fprintf(f, "arg%s = %d;\n", sizeu1(j), wlines[i].args[j]);
for (j = 0; j < NUM_SCRIPT_STRINGARGS; j++)
if (lines[i].stringargs[j])
fprintf(f, "stringarg%s = \"%s\";\n", sizeu1(j), lines[i].stringargs[j]);
if (wlines[i].alpha != FRACUNIT)
fprintf(f, "alpha = %f;\n", FIXED_TO_FLOAT(wlines[i].alpha));
if (wlines[i].blendmode != AST_COPY)
{
switch (wlines[i].blendmode)
{
case AST_ADD:
fprintf(f, "renderstyle = \"add\";\n");
break;
case AST_SUBTRACT:
fprintf(f, "renderstyle = \"subtract\";\n");
break;
case AST_REVERSESUBTRACT:
fprintf(f, "renderstyle = \"reversesubtract\";\n");
break;
case AST_MODULATE:
fprintf(f, "renderstyle = \"modulate\";\n");
break;
case AST_FOG:
fprintf(f, "renderstyle = \"fog\";\n");
break;
default:
break;
}
}
if (wlines[i].flags & ML_IMPASSABLE)
fprintf(f, "blocking = true;\n");
if (wlines[i].flags & ML_BLOCKPLAYERS)
fprintf(f, "blockplayers = true;\n");
if (wlines[i].flags & ML_BLOCKMONSTERS)
fprintf(f, "blockmonsters = true;\n");
if (wlines[i].flags & ML_TWOSIDED)
fprintf(f, "twosided = true;\n");
if (wlines[i].flags & ML_DONTPEGTOP)
fprintf(f, "dontpegtop = true;\n");
if (wlines[i].flags & ML_DONTPEGBOTTOM)
fprintf(f, "dontpegbottom = true;\n");
if (wlines[i].flags & ML_SKEWTD)
fprintf(f, "skewtd = true;\n");
if (wlines[i].flags & ML_NOCLIMB)
fprintf(f, "noclimb = true;\n");
if (wlines[i].flags & ML_NOSKEW)
fprintf(f, "noskew = true;\n");
if (wlines[i].flags & ML_MIDPEG)
fprintf(f, "midpeg = true;\n");
if (wlines[i].flags & ML_MIDSOLID)
fprintf(f, "midsolid = true;\n");
if (wlines[i].flags & ML_WRAPMIDTEX)
fprintf(f, "wrapmidtex = true;\n");
if (wlines[i].flags & ML_NONET)
fprintf(f, "nonet = true;\n");
if (wlines[i].flags & ML_NETONLY)
fprintf(f, "netonly = true;\n");
if (wlines[i].flags & ML_NOTBOUNCY)
fprintf(f, "notbouncy = true;\n");
if (wlines[i].flags & ML_TFERLINE)
fprintf(f, "transfer = true;\n");
if (wlines[i].activation & SPAC_REPEATSPECIAL)
fprintf(f, "repeatspecial = true;\n");
if (wlines[i].activation & SPAC_CROSS)
fprintf(f, "playercross = true;\n");
if (wlines[i].activation & SPAC_CROSSMONSTER)
fprintf(f, "monstercross = true;\n");
if (wlines[i].activation & SPAC_CROSSMISSILE)
fprintf(f, "missilecross = true;\n");
if (wlines[i].activation & SPAC_PUSH)
fprintf(f, "playerpush = true;\n");
if (wlines[i].activation & SPAC_PUSHMONSTER)
fprintf(f, "monsterpush = true;\n");
if (wlines[i].activation & SPAC_IMPACT)
fprintf(f, "impact = true;\n");
if (wlines[i].user.length > 0)
{
for (j = 0; j < wlines[i].user.length; j++)
{
mapUserProperty_t *const prop = &wlines[i].user.properties[j];
switch (prop->type)
{
case USER_PROP_BOOL:
fprintf(f, "user_%s = %s;\n", prop->key, (prop->valueBool == true) ? "true" : "false");
break;
case USER_PROP_INT:
fprintf(f, "user_%s = %d;\n", prop->key, prop->valueInt);
break;
case USER_PROP_FIXED:
fprintf(f, "user_%s = %f;\n", prop->key, FIXED_TO_FLOAT(prop->valueFixed));
break;
case USER_PROP_STR:
fprintf(f, "user_%s = \"%s\";\n", prop->key, prop->valueStr);
break;
}
}
}
fprintf(f, "}\n");
fprintf(f, "\n");
}
for (i = 0; i < numsides; i++)
{
fprintf(f, "sidedef // %s\n", sizeu1(i));
fprintf(f, "{\n");
fprintf(f, "sector = %s;\n", sizeu1(wsides[i].sector - sectors));
if (wsides[i].textureoffset != 0)
fprintf(f, "offsetx = %d;\n", wsides[i].textureoffset >> FRACBITS);
if (wsides[i].rowoffset != 0)
fprintf(f, "offsety = %d;\n", wsides[i].rowoffset >> FRACBITS);
if (wsides[i].toptexture > 0 && wsides[i].toptexture < numtextures)
fprintf(f, "texturetop = \"%.*s\";\n", 8, textures[wsides[i].toptexture]->name);
if (wsides[i].bottomtexture > 0 && wsides[i].bottomtexture < numtextures)
fprintf(f, "texturebottom = \"%.*s\";\n", 8, textures[wsides[i].bottomtexture]->name);
if (wsides[i].midtexture > 0 && wsides[i].midtexture < numtextures)
fprintf(f, "texturemiddle = \"%.*s\";\n", 8, textures[wsides[i].midtexture]->name);
if (wsides[i].repeatcnt != 0)
fprintf(f, "repeatcnt = %d;\n", wsides[i].repeatcnt);
if (wsides[i].user.length > 0)
{
for (j = 0; j < wsides[i].user.length; j++)
{
mapUserProperty_t *const prop = &wsides[i].user.properties[j];
switch (prop->type)
{
case USER_PROP_BOOL:
fprintf(f, "user_%s = %s;\n", prop->key, (prop->valueBool == true) ? "true" : "false");
break;
case USER_PROP_INT:
fprintf(f, "user_%s = %d;\n", prop->key, prop->valueInt);
break;
case USER_PROP_FIXED:
fprintf(f, "user_%s = %f;\n", prop->key, FIXED_TO_FLOAT(prop->valueFixed));
break;
case USER_PROP_STR:
fprintf(f, "user_%s = \"%s\";\n", prop->key, prop->valueStr);
break;
}
}
}
fprintf(f, "}\n");
fprintf(f, "\n");
}
for (i = 0; i < numsectors; i++)
{
fprintf(f, "sector // %s\n", sizeu1(i));
fprintf(f, "{\n");
fprintf(f, "heightfloor = %d;\n", wsectors[i].floorheight >> FRACBITS);
fprintf(f, "heightceiling = %d;\n", wsectors[i].ceilingheight >> FRACBITS);
if (wsectors[i].floorpic != -1)
fprintf(f, "texturefloor = \"%s\";\n", levelflats[wsectors[i].floorpic].name);
if (wsectors[i].ceilingpic != -1)
fprintf(f, "textureceiling = \"%s\";\n", levelflats[wsectors[i].ceilingpic].name);
fprintf(f, "lightlevel = %d;\n", wsectors[i].lightlevel);
if (wsectors[i].floorlightlevel != 0)
fprintf(f, "lightfloor = %d;\n", wsectors[i].floorlightlevel);
if (wsectors[i].floorlightabsolute)
fprintf(f, "lightfloorabsolute = true;\n");
if (wsectors[i].ceilinglightlevel != 0)
fprintf(f, "lightceiling = %d;\n", wsectors[i].ceilinglightlevel);
if (wsectors[i].ceilinglightabsolute)
fprintf(f, "lightceilingabsolute = true;\n");
firsttag = Tag_FGet(&wsectors[i].tags);
if (firsttag != 0)
fprintf(f, "id = %d;\n", firsttag);
if (wsectors[i].tags.count > 1)
{
fprintf(f, "moreids = \"");
for (j = 1; j < wsectors[i].tags.count; j++)
{
if (j > 1)
fprintf(f, " ");
fprintf(f, "%d", wsectors[i].tags.tags[j]);
}
fprintf(f, "\";\n");
}
sector_t tempsec = wsectors[i];
TextmapUnfixFlatOffsets(&tempsec);
if (tempsec.floor_xoffs != 0)
fprintf(f, "xpanningfloor = %f;\n", FIXED_TO_FLOAT(tempsec.floor_xoffs));
if (tempsec.floor_yoffs != 0)
fprintf(f, "ypanningfloor = %f;\n", FIXED_TO_FLOAT(tempsec.floor_yoffs));
if (tempsec.ceiling_xoffs != 0)
fprintf(f, "xpanningceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceiling_xoffs));
if (tempsec.ceiling_yoffs != 0)
fprintf(f, "ypanningceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceiling_yoffs));
if (wsectors[i].floorpic_angle != 0)
fprintf(f, "rotationfloor = %f;\n", FIXED_TO_FLOAT(AngleFixed(wsectors[i].floorpic_angle)));
if (wsectors[i].ceilingpic_angle != 0)
fprintf(f, "rotationceiling = %f;\n", FIXED_TO_FLOAT(AngleFixed(wsectors[i].ceilingpic_angle)));
if (wsectors[i].extra_colormap)
{
INT32 lightcolor = P_RGBAToColor(wsectors[i].extra_colormap->rgba);
UINT8 lightalpha = R_GetRgbaA(wsectors[i].extra_colormap->rgba);
INT32 fadecolor = P_RGBAToColor(wsectors[i].extra_colormap->fadergba);
UINT8 fadealpha = R_GetRgbaA(wsectors[i].extra_colormap->fadergba);
if (lightcolor != 0)
fprintf(f, "lightcolor = %d;\n", lightcolor);
if (lightalpha != 25)
fprintf(f, "lightalpha = %d;\n", lightalpha);
if (fadecolor != 0)
fprintf(f, "fadecolor = %d;\n", fadecolor);
if (fadealpha != 25)
fprintf(f, "fadealpha = %d;\n", fadealpha);
if (wsectors[i].extra_colormap->fadestart != 0)
fprintf(f, "fadestart = %d;\n", wsectors[i].extra_colormap->fadestart);
if (wsectors[i].extra_colormap->fadeend != 31)
fprintf(f, "fadeend = %d;\n", wsectors[i].extra_colormap->fadeend);
if (wsectors[i].extra_colormap->flags & CMF_FOG)
fprintf(f, "colormapfog = true;\n");
if (wsectors[i].extra_colormap->flags & CMF_FADEFULLBRIGHTSPRITES)
fprintf(f, "colormapfadesprites = true;\n");
}
if (wsectors[i].colormap_protected)
fprintf(f, "colormapprotected = true;\n");
if (!(wsectors[i].flags & MSF_FLIPSPECIAL_FLOOR))
fprintf(f, "flipspecial_nofloor = true;\n");
if (wsectors[i].flags & MSF_FLIPSPECIAL_CEILING)
fprintf(f, "flipspecial_ceiling = true;\n");
if (wsectors[i].flags & MSF_TRIGGERSPECIAL_TOUCH)
fprintf(f, "triggerspecial_touch = true;\n");
if (wsectors[i].flags & MSF_TRIGGERSPECIAL_HEADBUMP)
fprintf(f, "triggerspecial_headbump = true;\n");
if (wsectors[i].flags & MSF_INVERTPRECIP)
fprintf(f, "invertprecip = true;\n");
if (wsectors[i].flags & MSF_GRAVITYFLIP)
fprintf(f, "gravityflip = true;\n");
if (wsectors[i].flags & MSF_HEATWAVE)
fprintf(f, "heatwave = true;\n");
if (wsectors[i].flags & MSF_NOCLIPCAMERA)
fprintf(f, "noclipcamera = true;\n");
if (wsectors[i].flags & MSF_RIPPLE_FLOOR)
fprintf(f, "ripple_floor = true;\n");
if (wsectors[i].flags & MSF_RIPPLE_CEILING)
fprintf(f, "ripple_ceiling = true;\n");
if (wsectors[i].flags & MSF_INVERTENCORE)
fprintf(f, "invertencore = true;\n");
if (wsectors[i].specialflags & SSF_NOSTEPUP)
fprintf(f, "nostepup = true;\n");
if (wsectors[i].specialflags & SSF_DOUBLESTEPUP)
fprintf(f, "doublestepup = true;\n");
if (wsectors[i].specialflags & SSF_NOSTEPDOWN)
fprintf(f, "nostepdown = true;\n");
if (wsectors[i].specialflags & SSF_CHEATCHECKACTIVATOR)
fprintf(f, "cheatcheckactivator = true;\n");
if (wsectors[i].specialflags & SSF_EXIT)
fprintf(f, "exit = true;\n");
if (wsectors[i].specialflags & SSF_DELETEITEMS)
fprintf(f, "deleteitems = true;\n");
if (wsectors[i].specialflags & SSF_FAN)
fprintf(f, "fan = true;\n");
if (wsectors[i].specialflags & SSF_ZOOMTUBESTART)
fprintf(f, "zoomtubestart = true;\n");
if (wsectors[i].specialflags & SSF_ZOOMTUBEEND)
fprintf(f, "zoomtubeend = true;\n");
if (wsectors[i].friction != ORIG_FRICTION)
fprintf(f, "friction = %f;\n", FIXED_TO_FLOAT(wsectors[i].friction));
if (wsectors[i].gravity != FRACUNIT)
fprintf(f, "gravity = %f;\n", FIXED_TO_FLOAT(wsectors[i].gravity));
if (wsectors[i].damagetype != SD_NONE)
{
switch (wsectors[i].damagetype)
{
case SD_GENERIC:
fprintf(f, "damagetype = \"Generic\";\n");
break;
case SD_LAVA:
fprintf(f, "damagetype = \"Lava\";\n");
break;
case SD_DEATHPIT:
fprintf(f, "damagetype = \"DeathPit\";\n");
break;
case SD_INSTAKILL:
fprintf(f, "damagetype = \"Instakill\";\n");
break;
case SD_STUMBLE:
fprintf(f, "damagetype = \"Stumble\";\n");
break;
default:
break;
}
}
TextmapWriteSlopeConstants(f, &wsectors[i]);
if (wsectors[i].action != 0)
fprintf(f, "action = %d;\n", wsectors[i].action);
for (j = 0; j < NUM_SCRIPT_ARGS; j++)
if (wsectors[i].args[j] != 0)
fprintf(f, "arg%s = %d;\n", sizeu1(j), wsectors[i].args[j]);
for (j = 0; j < NUM_SCRIPT_STRINGARGS; j++)
if (wsectors[i].stringargs[j])
fprintf(f, "stringarg%s = \"%s\";\n", sizeu1(j), wsectors[i].stringargs[j]);
switch (wsectors[i].activation & SECSPAC_TRIGGERMASK)
{
case SECSPAC_REPEATSPECIAL:
{
fprintf(f, "repeatspecial = true;\n");
break;
}
case SECSPAC_CONTINUOUSSPECIAL:
{
fprintf(f, "continuousspecial = true;\n");
break;
}
}
if (wsectors[i].activation & SECSPAC_ENTER)
fprintf(f, "playerenter = true;\n");
if (wsectors[i].activation & SECSPAC_FLOOR)
fprintf(f, "playerfloor = true;\n");
if (wsectors[i].activation & SECSPAC_CEILING)
fprintf(f, "playerceiling = true;\n");
if (wsectors[i].activation & SECSPAC_ENTERMONSTER)
fprintf(f, "monsterenter = true;\n");
if (wsectors[i].activation & SECSPAC_FLOORMONSTER)
fprintf(f, "monsterfloor = true;\n");
if (wsectors[i].activation & SECSPAC_CEILINGMONSTER)
fprintf(f, "monsterceiling = true;\n");
if (wsectors[i].activation & SECSPAC_ENTERMISSILE)
fprintf(f, "missileenter = true;\n");
if (wsectors[i].activation & SECSPAC_FLOORMISSILE)
fprintf(f, "missilefloor = true;\n");
if (wsectors[i].activation & SECSPAC_CEILINGMISSILE)
fprintf(f, "missileceiling = true;\n");
if (wsectors[i].user.length > 0)
{
for (j = 0; j < wsectors[i].user.length; j++)
{
mapUserProperty_t *const prop = &wsectors[i].user.properties[j];
switch (prop->type)
{
case USER_PROP_BOOL:
fprintf(f, "user_%s = %s;\n", prop->key, (prop->valueBool == true) ? "true" : "false");
break;
case USER_PROP_INT:
fprintf(f, "user_%s = %d;\n", prop->key, prop->valueInt);
break;
case USER_PROP_FIXED:
fprintf(f, "user_%s = %f;\n", prop->key, FIXED_TO_FLOAT(prop->valueFixed));
break;
case USER_PROP_STR:
fprintf(f, "user_%s = \"%s\";\n", prop->key, prop->valueStr);
break;
}
}
}
fprintf(f, "}\n");
fprintf(f, "\n");
}
fclose(f);
for (i = 0; i < nummapthings; i++)
{
if (wmapthings[i].user.length)
Z_Free(wmapthings[i].user.properties);
}
for (i = 0; i < numsectors; i++)
{
if (wsectors[i].tags.count)
Z_Free(wsectors[i].tags.tags);
if (wsectors[i].user.length)
Z_Free(wsectors[i].user.properties);
}
for (i = 0; i < numlines; i++)
{
if (wlines[i].tags.count)
Z_Free(wlines[i].tags.tags);
if (wlines[i].user.length)
Z_Free(wlines[i].user.properties);
}
for (i = 0; i < numsides; i++)
{
if (wsides[i].user.length)
Z_Free(wsides[i].user.properties);
}
Z_Free(wmapthings);
Z_Free(wvertexes);
Z_Free(wsectors);
Z_Free(wlines);
Z_Free(wsides);
Z_Free(specialthings);
Z_Free(wusedvertexes);
}
static void P_WriteTextmapWaypoints(void)
{
FILE *f;
mobj_t *waypointmobj;
// Append to output from P_WriteTextmap prior
f = P_OpenTextmap("a", "Couldn't save map file (waypoints)");
if (!f)
{
return;
}
for (
waypointmobj = waypointcap;
waypointmobj;
waypointmobj = waypointmobj->tracer
){
P_WriteTextmapThing(f, waypointmobj->spawnpoint, 0, waypointmobj->spawnpoint - mapthings);
}
fclose(f);
}
/** Loads the textmap data, after obtaining the elements count and allocating their respective space.
*/
static void P_LoadTextmap(void)
{
TracyCZone(__zone, true);
UINT32 i;
vertex_t *vt;
sector_t *sc;
line_t *ld;
side_t *sd;
mapthing_t *mt;
/// Given the UDMF specs, some fields are given a default value.
/// If an element's field has a default value set, it is omitted
/// from the textmap, and therefore we have to account for it by
/// preemptively setting that value beforehand.
for (i = 0, vt = vertexes; i < numvertexes; i++, vt++)
{
// Defaults.
vt->x = vt->y = INT32_MAX;
vt->floorzset = vt->ceilingzset = false;
vt->floorz = vt->ceilingz = 0;
TextmapParse(vertexesPos[i], i, ParseTextmapVertexParameter);
if (vt->x == INT32_MAX)
I_Error("P_LoadTextmap: vertex %s has no x value set!\n", sizeu1(i));
if (vt->y == INT32_MAX)
I_Error("P_LoadTextmap: vertex %s has no y value set!\n", sizeu1(i));
}
for (i = 0, sc = sectors; i < numsectors; i++, sc++)
{
// Defaults.
sc->floorheight = 0;
sc->ceilingheight = 0;
sc->floorpic = 0;
sc->ceilingpic = 0;
sc->lightlevel = 255;
sc->special = 0;
Tag_FSet(&sc->tags, 0);
sc->floor_xoffs = sc->floor_yoffs = 0;
sc->ceiling_xoffs = sc->ceiling_yoffs = 0;
sc->floorpic_angle = sc->ceilingpic_angle = 0;
sc->floorlightlevel = sc->ceilinglightlevel = 0;
sc->floorlightabsolute = sc->ceilinglightabsolute = false;
sc->colormap_protected = false;
sc->gravity = FRACUNIT;
sc->flags = MSF_FLIPSPECIAL_FLOOR;
sc->specialflags = static_cast<sectorspecialflags_t>(0);
sc->damagetype = SD_NONE;
sc->triggertag = 0;
sc->triggerer = TO_PLAYER;
sc->friction = ORIG_FRICTION;
sc->action = 0;
memset(sc->args, 0, NUM_SCRIPT_ARGS*sizeof(*sc->args));
memset(sc->stringargs, 0x00, NUM_SCRIPT_STRINGARGS*sizeof(*sc->stringargs));
sc->activation = static_cast<sectoractionflags_t>(0);
K_UserPropertiesClear(&sc->user);
textmap_colormap.used = false;
textmap_colormap.lightcolor = 0;
textmap_colormap.lightalpha = 25;
textmap_colormap.fadecolor = 0;
textmap_colormap.fadealpha = 25;
textmap_colormap.fadestart = 0;
textmap_colormap.fadeend = 31;
textmap_colormap.flags = 0;
textmap_planefloor.defined = 0;
textmap_planeceiling.defined = 0;
TextmapParse(sectorsPos[i], i, ParseTextmapSectorParameter);
P_InitializeSector(sc);
if (textmap_colormap.used)
{
INT32 rgba = P_ColorToRGBA(textmap_colormap.lightcolor, textmap_colormap.lightalpha);
INT32 fadergba = P_ColorToRGBA(textmap_colormap.fadecolor, textmap_colormap.fadealpha);
sc->extra_colormap = sc->spawn_extra_colormap = R_CreateColormap(rgba, fadergba, textmap_colormap.fadestart, textmap_colormap.fadeend, textmap_colormap.flags);
}
if (textmap_planefloor.defined == (PD_A|PD_B|PD_C|PD_D))
{
sc->f_slope = MakeViaEquationConstants(textmap_planefloor.a, textmap_planefloor.b, textmap_planefloor.c, textmap_planefloor.d);
sc->hasslope = true;
}
if (textmap_planeceiling.defined == (PD_A|PD_B|PD_C|PD_D))
{
sc->c_slope = MakeViaEquationConstants(textmap_planeceiling.a, textmap_planeceiling.b, textmap_planeceiling.c, textmap_planeceiling.d);
sc->hasslope = true;
}
TextmapFixFlatOffsets(sc);
}
for (i = 0, ld = lines; i < numlines; i++, ld++)
{
// Defaults.
ld->v1 = ld->v2 = NULL;
ld->flags = 0;
ld->special = 0;
Tag_FSet(&ld->tags, 0);
memset(ld->args, 0, NUM_SCRIPT_ARGS*sizeof(*ld->args));
memset(ld->stringargs, 0x00, NUM_SCRIPT_STRINGARGS*sizeof(*ld->stringargs));
ld->alpha = FRACUNIT;
ld->executordelay = 0;
ld->sidenum[0] = 0xffff;
ld->sidenum[1] = 0xffff;
ld->activation = 0;
K_UserPropertiesClear(&ld->user);
TextmapParse(linesPos[i], i, ParseTextmapLinedefParameter);
if (!ld->v1)
I_Error("P_LoadTextmap: linedef %s has no v1 value set!\n", sizeu1(i));
if (!ld->v2)
I_Error("P_LoadTextmap: linedef %s has no v2 value set!\n", sizeu1(i));
if (ld->sidenum[0] == 0xffff)
I_Error("P_LoadTextmap: linedef %s has no sidefront value set!\n", sizeu1(i));
P_InitializeLinedef(ld);
}
for (i = 0, sd = sides; i < numsides; i++, sd++)
{
// Defaults.
sd->textureoffset = 0;
sd->rowoffset = 0;
sd->toptexture = R_TextureNumForName("-");
sd->midtexture = R_TextureNumForName("-");
sd->bottomtexture = R_TextureNumForName("-");
sd->sector = NULL;
sd->repeatcnt = 0;
K_UserPropertiesClear(&sd->user);
TextmapParse(sidesPos[i], i, ParseTextmapSidedefParameter);
if (!sd->sector)
I_Error("P_LoadTextmap: sidedef %s has no sector value set!\n", sizeu1(i));
P_InitializeSidedef(sd);
}
for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
{
// Defaults.
mt->x = mt->y = 0;
mt->angle = mt->pitch = mt->roll = 0;
mt->type = 0;
mt->options = 0;
mt->z = 0;
mt->extrainfo = 0;
mt->tid = 0;
mt->scale = FRACUNIT;
mt->spritexscale = mt->spriteyscale = FRACUNIT;
memset(mt->thing_args, 0, NUM_MAPTHING_ARGS*sizeof(*mt->thing_args));
memset(mt->thing_stringargs, 0x00, NUM_MAPTHING_STRINGARGS*sizeof(*mt->thing_stringargs));
mt->special = 0;
memset(mt->script_args, 0, NUM_SCRIPT_ARGS*sizeof(*mt->script_args));
memset(mt->script_stringargs, 0x00, NUM_SCRIPT_STRINGARGS*sizeof(*mt->script_stringargs));
mt->layer = 0;
mt->adjusted_z = INT32_MAX;
mt->mobj = NULL;
K_UserPropertiesClear(&mt->user);
TextmapParse(mapthingsPos[i], i, ParseTextmapThingParameter);
}
TracyCZoneEnd(__zone);
}
static fixed_t
P_MirrorTextureOffset
( fixed_t offset,
fixed_t source_width,
fixed_t actual_width)
{
/*
Adjusting the horizontal alignment is a bit ASS...
Textures on the opposite side of the line will begin
drawing from the opposite end.
Start with the texture width and subtract the seg
length to account for cropping/wrapping. Subtract the
offset to mirror the alignment.
*/
return source_width - actual_width - offset;
}
static boolean P_CheckLineSideTripWire(line_t *ld, int p)
{
INT32 n;
side_t *sda;
side_t *sdb;
terrain_t *terrain;
boolean tripwire;
n = ld->sidenum[p];
if (n == 0xffff)
return false;
sda = &sides[n];
terrain = K_GetTerrainForTextureNum(sda->midtexture);
tripwire = terrain && (terrain->flags & TRF_TRIPWIRE);
if (tripwire)
{
// copy midtexture to other side
n = ld->sidenum[!p];
if (n != 0xffff)
{
fixed_t linelength = FixedHypot(ld->dx, ld->dy);
texture_t *tex = textures[sda->midtexture];
sdb = &sides[n];
sdb->midtexture = sda->midtexture;
sdb->rowoffset = sda->rowoffset;
// mirror texture alignment
sdb->textureoffset = P_MirrorTextureOffset(
sda->textureoffset, tex->width * FRACUNIT,
linelength);
}
}
return tripwire;
}
static void P_ProcessLinedefsAfterSidedefs(void)
{
size_t i = numlines;
line_t *ld = lines;
const boolean subtractTripwire = ((mapheaderinfo[gamemap - 1]->levelflags & LF_SUBTRACTNUM) == LF_SUBTRACTNUM);
for (; i--; ld++)
{
ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here
ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : 0;
// Check for tripwire, if either side matches then
// copy that (mid)texture to the other side.
ld->tripwire =
P_CheckLineSideTripWire(ld, 0) ||
P_CheckLineSideTripWire(ld, 1);
if (ld->tripwire)
{
ld->blendmode = (subtractTripwire ? AST_COPY : AST_ADD);
ld->alpha = FRACUNIT;
}
if (udmf)
continue;
switch (ld->special)
{
// Compile linedef text from both sidedefs for appropriate specials.
case 331: // Trigger linedef executor: Skin - Continuous
case 332: // Trigger linedef executor: Skin - Each time
case 333: // Trigger linedef executor: Skin - Once
case 443: // Calls a named Lua function
if (ld->stringargs[0] && ld->stringargs[1])
{
size_t len[2];
len[0] = strlen(ld->stringargs[0]);
len[1] = strlen(ld->stringargs[1]);
if (len[1])
{
ld->stringargs[0] = static_cast<char*>(Z_Realloc(ld->stringargs[0], len[0] + len[1] + 1, PU_LEVEL, NULL));
M_Memcpy(ld->stringargs[0] + len[0] + 1, ld->stringargs[1], len[1] + 1);
}
Z_Free(ld->stringargs[1]);
ld->stringargs[1] = NULL;
}
break;
case 447: // Change colormap
case 455: // Fade colormap
if (ld->flags & ML_DONTPEGBOTTOM) // alternate alpha (by texture offsets)
{
extracolormap_t *exc = R_CopyColormap(sides[ld->sidenum[0]].colormap_data, false);
INT16 alpha = std::max<fixed_t>(std::min<fixed_t>(sides[ld->sidenum[0]].textureoffset >> FRACBITS, 25), -25);
INT16 fadealpha = std::max<fixed_t>(std::min<fixed_t>(sides[ld->sidenum[0]].rowoffset >> FRACBITS, 25), -25);
// If alpha is negative, set "subtract alpha" flag and store absolute value
if (alpha < 0)
{
alpha *= -1;
ld->args[2] |= TMCF_SUBLIGHTA;
}
if (fadealpha < 0)
{
fadealpha *= -1;
ld->args[2] |= TMCF_SUBFADEA;
}
exc->rgba = R_GetRgbaRGB(exc->rgba) + R_PutRgbaA(alpha);
exc->fadergba = R_GetRgbaRGB(exc->fadergba) + R_PutRgbaA(fadealpha);
if (!(sides[ld->sidenum[0]].colormap_data = R_GetColormapFromList(exc)))
{
exc->colormap = R_CreateLightTable(exc);
R_AddColormapToList(exc);
sides[ld->sidenum[0]].colormap_data = exc;
}
else
Z_Free(exc);
}
break;
}
}
}
static boolean P_LoadMapData(const virtres_t *virt)
{
TracyCZone(__zone, true);
virtlump_t *virtvertexes = NULL, *virtsectors = NULL, *virtsidedefs = NULL, *virtlinedefs = NULL, *virtthings = NULL;
// Count map data.
if (udmf) // Count how many entries for each type we got in textmap.
{
virtlump_t *textmap = vres_Find(virt, "TEXTMAP");
M_TokenizerOpen((char *)textmap->data, textmap->size);
if (!TextmapCount(textmap->size))
{
M_TokenizerClose();
TracyCZoneEnd(__zone);
return false;
}
}
else
{
virtthings = vres_Find(virt, "THINGS");
virtvertexes = vres_Find(virt, "VERTEXES");
virtsectors = vres_Find(virt, "SECTORS");
virtsidedefs = vres_Find(virt, "SIDEDEFS");
virtlinedefs = vres_Find(virt, "LINEDEFS");
if (!virtthings)
I_Error("THINGS lump not found");
if (!virtvertexes)
I_Error("VERTEXES lump not found");
if (!virtsectors)
I_Error("SECTORS lump not found");
if (!virtsidedefs)
I_Error("SIDEDEFS lump not found");
if (!virtlinedefs)
I_Error("LINEDEFS lump not found");
// Traditional doom map format just assumes the number of elements from the lump sizes.
numvertexes = virtvertexes->size / sizeof (mapvertex_t);
numsectors = virtsectors->size / sizeof (mapsector_t);
numsides = virtsidedefs->size / sizeof (mapsidedef_t);
numlines = virtlinedefs->size / sizeof (maplinedef_t);
nummapthings = virtthings->size / (5 * sizeof (INT16));
}
if (numvertexes <= 0)
I_Error("Level has no vertices");
if (numsectors <= 0)
I_Error("Level has no sectors");
if (numsides <= 0)
I_Error("Level has no sidedefs");
if (numlines <= 0)
I_Error("Level has no linedefs");
// Copy original vertex count before BSP modifications,
// as it can alter how -writetextmap works.
num_orig_vertexes = numvertexes;
vertexes = static_cast<vertex_t*>(Z_Calloc(numvertexes * sizeof (*vertexes), PU_LEVEL, NULL));
sectors = static_cast<sector_t*>(Z_Calloc(numsectors * sizeof (*sectors), PU_LEVEL, NULL));
sides = static_cast<side_t*>(Z_Calloc(numsides * sizeof (*sides), PU_LEVEL, NULL));
lines = static_cast<line_t*>(Z_Calloc(numlines * sizeof (*lines), PU_LEVEL, NULL));
mapthings = static_cast<mapthing_t*>(Z_Calloc(nummapthings * sizeof (*mapthings), PU_LEVEL, NULL));
// Allocate a big chunk of memory as big as our MAXLEVELFLATS limit.
//Fab : FIXME: allocate for whatever number of flats - 512 different flats per level should be plenty
foundflats = static_cast<levelflat_t*>(calloc(MAXLEVELFLATS, sizeof (*foundflats)));
if (foundflats == NULL)
I_Error("Ran out of memory while loading sectors\n");
numlevelflats = 0;
// Load map data.
if (udmf)
{
P_LoadTextmap();
M_TokenizerClose();
}
else
{
P_LoadVertices(virtvertexes->data);
P_LoadSectors(virtsectors->data);
P_LoadLinedefs(virtlinedefs->data);
P_LoadSidedefs(virtsidedefs->data);
P_LoadThings(virtthings->data);
}
P_ProcessLinedefsAfterSidedefs();
R_ClearTextureNumCache(true);
// set the sky flat num
skyflatnum = P_AddLevelFlat(SKYFLATNAME, foundflats);
// copy table for global usage
levelflats = static_cast<levelflat_t*>(M_Memcpy(Z_Calloc(numlevelflats * sizeof (*levelflats), PU_LEVEL, NULL), foundflats, numlevelflats * sizeof (levelflat_t)));
free(foundflats);
// search for animated flats and set up
P_SetupLevelFlatAnims();
TracyCZoneEnd(__zone);
return true;
}
static void P_InitializeSubsector(subsector_t *ss)
{
ss->sector = NULL;
ss->validcount = 0;
}
static inline void P_LoadSubsectors(UINT8 *data)
{
mapsubsector_t *ms = (mapsubsector_t*)data;
subsector_t *ss = subsectors;
size_t i;
for (i = 0; i < numsubsectors; i++, ss++, ms++)
{
ss->numlines = SHORT(ms->numsegs);
ss->firstline = SHORT(ms->firstseg);
P_InitializeSubsector(ss);
}
}
static void P_LoadNodes(UINT8 *data)
{
UINT8 j, k;
mapnode_t *mn = (mapnode_t*)data;
node_t *no = nodes;
size_t i;
for (i = 0; i < numnodes; i++, no++, mn++)
{
no->x = SHORT(mn->x)<<FRACBITS;
no->y = SHORT(mn->y)<<FRACBITS;
no->dx = SHORT(mn->dx)<<FRACBITS;
no->dy = SHORT(mn->dy)<<FRACBITS;
for (j = 0; j < 2; j++)
{
no->children[j] = SHORT(mn->children[j]);
for (k = 0; k < 4; k++)
no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
}
}
}
/** Computes the length of a seg in fracunits.
*
* \param seg Seg to compute length for.
* \return Length in fracunits.
*/
static fixed_t P_SegLength(seg_t *seg)
{
INT64 dx = (seg->v2->x - seg->v1->x)>>1;
INT64 dy = (seg->v2->y - seg->v1->y)>>1;
return FixedHypot(dx, dy)<<1;
}
#ifdef HWRENDER
/** Computes the length of a seg as a float.
* This is needed for OpenGL.
*
* \param seg Seg to compute length for.
* \return Length as a float.
*/
static inline float P_SegLengthFloat(seg_t *seg)
{
float dx, dy;
// make a vector (start at origin)
dx = FIXED_TO_FLOAT(seg->v2->x - seg->v1->x);
dy = FIXED_TO_FLOAT(seg->v2->y - seg->v1->y);
return (float)hypot(dx, dy);
}
#endif
/** Updates the light offset
*
* \param li Seg to update the light offsets of
*/
void P_UpdateSegLightOffset(seg_t *li)
{
const UINT8 contrast = maplighting.contrast;
const fixed_t contrastFixed = ((fixed_t)contrast) * FRACUNIT;
fixed_t light = FRACUNIT;
fixed_t extralight = 0;
if (maplighting.directional == true)
{
angle_t liAngle = R_PointToAngle2(0, 0, (li->v1->x - li->v2->x), (li->v1->y - li->v2->y)) - ANGLE_90;
light = FixedMul(FINECOSINE(liAngle >> ANGLETOFINESHIFT), FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
+ FixedMul(FINESINE(liAngle >> ANGLETOFINESHIFT), FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
light = (light + FRACUNIT) / 2;
}
else
{
light = FixedDiv(R_PointToAngle2(0, 0, abs(li->v1->x - li->v2->x), abs(li->v1->y - li->v2->y)), ANGLE_90);
}
extralight = -contrastFixed + FixedMul(light, contrastFixed * 2);
// Between -2 and 2 for software, -16 and 16 for hardware
li->lightOffset = FixedFloor((extralight / 8) + (FRACUNIT / 2)) / FRACUNIT;
#ifdef HWRENDER
li->hwLightOffset = FixedFloor(extralight + (FRACUNIT / 2)) / FRACUNIT;
#endif
}
boolean P_SectorUsesDirectionalLighting(const sector_t *sector)
{
if (sector != NULL)
{
// explicitly turned on
if (sector->flags & MSF_DIRECTIONLIGHTING)
{
return true;
}
// explicitly turned off
if (sector->flags & MSF_FLATLIGHTING)
{
return false;
}
// automatically turned on
if (sector->ceilingpic == skyflatnum)
{
// sky is visible
return true;
}
}
// default is off, for indoors
return false;
}
boolean P_ApplyLightOffset(UINT8 baselightnum, const sector_t *sector)
{
if (!P_SectorUsesDirectionalLighting(sector))
{
return false;
}
// Don't apply light offsets at full bright or full dark.
// Is in steps of light num .
return (baselightnum < LIGHTLEVELS-1 && baselightnum > 0);
}
boolean P_ApplyLightOffsetFine(UINT8 baselightlevel, const sector_t *sector)
{
if (!P_SectorUsesDirectionalLighting(sector))
{
return false;
}
// Don't apply light offsets at full bright or full dark.
// Uses exact light levels for more smoothness.
return (baselightlevel < 255 && baselightlevel > 0);
}
static void P_InitializeSeg(seg_t *seg)
{
if (seg->linedef)
{
UINT16 side = seg->linedef->sidenum[seg->side];
if (side == 0xffff)
I_Error("P_InitializeSeg: Seg %s refers to side %d of linedef %s, which doesn't exist!\n", sizeu1((size_t)(seg - segs)), seg->side, sizeu1((size_t)(seg->linedef - lines)));
seg->sidedef = &sides[side];
seg->frontsector = seg->sidedef->sector;
seg->backsector = (seg->linedef->flags & ML_TWOSIDED) ? sides[seg->linedef->sidenum[seg->side ^ 1]].sector : NULL;
}
#ifdef HWRENDER
seg->pv1 = seg->pv2 = NULL;
//Hurdler: 04/12/2000: for now, only used in hardware mode
seg->lightmaps = NULL; // list of static lightmap for this seg
#endif
seg->numlights = 0;
seg->rlights = NULL;
seg->polyseg = NULL;
seg->dontrenderme = false;
P_UpdateSegLightOffset(seg);
}
static void P_LoadSegs(UINT8 *data)
{
mapseg_t *ms = (mapseg_t*)data;
seg_t *seg = segs;
size_t i;
for (i = 0; i < numsegs; i++, seg++, ms++)
{
seg->v1 = &vertexes[SHORT(ms->v1)];
seg->v2 = &vertexes[SHORT(ms->v2)];
seg->side = SHORT(ms->side);
seg->offset = (SHORT(ms->offset)) << FRACBITS;
seg->angle = (SHORT(ms->angle)) << FRACBITS;
seg->linedef = &lines[SHORT(ms->linedef)];
seg->length = P_SegLength(seg);
#ifdef HWRENDER
seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
#endif
seg->glseg = false;
P_InitializeSeg(seg);
}
}
typedef enum {
NT_DOOM,
NT_XNOD,
NT_ZNOD,
NT_XGLN,
NT_ZGLN,
NT_XGL2,
NT_ZGL2,
NT_XGL3,
NT_ZGL3,
NT_UNSUPPORTED,
NUMNODETYPES
} nodetype_t;
// Find out the BSP format.
static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata)
{
boolean supported[NUMNODETYPES] = {0};
nodetype_t nodetype = NT_UNSUPPORTED;
char signature[4 + 1];
*nodedata = NULL;
if (udmf)
{
virtlump_t *virtznodes = vres_Find(virt, "ZNODES");
if (virtznodes && virtznodes->size)
{
*nodedata = virtznodes->data;
supported[NT_XGLN] = supported[NT_XGL3] = true;
}
}
else
{
virtlump_t *virtsegs = vres_Find(virt, "SEGS");
virtlump_t *virtssectors;
if (virtsegs && virtsegs->size)
{
virtlump_t *virtnodes = vres_Find(virt, "NODES");
if (virtnodes && virtnodes->size)
{
*nodedata = virtnodes->data;
return NT_DOOM; // Traditional map format BSP tree.
}
}
else
{
virtssectors = vres_Find(virt, "SSECTORS");
if (virtssectors && virtssectors->size)
{ // Possibly GL nodes: NODES ignored, SSECTORS takes precedence as nodes lump, (It is confusing yeah) and has a signature.
*nodedata = virtssectors->data;
supported[NT_XGLN] = supported[NT_ZGLN] = supported[NT_XGL3] = true;
}
else
{ // Possibly ZDoom extended nodes: SSECTORS is empty, NODES has a signature.
virtlump_t *virtnodes = vres_Find(virt, "NODES");
if (virtnodes && virtnodes->size)
{
*nodedata = virtnodes->data;
supported[NT_XNOD] = supported[NT_ZNOD] = true;
}
}
}
}
if (*nodedata == NULL)
{
I_Error("Level has no nodes (does your map have at least 2 sectors?)");
}
M_Memcpy(signature, *nodedata, 4);
signature[4] = '\0';
(*nodedata) += 4;
if (!strcmp(signature, "XNOD"))
nodetype = NT_XNOD;
else if (!strcmp(signature, "ZNOD"))
nodetype = NT_ZNOD;
else if (!strcmp(signature, "XGLN"))
nodetype = NT_XGLN;
else if (!strcmp(signature, "ZGLN"))
nodetype = NT_ZGLN;
else if (!strcmp(signature, "XGL3"))
nodetype = NT_XGL3;
return supported[nodetype] ? nodetype : NT_UNSUPPORTED;
}
// Extended node formats feature additional vertices; useful for OpenGL, but totally useless in gamelogic.
static boolean P_LoadExtraVertices(UINT8 **data)
{
UINT32 origvrtx = READUINT32((*data));
UINT32 xtrvrtx = READUINT32((*data));
line_t* ld = lines;
vertex_t *oldpos = vertexes;
size_t i;
if (numvertexes != origvrtx) // If native vertex count doesn't match node original vertex count, bail out (broken data?).
{
CONS_Alert(CONS_WARNING, "Vertex count in map data and nodes differ!\n");
return false;
}
if (!xtrvrtx)
return true;
// If extra vertexes were generated, reallocate the vertex array and fix the pointers.
numvertexes += xtrvrtx;
vertexes = static_cast<vertex_t*>(Z_Realloc(vertexes, numvertexes*sizeof(*vertexes), PU_LEVEL, NULL));
for (i = 0, ld = lines; i < numlines; i++, ld++)
{
ld->v1 = &vertexes[ld->v1 - oldpos];
ld->v2 = &vertexes[ld->v2 - oldpos];
}
// Read extra vertex data.
for (i = origvrtx; i < numvertexes; i++)
{
vertexes[i].x = READFIXED((*data));
vertexes[i].y = READFIXED((*data));
}
return true;
}
static boolean P_LoadExtendedSubsectorsAndSegs(UINT8 **data, nodetype_t nodetype)
{
size_t i, k;
INT16 m;
seg_t *seg;
// Subsectors
numsubsectors = READUINT32((*data));
subsectors = static_cast<subsector_t*>(Z_Calloc(numsubsectors*sizeof(*subsectors), PU_LEVEL, NULL));
for (i = 0; i < numsubsectors; i++)
subsectors[i].numlines = READUINT32((*data));
// Segs
numsegs = READUINT32((*data));
segs = static_cast<seg_t*>(Z_Calloc(numsegs*sizeof(*segs), PU_LEVEL, NULL));
for (i = 0, k = 0; i < numsubsectors; i++)
{
subsectors[i].firstline = k;
P_InitializeSubsector(&subsectors[i]);
switch (nodetype)
{
case NT_XGLN:
case NT_XGL3:
for (m = 0; m < subsectors[i].numlines; m++, k++)
{
UINT32 vertexnum = READUINT32((*data));
UINT16 linenum;
if (vertexnum >= numvertexes)
I_Error("P_LoadExtendedSubsectorsAndSegs: Seg %s in subsector %d has invalid vertex %d!\n", sizeu1(k), m, vertexnum);
segs[k - 1 + ((m == 0) ? subsectors[i].numlines : 0)].v2 = segs[k].v1 = &vertexes[vertexnum];
*data += sizeof (UINT32); // partner, can be ignored by software renderer
linenum = (nodetype == NT_XGL3) ? READUINT32((*data)) : READUINT16((*data));
if (linenum != 0xFFFF && linenum >= numlines)
I_Error("P_LoadExtendedSubsectorsAndSegs: Seg %s in subsector %s has invalid linedef %d!\n", sizeu1(k), sizeu2(i), linenum);
segs[k].glseg = (linenum == 0xFFFF);
segs[k].linedef = (linenum == 0xFFFF) ? NULL : &lines[linenum];
segs[k].side = READUINT8((*data));
}
while (segs[subsectors[i].firstline].glseg)
{
subsectors[i].firstline++;
if (subsectors[i].firstline == k)
I_Error("P_LoadExtendedSubsectorsAndSegs: Subsector %s does not have any valid segs!", sizeu1(i));
}
break;
case NT_XNOD:
for (m = 0; m < subsectors[i].numlines; m++, k++)
{
UINT32 v1num = READUINT32((*data));
UINT32 v2num = READUINT32((*data));
UINT16 linenum = READUINT16((*data));
if (v1num >= numvertexes)
I_Error("P_LoadExtendedSubsectorsAndSegs: Seg %s in subsector %d has invalid v1 %d!\n", sizeu1(k), m, v1num);
if (v2num >= numvertexes)
I_Error("P_LoadExtendedSubsectorsAndSegs: Seg %s in subsector %d has invalid v2 %d!\n", sizeu1(k), m, v2num);
if (linenum >= numlines)
I_Error("P_LoadExtendedSubsectorsAndSegs: Seg %s in subsector %d has invalid linedef %d!\n", sizeu1(k), m, linenum);
segs[k].v1 = &vertexes[v1num];
segs[k].v2 = &vertexes[v2num];
segs[k].linedef = &lines[linenum];
segs[k].side = READUINT8((*data));
segs[k].glseg = false;
}
break;
default:
return false;
}
}
for (i = 0, seg = segs; i < numsegs; i++, seg++)
{
vertex_t *v1 = seg->v1;
vertex_t *v2 = seg->v2;
P_InitializeSeg(seg);
seg->angle = R_PointToAngle2(v1->x, v1->y, v2->x, v2->y);
if (seg->linedef)
{
vertex_t *v = (seg->side == 1) ? seg->linedef->v2 : seg->linedef->v1;
segs[i].offset = FixedHypot(v1->x - v->x, v1->y - v->y);
}
seg->length = P_SegLength(seg);
#ifdef HWRENDER
seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
#endif
}
return true;
}
// Auxiliary function: Shrink node ID from 32-bit to 16-bit.
static UINT16 ShrinkNodeID(UINT32 x) {
UINT16 mask = (x >> 16) & 0xC000;
UINT16 result = x;
return result | mask;
}
static void P_LoadExtendedNodes(UINT8 **data, nodetype_t nodetype)
{
node_t *mn;
size_t i, j, k;
boolean xgl3 = (nodetype == NT_XGL3);
numnodes = READINT32((*data));
nodes = static_cast<node_t*>(Z_Calloc(numnodes*sizeof(*nodes), PU_LEVEL, NULL));
for (i = 0, mn = nodes; i < numnodes; i++, mn++)
{
// Splitter
mn->x = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
mn->y = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
mn->dx = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
mn->dy = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
// Bounding boxes
for (j = 0; j < 2; j++)
for (k = 0; k < 4; k++)
mn->bbox[j][k] = READINT16((*data)) << FRACBITS;
//Children
mn->children[0] = ShrinkNodeID(READUINT32((*data))); /// \todo Use UINT32 for node children in a future, instead?
mn->children[1] = ShrinkNodeID(READUINT32((*data)));
}
}
static void P_LoadMapBSP(const virtres_t *virt)
{
UINT8 *nodedata = NULL;
nodetype_t nodetype = P_GetNodetype(virt, &nodedata);
switch (nodetype)
{
case NT_DOOM:
{
virtlump_t *virtssectors = vres_Find(virt, "SSECTORS");
virtlump_t* virtnodes = vres_Find(virt, "NODES");
virtlump_t *virtsegs = vres_Find(virt, "SEGS");
numsubsectors = virtssectors->size / sizeof(mapsubsector_t);
numnodes = virtnodes->size / sizeof(mapnode_t);
numsegs = virtsegs->size / sizeof(mapseg_t);
if (numsubsectors <= 0)
I_Error("Level has no subsectors (did you forget to run it through a nodesbuilder?)");
if (numnodes <= 0)
I_Error("Level has no nodes (does your map have at least 2 sectors?)");
if (numsegs <= 0)
I_Error("Level has no segs");
subsectors = static_cast<subsector_t*>(Z_Calloc(numsubsectors * sizeof(*subsectors), PU_LEVEL, NULL));
nodes = static_cast<node_t*>(Z_Calloc(numnodes * sizeof(*nodes), PU_LEVEL, NULL));
segs = static_cast<seg_t*>(Z_Calloc(numsegs * sizeof(*segs), PU_LEVEL, NULL));
P_LoadSubsectors(virtssectors->data);
P_LoadNodes(virtnodes->data);
P_LoadSegs(virtsegs->data);
break;
}
case NT_XNOD:
case NT_XGLN:
case NT_XGL3:
if (!P_LoadExtraVertices(&nodedata))
return;
if (!P_LoadExtendedSubsectorsAndSegs(&nodedata, nodetype))
return;
P_LoadExtendedNodes(&nodedata, nodetype);
break;
default:
CONS_Alert(CONS_WARNING, "Unsupported BSP format detected.\n");
return;
}
return;
}
// Split from P_LoadBlockMap for convenience
// -- Monster Iestyn 08/01/18
static void P_ReadBlockMapLump(INT16 *wadblockmaplump, size_t count)
{
size_t i;
blockmaplump = static_cast<INT32*>(Z_Calloc(sizeof (*blockmaplump) * count, PU_LEVEL, NULL));
// killough 3/1/98: Expand wad blockmap into larger internal one,
// by treating all offsets except -1 as unsigned and zero-extending
// them. This potentially doubles the size of blockmaps allowed,
// because Doom originally considered the offsets as always signed.
blockmaplump[0] = SHORT(wadblockmaplump[0]);
blockmaplump[1] = SHORT(wadblockmaplump[1]);
blockmaplump[2] = (INT32)(SHORT(wadblockmaplump[2])) & 0xffff;
blockmaplump[3] = (INT32)(SHORT(wadblockmaplump[3])) & 0xffff;
for (i = 4; i < count; i++)
{
INT16 t = SHORT(wadblockmaplump[i]); // killough 3/1/98
blockmaplump[i] = t == -1 ? (INT32)-1 : (INT32) t & 0xffff;
}
}
// This needs to be a separate function
// because making both the WAD and PK3 loading code use
// the same functions is trickier than it looks for blockmap
// -- Monster Iestyn 09/01/18
static boolean P_LoadBlockMap(UINT8 *data, size_t count)
{
if (!count || count >= 0x20000)
return false;
//CONS_Printf("Reading blockmap lump for pk3...\n");
// no need to malloc anything, assume the data is uncompressed for now
count /= 2;
P_ReadBlockMapLump((INT16 *)data, count);
bmaporgx = blockmaplump[0]<<FRACBITS;
bmaporgy = blockmaplump[1]<<FRACBITS;
bmapwidth = blockmaplump[2];
bmapheight = blockmaplump[3];
// clear out mobj chains
count = sizeof (*blocklinks)* bmapwidth*bmapheight;
blocklinks = static_cast<mobj_t**>(Z_Calloc(count, PU_LEVEL, NULL));
blockmap = blockmaplump+4;
// haleyjd 2/22/06: setup polyobject blockmap
count = sizeof(*polyblocklinks) * bmapwidth * bmapheight;
polyblocklinks = static_cast<polymaplink_t**>(Z_Calloc(count, PU_LEVEL, NULL));
count = sizeof (*precipblocklinks)* bmapwidth*bmapheight;
precipblocklinks = static_cast<precipmobj_t**>(Z_Calloc(count, PU_LEVEL, NULL));
return true;
}
static boolean LineInBlock(fixed_t cx1, fixed_t cy1, fixed_t cx2, fixed_t cy2, fixed_t bx1, fixed_t by1)
{
fixed_t bbox[4];
line_t testline;
vertex_t vtest;
bbox[BOXRIGHT] = bx1 + MAPBLOCKUNITS;
bbox[BOXTOP] = by1 + MAPBLOCKUNITS;
bbox[BOXLEFT] = bx1;
bbox[BOXBOTTOM] = by1;
// Trivial rejection
if (cx1 < bbox[BOXLEFT] && cx2 < bbox[BOXLEFT])
return false;
if (cx1 > bbox[BOXRIGHT] && cx2 > bbox[BOXRIGHT])
return false;
if (cy1 < bbox[BOXBOTTOM] && cy2 < bbox[BOXBOTTOM])
return false;
if (cy1 > bbox[BOXTOP] && cy2 > bbox[BOXTOP])
return false;
// Rats, guess we gotta check
// if the line intersects
// any sides of the block.
cx1 <<= FRACBITS;
cy1 <<= FRACBITS;
cx2 <<= FRACBITS;
cy2 <<= FRACBITS;
bbox[BOXTOP] <<= FRACBITS;
bbox[BOXBOTTOM] <<= FRACBITS;
bbox[BOXLEFT] <<= FRACBITS;
bbox[BOXRIGHT] <<= FRACBITS;
testline.v1 = &vtest;
testline.v1->x = cx1;
testline.v1->y = cy1;
testline.dx = cx2 - cx1;
testline.dy = cy2 - cy1;
if ((testline.dx > 0) ^ (testline.dy > 0))
testline.slopetype = ST_NEGATIVE;
else
testline.slopetype = ST_POSITIVE;
return P_BoxOnLineSide(bbox, &testline) == -1;
}
//
// killough 10/98:
//
// Rewritten to use faster algorithm.
//
// SSN Edit: Killough's wasn't accurate enough, sometimes excluding
// blocks that the line did in fact exist in, so now we use
// a fail-safe approach that puts a 'box' around each line.
//
// Please note: This section of code is not interchangable with TeamTNT's
// code which attempts to fix the same problem.
static void P_CreateBlockMap(void)
{
size_t i;
fixed_t minx = INT32_MAX, miny = INT32_MAX, maxx = INT32_MIN, maxy = INT32_MIN;
// First find limits of map
for (i = 0; i < numvertexes; i++)
{
if (vertexes[i].x>>FRACBITS < minx)
minx = vertexes[i].x>>FRACBITS;
else if (vertexes[i].x>>FRACBITS > maxx)
maxx = vertexes[i].x>>FRACBITS;
if (vertexes[i].y>>FRACBITS < miny)
miny = vertexes[i].y>>FRACBITS;
else if (vertexes[i].y>>FRACBITS > maxy)
maxy = vertexes[i].y>>FRACBITS;
}
// Save blockmap parameters
bmaporgx = minx << FRACBITS;
bmaporgy = miny << FRACBITS;
bmapwidth = ((maxx-minx) >> MAPBTOFRAC) + 1;
bmapheight = ((maxy-miny) >> MAPBTOFRAC)+ 1;
// Compute blockmap, which is stored as a 2d array of variable-sized lists.
//
// Pseudocode:
//
// For each linedef:
//
// Map the starting and ending vertices to blocks.
//
// Starting in the starting vertex's block, do:
//
// Add linedef to current block's list, dynamically resizing it.
//
// If current block is the same as the ending vertex's block, exit loop.
//
// Move to an adjacent block by moving towards the ending block in
// either the x or y direction, to the block which contains the linedef.
{
typedef struct
{
INT32 n, nalloc;
INT32 *list;
} bmap_t; // blocklist structure
size_t tot = bmapwidth * bmapheight; // size of blockmap
bmap_t *bmap = static_cast<bmap_t*>(calloc(tot, sizeof (*bmap))); // array of blocklists
boolean straight;
if (bmap == NULL) I_Error("%s: Out of memory making blockmap", "P_CreateBlockMap");
for (i = 0; i < numlines; i++)
{
// starting coordinates
INT32 x = (lines[i].v1->x>>FRACBITS) - minx;
INT32 y = (lines[i].v1->y>>FRACBITS) - miny;
INT32 bxstart, bxend, bystart, byend, v2x, v2y, curblockx, curblocky;
v2x = lines[i].v2->x>>FRACBITS;
v2y = lines[i].v2->y>>FRACBITS;
// Draw a "box" around the line.
bxstart = (x >> MAPBTOFRAC);
bystart = (y >> MAPBTOFRAC);
v2x -= minx;
v2y -= miny;
bxend = ((v2x) >> MAPBTOFRAC);
byend = ((v2y) >> MAPBTOFRAC);
if (bxend < bxstart)
{
INT32 temp = bxstart;
bxstart = bxend;
bxend = temp;
}
if (byend < bystart)
{
INT32 temp = bystart;
bystart = byend;
byend = temp;
}
// Catch straight lines
// This fixes the error where straight lines
// directly on a blockmap boundary would not
// be included in the proper blocks.
if (lines[i].v1->y == lines[i].v2->y)
{
straight = true;
bystart--;
byend++;
}
else if (lines[i].v1->x == lines[i].v2->x)
{
straight = true;
bxstart--;
bxend++;
}
else
straight = false;
// Now we simply iterate block-by-block until we reach the end block.
for (curblockx = bxstart; curblockx <= bxend; curblockx++)
for (curblocky = bystart; curblocky <= byend; curblocky++)
{
size_t b = curblocky * bmapwidth + curblockx;
if (b >= tot)
continue;
if (!straight && !(LineInBlock((fixed_t)x, (fixed_t)y, (fixed_t)v2x, (fixed_t)v2y, (fixed_t)(curblockx << MAPBTOFRAC), (fixed_t)(curblocky << MAPBTOFRAC))))
continue;
// Increase size of allocated list if necessary
if (bmap[b].n >= bmap[b].nalloc)
{
// Graue 02-29-2004: make code more readable, don't realloc a null pointer
// (because it crashes for me, and because the comp.lang.c FAQ says so)
if (bmap[b].nalloc == 0)
bmap[b].nalloc = 8;
else
bmap[b].nalloc *= 2;
bmap[b].list = static_cast<INT32*>(Z_Realloc(bmap[b].list, bmap[b].nalloc * sizeof (*bmap->list), PU_CACHE, &bmap[b].list));
if (!bmap[b].list)
I_Error("Out of Memory in P_CreateBlockMap");
}
// Add linedef to end of list
bmap[b].list[bmap[b].n++] = (INT32)i;
}
}
// Compute the total size of the blockmap.
//
// Compression of empty blocks is performed by reserving two offset words
// at tot and tot+1.
//
// 4 words, unused if this routine is called, are reserved at the start.
{
size_t count = tot + 6; // we need at least 1 word per block, plus reserved's
for (i = 0; i < tot; i++)
if (bmap[i].n)
count += bmap[i].n + 2; // 1 header word + 1 trailer word + blocklist
// Allocate blockmap lump with computed count
blockmaplump = static_cast<INT32*>(Z_Calloc(sizeof (*blockmaplump) * count, PU_LEVEL, NULL));
}
// Now compress the blockmap.
{
size_t ndx = tot += 4; // Advance index to start of linedef lists
bmap_t *bp = bmap; // Start of uncompressed blockmap
blockmaplump[ndx++] = 0; // Store an empty blockmap list at start
blockmaplump[ndx++] = -1; // (Used for compression)
for (i = 4; i < tot; i++, bp++)
if (bp->n) // Non-empty blocklist
{
blockmaplump[blockmaplump[i] = (INT32)(ndx++)] = 0; // Store index & header
do
blockmaplump[ndx++] = bp->list[--bp->n]; // Copy linedef list
while (bp->n);
blockmaplump[ndx++] = -1; // Store trailer
Z_Free(bp->list); // Free linedef list
}
else // Empty blocklist: point to reserved empty blocklist
blockmaplump[i] = (INT32)tot;
free(bmap); // Free uncompressed blockmap
}
}
{
size_t count = sizeof (*blocklinks) * bmapwidth * bmapheight;
// clear out mobj chains (copied from from P_LoadBlockMap)
blocklinks = static_cast<mobj_t**>(Z_Calloc(count, PU_LEVEL, NULL));
blockmap = blockmaplump + 4;
// haleyjd 2/22/06: setup polyobject blockmap
count = sizeof(*polyblocklinks) * bmapwidth * bmapheight;
polyblocklinks = static_cast<polymaplink_t**>(Z_Calloc(count, PU_LEVEL, NULL));
count = sizeof (*precipblocklinks)* bmapwidth*bmapheight;
precipblocklinks = static_cast<precipmobj_t**>(Z_Calloc(count, PU_LEVEL, NULL));
}
}
// PK3 version
// -- Monster Iestyn 09/01/18
static void P_LoadReject(UINT8 *data, size_t count)
{
if (!count) // zero length, someone probably used ZDBSP
{
rejectmatrix = NULL;
CONS_Debug(DBG_SETUP, "P_LoadReject: REJECT lump has size 0, will not be loaded\n");
}
else
{
rejectmatrix = static_cast<UINT8*>(Z_Malloc(count, PU_LEVEL, NULL)); // allocate memory for the reject matrix
M_Memcpy(rejectmatrix, data, count); // copy the data into it
}
}
static void P_LoadMapLUT(const virtres_t *virt)
{
virtlump_t* virtblockmap = vres_Find(virt, "BLOCKMAP");
virtlump_t* virtreject = vres_Find(virt, "REJECT");
// Lookup tables
if (virtreject)
P_LoadReject(virtreject->data, virtreject->size);
else
rejectmatrix = NULL;
if (!(virtblockmap && P_LoadBlockMap(virtblockmap->data, virtblockmap->size)))
P_CreateBlockMap();
}
//
// P_LinkMapData
// Builds sector line lists and subsector sector numbers.
// Finds block bounding boxes for sectors.
//
static void P_LinkMapData(void)
{
size_t i, j;
line_t *li;
sector_t *sector;
subsector_t *ss = subsectors;
size_t sidei;
seg_t *seg;
fixed_t bbox[4];
// look up sector number for each subsector
for (i = 0; i < numsubsectors; i++, ss++)
{
if (ss->firstline >= numsegs)
CorruptMapError(va("P_LinkMapData: ss->firstline invalid "
"(subsector %s, firstline refers to %d of %s)", sizeu1(i), ss->firstline,
sizeu2(numsegs)));
seg = &segs[ss->firstline];
sidei = (size_t)(seg->sidedef - sides);
if (!seg->sidedef)
CorruptMapError(va("P_LinkMapData: seg->sidedef is NULL "
"(subsector %s, firstline is %d)", sizeu1(i), ss->firstline));
if (seg->sidedef - sides < 0 || seg->sidedef - sides > (UINT16)numsides)
CorruptMapError(va("P_LinkMapData: seg->sidedef refers to sidedef %s of %s "
"(subsector %s, firstline is %d)", sizeu1(sidei), sizeu2(numsides),
sizeu3(i), ss->firstline));
if (!seg->sidedef->sector)
CorruptMapError(va("P_LinkMapData: seg->sidedef->sector is NULL "
"(subsector %s, firstline is %d, sidedef is %s)", sizeu1(i), ss->firstline,
sizeu1(sidei)));
ss->sector = seg->sidedef->sector;
}
// count number of lines in each sector
for (i = 0, li = lines; i < numlines; i++, li++)
{
li->frontsector->linecount++;
if (li->backsector && li->backsector != li->frontsector)
li->backsector->linecount++;
}
// allocate linebuffers for each sector
for (i = 0, sector = sectors; i < numsectors; i++, sector++)
{
if (sector->linecount == 0) // no lines found?
{
sector->lines = NULL;
CONS_Debug(DBG_SETUP, "P_LinkMapData: sector %s has no lines\n", sizeu1(i));
}
else
{
sector->lines = static_cast<line_t**>(Z_Calloc(sector->linecount * sizeof(line_t*), PU_LEVEL, NULL));
// zero the count, since we'll later use this to track how many we've recorded
sector->linecount = 0;
}
}
// iterate through lines, assigning them to sectors' linebuffers,
// and recalculate the counts in the process
for (i = 0, li = lines; i < numlines; i++, li++)
{
li->frontsector->lines[li->frontsector->linecount++] = li;
if (li->backsector && li->backsector != li->frontsector)
li->backsector->lines[li->backsector->linecount++] = li;
}
// set soundorg's position for each sector
for (i = 0, sector = sectors; i < numsectors; i++, sector++)
{
M_ClearBox(bbox);
if (sector->linecount != 0)
{
for (j = 0; j < sector->linecount; j++)
{
li = sector->lines[j];
M_AddToBox(bbox, li->v1->x, li->v1->y);
M_AddToBox(bbox, li->v2->x, li->v2->y);
}
}
// set the degenmobj_t to the middle of the bounding box
sector->soundorg.x = (((bbox[BOXRIGHT]>>FRACBITS) + (bbox[BOXLEFT]>>FRACBITS))/2)<<FRACBITS;
sector->soundorg.y = (((bbox[BOXTOP]>>FRACBITS) + (bbox[BOXBOTTOM]>>FRACBITS))/2)<<FRACBITS;
sector->soundorg.z = sector->floorheight; // default to sector's floor height
}
}
// For maps in binary format, add multi-tags from linedef specials. This must be done
// before any linedef specials have been processed.
static void P_AddBinaryMapTagsFromLine(sector_t *sector, line_t *line)
{
Tag_Add(&sector->tags, Tag_FGet(&line->tags));
if (line->flags & ML_BLOCKMONSTERS) {
if (sides[line->sidenum[0]].textureoffset)
Tag_Add(&sector->tags, (INT32)sides[line->sidenum[0]].textureoffset / FRACUNIT);
if (sides[line->sidenum[0]].rowoffset)
Tag_Add(&sector->tags, (INT32)sides[line->sidenum[0]].rowoffset / FRACUNIT);
}
if (line->flags & ML_TFERLINE) {
if (sides[line->sidenum[1]].textureoffset)
Tag_Add(&sector->tags, (INT32)sides[line->sidenum[1]].textureoffset / FRACUNIT);
if (sides[line->sidenum[1]].rowoffset)
Tag_Add(&sector->tags, (INT32)sides[line->sidenum[1]].rowoffset / FRACUNIT);
}
}
static void P_AddBinaryMapTags(void)
{
size_t i;
for (i = 0; i < numlines; i++) {
// 97: Apply Tag to Front Sector
// 98: Apply Tag to Back Sector
// 99: Apply Tag to Front and Back Sectors
if (lines[i].special == 97 || lines[i].special == 99)
P_AddBinaryMapTagsFromLine(lines[i].frontsector, &lines[i]);
if (lines[i].special == 98 || lines[i].special == 99)
P_AddBinaryMapTagsFromLine(lines[i].backsector, &lines[i]);
}
// Run this loop after the 97-99 loop to ensure that 96 can search through all of the
// 97-99-applied tags.
for (i = 0; i < numlines; i++) {
size_t j;
mtag_t tag, target_tag;
mtag_t offset_tags[4];
// 96: Apply Tag to Tagged Sectors
if (lines[i].special != 96)
continue;
tag = Tag_FGet(&lines[i].frontsector->tags);
target_tag = Tag_FGet(&lines[i].tags);
memset(offset_tags, 0, sizeof(mtag_t)*4);
if (lines[i].flags & ML_BLOCKMONSTERS) {
offset_tags[0] = (INT32)sides[lines[i].sidenum[0]].textureoffset / FRACUNIT;
offset_tags[1] = (INT32)sides[lines[i].sidenum[0]].rowoffset / FRACUNIT;
}
if (lines[i].flags & ML_TFERLINE) {
offset_tags[2] = (INT32)sides[lines[i].sidenum[1]].textureoffset / FRACUNIT;
offset_tags[3] = (INT32)sides[lines[i].sidenum[1]].rowoffset / FRACUNIT;
}
for (j = 0; j < numsectors; j++) {
boolean matches_target_tag = target_tag && Tag_Find(&sectors[j].tags, target_tag);
size_t k;
for (k = 0; k < 4; k++) {
if (lines[i].flags & ML_WRAPMIDTEX) {
if (matches_target_tag || (offset_tags[k] && Tag_Find(&sectors[j].tags, offset_tags[k]))) {
Tag_Add(&sectors[j].tags, tag);
break;
}
} else if (matches_target_tag) {
if (k == 0)
Tag_Add(&sectors[j].tags, tag);
if (offset_tags[k])
Tag_Add(&sectors[j].tags, offset_tags[k]);
}
}
}
}
for (i = 0; i < nummapthings; i++)
{
switch (mapthings[i].type)
{
case 291:
case 322:
case 750:
case 760:
case 761:
case 762:
mapthings[i].tid = mapthings[i].angle;
break;
case 290:
case 292:
case 294:
case 780:
case 2020: // MT_LOOPENDPOINT
case 2021: // MT_LOOPCENTERPOINT
mapthings[i].tid = mapthings[i].extrainfo;
break;
default:
break;
}
}
}
static line_t *P_FindPointPushLine(taglist_t *list)
{
INT32 i, l;
for (i = 0; i < list->count; i++)
{
mtag_t tag = list->tags[i];
TAG_ITER_LINES(tag, l)
{
if (Tag_FGet(&lines[l].tags) != tag)
continue;
if (lines[l].special != 547)
continue;
return &lines[l];
}
}
return NULL;
}
static void P_SetBinaryFOFAlpha(line_t *line)
{
if (sides[line->sidenum[0]].toptexture > 0)
{
line->args[1] = sides[line->sidenum[0]].toptexture;
if (line->args[1] == 901) // additive special
{
line->args[1] = 0xff;
line->args[2] = TMB_ADD;
}
else if (line->args[1] == 902) // subtractive special
{
line->args[1] = 0xff;
line->args[2] = TMB_SUBTRACT;
}
else if (line->args[1] >= 1001) // fourth digit
{
line->args[1] %= 1000;
line->args[2] = (sides[line->sidenum[0]].toptexture/1000); // TMB_TRANSLUCNET, TMB_ADD, etc
}
}
else
{
line->args[1] = 128;
line->args[2] = TMB_TRANSLUCENT;
}
}
static INT32 P_GetFOFFlags(INT32 oldflags)
{
INT32 result = 0;
if (oldflags & FF_OLD_EXISTS)
result |= FOF_EXISTS;
if (oldflags & FF_OLD_BLOCKPLAYER)
result |= FOF_BLOCKPLAYER;
if (oldflags & FF_OLD_BLOCKOTHERS)
result |= FOF_BLOCKOTHERS;
if (oldflags & FF_OLD_RENDERSIDES)
result |= FOF_RENDERSIDES;
if (oldflags & FF_OLD_RENDERPLANES)
result |= FOF_RENDERPLANES;
if (oldflags & FF_OLD_SWIMMABLE)
result |= FOF_SWIMMABLE;
if (oldflags & FF_OLD_NOSHADE)
result |= FOF_NOSHADE;
if (oldflags & FF_OLD_CUTSOLIDS)
result |= FOF_CUTSOLIDS;
if (oldflags & FF_OLD_CUTEXTRA)
result |= FOF_CUTEXTRA;
if (oldflags & FF_OLD_CUTSPRITES)
result |= FOF_CUTSPRITES;
if (oldflags & FF_OLD_BOTHPLANES)
result |= FOF_BOTHPLANES;
if (oldflags & FF_OLD_EXTRA)
result |= FOF_EXTRA;
if (oldflags & FF_OLD_TRANSLUCENT)
result |= FOF_TRANSLUCENT;
if (oldflags & FF_OLD_FOG)
result |= FOF_FOG;
if (oldflags & FF_OLD_INVERTPLANES)
result |= FOF_INVERTPLANES;
if (oldflags & FF_OLD_ALLSIDES)
result |= FOF_ALLSIDES;
if (oldflags & FF_OLD_INVERTSIDES)
result |= FOF_INVERTSIDES;
if (oldflags & FF_OLD_DOUBLESHADOW)
result |= FOF_DOUBLESHADOW;
if (oldflags & FF_OLD_FLOATBOB)
result |= FOF_FLOATBOB;
if (oldflags & FF_OLD_NORETURN)
result |= FOF_NORETURN;
if (oldflags & FF_OLD_CRUMBLE)
result |= FOF_CRUMBLE;
if (oldflags & FF_OLD_GOOWATER)
result |= FOF_GOOWATER;
if (oldflags & FF_OLD_MARIO)
result |= FOF_MARIO;
if (oldflags & FF_OLD_BUSTUP)
result |= FOF_BUSTUP;
if (oldflags & FF_OLD_QUICKSAND)
result |= FOF_QUICKSAND;
if (oldflags & FF_OLD_PLATFORM)
result |= FOF_PLATFORM;
if (oldflags & FF_OLD_REVERSEPLATFORM)
result |= FOF_REVERSEPLATFORM;
if (oldflags & FF_OLD_RIPPLE)
result |= FOF_RIPPLE;
if (oldflags & FF_OLD_COLORMAPONLY)
result |= FOF_COLORMAPONLY;
return result;
}
static INT32 P_GetFOFBusttype(INT32 oldflags)
{
if (oldflags & FF_OLD_SHATTER)
return TMFB_TOUCH;
if (oldflags & FF_OLD_SPINBUST)
return TMFB_SPIN;
if (oldflags & FF_OLD_STRONGBUST)
return TMFB_STRONG;
return TMFB_REGULAR;
}
static void P_ConvertBinaryLinedefTypes(void)
{
size_t i;
for (i = 0; i < numlines; i++)
{
mtag_t tag = Tag_FGet(&lines[i].tags);
switch (lines[i].special)
{
case 2: //Custom exit
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[1] |= TMEF_SKIPTALLY;
if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[1] |= TMEF_EMERALDCHECK;
break;
case 3: //Zoom tube parameters
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = !!(lines[i].flags & ML_MIDSOLID);
break;
case 4: //Speed pad parameters
CONS_Alert(CONS_WARNING, "Speed Pad linedef is deprecated. Use the TERRAIN effect!\n");
break;
case 7: //Sector flat alignment
lines[i].args[0] = tag;
if ((lines[i].flags & (ML_NETONLY|ML_NONET)) == (ML_NETONLY|ML_NONET))
{
CONS_Alert(CONS_WARNING, M_GetText("Flat alignment linedef (tag %d) doesn't have anything to do.\nConsider changing the linedef's flag configuration or removing it entirely.\n"), tag);
lines[i].special = 0;
}
else if (lines[i].flags & ML_NETONLY)
lines[i].args[1] = TMP_CEILING;
else if (lines[i].flags & ML_NONET)
lines[i].args[1] = TMP_FLOOR;
else
lines[i].args[1] = TMP_BOTH;
lines[i].flags &= ~(ML_NETONLY|ML_NONET);
if (lines[i].flags & ML_BLOCKMONSTERS) // Set offset through x and y texture offsets
{
angle_t flatangle = InvAngle(R_PointToAngle2(lines[i].v1->x, lines[i].v1->y, lines[i].v2->x, lines[i].v2->y));
fixed_t xoffs = sides[lines[i].sidenum[0]].textureoffset;
fixed_t yoffs = sides[lines[i].sidenum[0]].rowoffset;
//If no tag is given, apply to front sector
if (lines[i].args[0] == 0)
P_ApplyFlatAlignment(lines[i].frontsector, flatangle, xoffs, yoffs, lines[i].args[1] != TMP_CEILING, lines[i].args[1] != TMP_FLOOR);
else
{
INT32 s;
TAG_ITER_SECTORS(lines[i].args[0], s)
P_ApplyFlatAlignment(sectors + s, flatangle, xoffs, yoffs, lines[i].args[1] != TMP_CEILING, lines[i].args[1] != TMP_FLOOR);
}
lines[i].special = 0;
}
break;
case 8: //Special sector properties
{
INT32 s;
lines[i].args[0] = tag;
TAG_ITER_SECTORS(tag, s)
{
if (lines[i].flags & ML_NOCLIMB)
{
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags & ~MSF_FLIPSPECIAL_FLOOR);
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_FLIPSPECIAL_CEILING);
}
else if (lines[i].flags & ML_MIDSOLID)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_FLIPSPECIAL_BOTH);
if (lines[i].flags & ML_MIDPEG)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_TRIGGERSPECIAL_TOUCH);
if (lines[i].flags & ML_NOSKEW)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_TRIGGERSPECIAL_HEADBUMP);
if (lines[i].flags & ML_SKEWTD)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_INVERTPRECIP);
if (lines[i].flags & ML_DONTPEGTOP)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_RIPPLE_FLOOR);
if (lines[i].flags & ML_DONTPEGBOTTOM)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_RIPPLE_CEILING);
}
if (GETSECSPECIAL(lines[i].frontsector->special, 4) != 12)
lines[i].special = 0;
break;
}
case 10: //Culling plane
lines[i].args[0] = tag;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 11: //Rope hang parameters
lines[i].args[0] = (lines[i].flags & ML_NOCLIMB) ? 0 : sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = !!(lines[i].flags & ML_SKEWTD);
break;
case 13: //Heat wave effect
{
INT32 s;
TAG_ITER_SECTORS(tag, s)
sectors[s].flags = static_cast<sectorflags_t>(sectors[s].flags | MSF_HEATWAVE);
break;
}
case 14: //Bustable block parameters
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = !!(lines[i].flags & ML_SKEWTD);
break;
case 16: //Minecart parameters
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
break;
case 20: //PolyObject first line
{
INT32 check = -1;
INT32 paramline = -1;
TAG_ITER_LINES(tag, check)
{
if (lines[check].special == 22)
{
paramline = check;
break;
}
}
//PolyObject ID
lines[i].args[0] = tag;
//Default: Invisible planes
lines[i].args[3] |= TMPF_INVISIBLEPLANES;
//Linedef executor tag
lines[i].args[4] = 32000 + lines[i].args[0];
if (paramline == -1)
break; // no extra settings to apply, let's leave it
//Parent ID
lines[i].args[1] = lines[paramline].frontsector->special;
//Translucency
lines[i].args[2] = (lines[paramline].flags & ML_DONTPEGTOP)
? (sides[lines[paramline].sidenum[0]].textureoffset >> FRACBITS)
: ((lines[paramline].frontsector->floorheight >> FRACBITS) / 100);
//Flags
if (lines[paramline].flags & ML_SKEWTD)
lines[i].args[3] |= TMPF_NOINSIDES;
if (lines[paramline].flags & ML_NOSKEW)
lines[i].args[3] |= TMPF_INTANGIBLE;
if (lines[paramline].flags & ML_MIDPEG)
lines[i].args[3] |= TMPF_PUSHABLESTOP;
if (lines[paramline].flags & ML_MIDSOLID)
lines[i].args[3] &= ~TMPF_INVISIBLEPLANES;
/*if (lines[paramline].flags & ML_WRAPMIDTEX)
lines[i].args[3] |= TMPF_DONTCLIPPLANES;*/
if (lines[paramline].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= TMPF_SPLAT;
if (lines[paramline].flags & ML_NOCLIMB)
lines[i].args[3] |= TMPF_EXECUTOR;
break;
}
case 30: //Polyobject - waving flag
lines[i].args[0] = tag;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[2] = AngleFixed(lines[i].angle) >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
break;
case 31: //Polyobject - displacement by front sector
lines[i].args[0] = tag;
lines[i].args[1] = 0;
lines[i].args[2] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
lines[i].args[3] = R_PointToAngle2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
break;
case 32: //Polyobject - angular displacement by front sector
lines[i].args[0] = tag;
lines[i].args[1] = 0;
lines[i].args[2] = sides[lines[i].sidenum[0]].textureoffset ? sides[lines[i].sidenum[0]].textureoffset >> FRACBITS : 128;
lines[i].args[3] = sides[lines[i].sidenum[0]].rowoffset ? sides[lines[i].sidenum[0]].rowoffset >> FRACBITS : 90;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[4] |= TMPR_DONTROTATEOTHERS;
else if (lines[i].flags & ML_MIDSOLID)
lines[i].args[4] |= TMPR_ROTATEPLAYERS;
break;
case 50: //Instantly lower floor on level load
case 51: //Instantly raise ceiling on level load
lines[i].args[0] = tag;
break;
case 52: //Continuously falling sector
lines[i].args[0] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 53: //Continuous floor/ceiling mover
case 54: //Continuous floor mover
case 55: //Continuous ceiling mover
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 53) ? TMP_BOTH : lines[i].special - 54;
lines[i].args[2] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[3] = lines[i].args[2];
lines[i].args[4] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[5] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].special = 53;
break;
case 56: //Continuous two-speed floor/ceiling mover
case 57: //Continuous two-speed floor mover
case 58: //Continuous two-speed ceiling mover
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 56) ? TMP_BOTH : lines[i].special - 57;
lines[i].args[2] = abs(lines[i].dx) >> FRACBITS;
lines[i].args[3] = abs(lines[i].dy) >> FRACBITS;
lines[i].args[4] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[5] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].special = 56;
break;
case 59: //Activate moving platform
case 60: //Activate moving platform (adjustable speed)
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 60) ? P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS : 8;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[4] = (lines[i].flags & ML_NOCLIMB) ? 1 : 0;
lines[i].special = 60;
break;
case 61: //Crusher (Ceiling to floor)
case 62: //Crusher (Floor to ceiling)
lines[i].args[0] = tag;
lines[i].args[1] = lines[i].special - 61;
if (lines[i].flags & ML_MIDSOLID)
{
lines[i].args[2] = abs(lines[i].dx) >> FRACBITS;
lines[i].args[3] = lines[i].args[2];
}
else
{
lines[i].args[2] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> (FRACBITS + 1);
lines[i].args[3] = lines[i].args[2] / 4;
}
lines[i].special = 61;
break;
case 63: //Fake floor/ceiling planes
lines[i].args[0] = tag;
break;
case 64: //Appearing/disappearing FOF
lines[i].args[0] = (lines[i].flags & ML_BLOCKPLAYERS) ? 0 : tag;
lines[i].args[1] = (lines[i].flags & ML_BLOCKPLAYERS) ? tag : Tag_FGet(&lines[i].frontsector->tags);
lines[i].args[2] = lines[i].dx >> FRACBITS;
lines[i].args[3] = lines[i].dy >> FRACBITS;
lines[i].args[4] = lines[i].frontsector->floorheight >> FRACBITS;
lines[i].args[5] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 66: //Move floor by displacement
case 67: //Move ceiling by displacement
case 68: //Move floor and ceiling by displacement
lines[i].args[0] = tag;
lines[i].args[1] = lines[i].special - 66;
lines[i].args[2] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] *= -1;
lines[i].special = 66;
break;
case 76: //Make FOF bouncy
lines[i].args[0] = tag;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
break;
case 80: //Raise tagged things by type to this FOF
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = tag;
break;
case 81: //Block enemies
lines[i].flags |= ML_BLOCKMONSTERS;
lines[i].special = 0;
break;
case 100: //FOF: solid, opaque, shadowcasting
case 101: //FOF: solid, opaque, non-shadowcasting
case 102: //FOF: solid, translucent
case 103: //FOF: solid, sides only
case 104: //FOF: solid, no sides
case 105: //FOF: solid, invisible
lines[i].args[0] = tag;
//Alpha
if (lines[i].special == 102)
{
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] |= TMFA_INSIDES;
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[3] |= TMFA_SPLAT;
}
else
lines[i].args[1] = 255;
//Appearance
if (lines[i].special == 105)
lines[i].args[3] |= TMFA_NOPLANES|TMFA_NOSIDES;
else if (lines[i].special == 104)
lines[i].args[3] |= TMFA_NOSIDES;
else if (lines[i].special == 103)
lines[i].args[3] |= TMFA_NOPLANES;
if (lines[i].special != 100 && (lines[i].special != 104 || !(lines[i].flags & ML_NOCLIMB)))
lines[i].args[3] |= TMFA_NOSHADE;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= TMFA_SPLAT;
//Tangibility
if (lines[i].flags & ML_SKEWTD)
lines[i].args[4] |= TMFT_DONTBLOCKOTHERS;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[4] |= TMFT_DONTBLOCKPLAYER;
lines[i].special = 100;
break;
case 120: //FOF: water, opaque
case 121: //FOF: water, translucent
case 122: //FOF: water, opaque, no sides
case 123: //FOF: water, translucent, no sides
case 124: //FOF: goo water, translucent
case 125: //FOF: goo water, translucent, no sides
lines[i].args[0] = tag;
//Alpha
if (lines[i].special == 120 || lines[i].special == 122)
lines[i].args[1] = 255;
else
{
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[3] |= TMFW_SPLAT;
}
//No sides?
if (lines[i].special == 122 || lines[i].special == 123 || lines[i].special == 125)
lines[i].args[3] |= TMFW_NOSIDES;
//Flags
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] |= TMFW_DOUBLESHADOW;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[3] |= TMFW_COLORMAPONLY;
if (!(lines[i].flags & ML_WRAPMIDTEX))
lines[i].args[3] |= TMFW_NORIPPLE;
//Goo?
if (lines[i].special >= 124)
lines[i].args[3] |= TMFW_GOOWATER;
//Splat rendering?
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= TMFW_SPLAT;
lines[i].special = 120;
break;
case 140: //FOF: intangible from bottom, opaque
case 141: //FOF: intangible from bottom, translucent
case 142: //FOF: intangible from bottom, translucent, no sides
case 143: //FOF: intangible from top, opaque
case 144: //FOF: intangible from top, translucent
case 145: //FOF: intangible from top, translucent, no sides
case 146: //FOF: only tangible from sides
lines[i].args[0] = tag;
//Alpha
if (lines[i].special == 141 || lines[i].special == 142 || lines[i].special == 144 || lines[i].special == 145)
{
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] |= TMFA_INSIDES;
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[3] |= TMFA_SPLAT;
}
else
lines[i].args[1] = 255;
//Appearance
if (lines[i].special == 142 || lines[i].special == 145)
lines[i].args[3] |= TMFA_NOSIDES;
else if (lines[i].special == 146)
lines[i].args[3] |= TMFA_NOPLANES;
if (lines[i].special != 146 && (lines[i].flags & ML_NOCLIMB))
lines[i].args[3] |= TMFA_NOSHADE;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= TMFA_SPLAT;
//Tangibility
if (lines[i].special <= 142)
lines[i].args[4] |= TMFT_INTANGIBLEBOTTOM;
else if (lines[i].special <= 145)
lines[i].args[4] |= TMFT_INTANGIBLETOP;
else
lines[i].args[4] |= TMFT_INTANGIBLEBOTTOM|TMFT_INTANGIBLETOP;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[4] |= TMFT_DONTBLOCKOTHERS;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[4] |= TMFT_DONTBLOCKPLAYER;
lines[i].special = 100;
break;
case 150: //FOF: Air bobbing
case 151: //FOF: Air bobbing (adjustable)
case 152: //FOF: Reverse air bobbing (adjustable)
case 153: //FOF: Dynamically sinking platform
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 150) ? 16 : (P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS);
//Flags
if (lines[i].special == 152)
lines[i].args[2] |= TMFB_REVERSE;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] |= TMFB_SPINDASH;
if (lines[i].special == 153)
lines[i].args[2] |= TMFB_DYNAMIC;
lines[i].special = 150;
break;
case 160: //FOF: Water bobbing
lines[i].args[0] = tag;
break;
case 170: //FOF: Crumbling, respawn
case 171: //FOF: Crumbling, no respawn
case 172: //FOF: Crumbling, respawn, intangible from bottom
case 173: //FOF: Crumbling, no respawn, intangible from bottom
case 174: //FOF: Crumbling, respawn, intangible from bottom, translucent
case 175: //FOF: Crumbling, no respawn, intangible from bottom, translucent
case 176: //FOF: Crumbling, respawn, floating, bobbing
case 177: //FOF: Crumbling, no respawn, floating, bobbing
case 178: //FOF: Crumbling, respawn, floating
case 179: //FOF: Crumbling, no respawn, floating
case 180: //FOF: Crumbling, respawn, air bobbing
lines[i].args[0] = tag;
//Alpha
if (lines[i].special >= 174 && lines[i].special <= 175)
{
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[4] |= TMFC_SPLAT;
}
else
lines[i].args[1] = 255;
if (lines[i].special >= 172 && lines[i].special <= 175)
{
lines[i].args[3] |= TMFT_INTANGIBLEBOTTOM;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[4] |= TMFC_NOSHADE;
}
if (lines[i].special % 2 == 1)
lines[i].args[4] |= TMFC_NORETURN;
if (lines[i].special == 176 || lines[i].special == 177 || lines[i].special == 180)
lines[i].args[4] |= TMFC_AIRBOB;
if (lines[i].special >= 176 && lines[i].special <= 179)
lines[i].args[4] |= TMFC_FLOATBOB;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[4] |= TMFC_SPLAT;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[3] |= TMFT_DONTBLOCKOTHERS;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[3] |= TMFT_DONTBLOCKPLAYER;
lines[i].special = 170;
break;
case 190: // FOF: Rising, solid, opaque, shadowcasting
case 191: // FOF: Rising, solid, opaque, non-shadowcasting
case 192: // FOF: Rising, solid, translucent
case 193: // FOF: Rising, solid, invisible
case 194: // FOF: Rising, intangible from bottom, opaque
case 195: // FOF: Rising, intangible from bottom, translucent
lines[i].args[0] = tag;
//Translucency
if (lines[i].special == 192 || lines[i].special == 195)
{
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[3] |= TMFA_SPLAT;
}
else
lines[i].args[1] = 255;
//Appearance
if (lines[i].special == 193)
lines[i].args[3] |= TMFA_NOPLANES|TMFA_NOSIDES;
if (lines[i].special >= 194)
lines[i].args[3] |= TMFA_INSIDES;
if (lines[i].special != 190 && (lines[i].special <= 193 || lines[i].flags & ML_NOCLIMB))
lines[i].args[3] |= TMFA_NOSHADE;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= TMFA_SPLAT;
//Tangibility
if (lines[i].flags & ML_SKEWTD)
lines[i].args[4] |= TMFT_DONTBLOCKOTHERS;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[4] |= TMFT_DONTBLOCKPLAYER;
if (lines[i].special >= 194)
lines[i].args[4] |= TMFT_INTANGIBLEBOTTOM;
//Speed
lines[i].args[5] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
//Flags
if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[6] |= TMFR_REVERSE;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[6] |= TMFR_SPINDASH;
lines[i].special = 190;
break;
case 200: //FOF: Light block
case 201: //FOF: Half light block
lines[i].args[0] = tag;
if (lines[i].special == 201)
lines[i].args[1] = 1;
lines[i].special = 200;
break;
case 202: //FOF: Fog block
case 223: //FOF: Intangible, invisible
lines[i].args[0] = tag;
break;
case 220: //FOF: Intangible, opaque
case 221: //FOF: Intangible, translucent
case 222: //FOF: Intangible, sides only
lines[i].args[0] = tag;
//Alpha
if (lines[i].special == 221)
{
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[3] |= TMFA_SPLAT;
}
else
lines[i].args[1] = 255;
//Appearance
if (lines[i].special == 222)
lines[i].args[3] |= TMFA_NOPLANES;
if (lines[i].special == 221)
lines[i].args[3] |= TMFA_INSIDES;
if (lines[i].special != 220 && !(lines[i].flags & ML_NOCLIMB))
lines[i].args[3] |= TMFA_NOSHADE;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= TMFA_SPLAT;
lines[i].special = 220;
break;
case 250: //FOF: Mario block
lines[i].args[0] = tag;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[1] |= TMFM_BRICK;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[1] |= TMFM_INVISIBLE;
break;
case 251: //FOF: Thwomp block
lines[i].args[0] = tag;
if (lines[i].flags & ML_WRAPMIDTEX) //Custom speeds
{
lines[i].args[1] = lines[i].dy >> FRACBITS;
lines[i].args[2] = lines[i].dx >> FRACBITS;
}
else
{
lines[i].args[1] = 80;
lines[i].args[2] = 16;
}
if (lines[i].flags & ML_MIDSOLID)
P_WriteSfx(sides[lines[i].sidenum[0]].textureoffset >> FRACBITS, &lines[i].stringargs[0]);
if (lines[i].flags & ML_SKEWTD) // Kart Z delay. Yes, it used the same field as the above.
lines[i].args[3] = (unsigned)(sides[lines[i].sidenum[0]].textureoffset >> FRACBITS);
break;
case 252: //FOF: Shatter block
case 253: //FOF: Shatter block, translucent
case 254: //FOF: Bustable block
case 255: //FOF: Spin-bustable block
case 256: //FOF: Spin-bustable block, translucent
lines[i].args[0] = tag;
//Alpha
if (lines[i].special == 253 || lines[i].special == 256)
{
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[4] |= TMFB_SPLAT;
}
else
lines[i].args[1] = 255;
//Bustable type
if (lines[i].special <= 253)
lines[i].args[3] = TMFB_TOUCH;
else if (lines[i].special >= 255)
lines[i].args[3] = TMFB_SPIN;
else if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] = TMFB_STRONG;
else
lines[i].args[3] = TMFB_REGULAR;
//Flags
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[4] |= TMFB_PUSHABLES;
if (lines[i].flags & ML_WRAPMIDTEX)
{
lines[i].args[4] |= TMFB_EXECUTOR;
lines[i].args[5] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
}
if (lines[i].special == 252 && lines[i].flags & ML_NOCLIMB)
lines[i].args[4] |= TMFB_ONLYBOTTOM;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[4] |= TMFB_SPLAT;
lines[i].special = 254;
break;
case 257: //FOF: Quicksand
lines[i].args[0] = tag;
if (!(lines[i].flags & ML_WRAPMIDTEX))
lines[i].args[1] = 1; //No ripple effect
lines[i].args[2] = lines[i].dx >> FRACBITS; //Sinking speed
lines[i].args[3] = lines[i].dy >> FRACBITS; //Friction
break;
case 258: //FOF: Laser
lines[i].args[0] = tag;
//Alpha
P_SetBinaryFOFAlpha(&lines[i]);
//Flags
if (lines[i].flags & ML_SKEWTD)
lines[i].args[3] |= TMFL_NOBOSSES;
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].flags & ML_BLOCKMONSTERS || lines[i].args[1] == 256)
lines[i].args[3] |= TMFL_SPLAT;
break;
case 259: //Custom FOF
if (lines[i].sidenum[1] == 0xffff)
I_Error("Custom FOF (tag %d) found without a linedef back side!", tag);
lines[i].args[0] = tag;
lines[i].args[3] = P_GetFOFFlags(sides[lines[i].sidenum[1]].toptexture);
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[3] |= FOF_SPLAT;
lines[i].args[4] = P_GetFOFBusttype(sides[lines[i].sidenum[1]].toptexture);
if (sides[lines[i].sidenum[1]].toptexture & FF_OLD_SHATTERBOTTOM)
lines[i].args[4] |= TMFB_ONLYBOTTOM;
if (lines[i].args[3] & FOF_TRANSLUCENT)
{
P_SetBinaryFOFAlpha(&lines[i]);
//Replicate old hack: Translucent FOFs set to full opacity cut cyan pixels
if (lines[i].args[1] == 256)
lines[i].args[3] |= FOF_SPLAT;
}
else
lines[i].args[1] = 255;
break;
case 300: //Trigger linedef executor - Continuous
case 301: //Trigger linedef executor - Each time
case 302: //Trigger linedef executor - Once
if (lines[i].special == 302)
lines[i].args[0] = TMT_ONCE;
else if (lines[i].special == 301)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].special = 300;
break;
case 303: //Ring count - Continuous
case 304: //Ring count - Once
lines[i].args[0] = (lines[i].special == 304) ? TMT_ONCE : TMT_CONTINUOUS;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] = TMC_LTE;
else if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[2] = TMC_GTE;
else
lines[i].args[2] = TMC_EQUAL;
lines[i].args[3] = !!(lines[i].flags & ML_MIDSOLID);
lines[i].special = 303;
break;
case 305: //Character ability - Continuous
case 306: //Character ability - Each time
case 307: //Character ability - Once
if (lines[i].special == 307)
lines[i].args[0] = TMT_ONCE;
else if (lines[i].special == 306)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].args[1] = (P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS) / 10;
lines[i].special = 305;
break;
case 308: //Race only - once
lines[i].args[0] = TMT_ONCE;
lines[i].args[1] = GTR_CIRCUIT;
lines[i].args[2] = TMF_HASANY;
break;
case 309: //CTF red team - continuous
case 310: //CTF red team - each time
case 311: //CTF blue team - continuous
case 312: //CTF blue team - each time
if (lines[i].special % 2 == 0)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].args[1] = (lines[i].special > 310) ? TMT_BLUE : TMT_ORANGE;
lines[i].special = 309;
break;
case 313: //No more enemies - once
lines[i].args[0] = tag;
break;
case 314: //Number of pushables - Continuous
case 315: //Number of pushables - Once
lines[i].args[0] = (lines[i].special == 315) ? TMT_ONCE : TMT_CONTINUOUS;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] = TMC_GTE;
else if (lines[i].flags & ML_MIDSOLID)
lines[i].args[2] = TMC_LTE;
else
lines[i].args[2] = TMC_EQUAL;
lines[i].special = 314;
break;
case 317: //Condition set trigger - Continuous
case 318: //Condition set trigger - Once
lines[i].args[0] = (lines[i].special == 318) ? TMT_ONCE : TMT_CONTINUOUS;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].special = 317;
break;
case 319: //Unlockable trigger - Continuous
case 320: //Unlockable trigger - Once
lines[i].args[0] = (lines[i].special == 320) ? TMT_ONCE : TMT_CONTINUOUS;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].special = 319;
break;
case 321: //Trigger after X calls - Continuous
case 322: //Trigger after X calls - Each time
if (lines[i].special % 2 == 0)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMXT_EACHTIMEENTERANDEXIT : TMXT_EACHTIMEENTER;
else
lines[i].args[0] = TMXT_CONTINUOUS;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
{
lines[i].args[2] = 1;
lines[i].args[3] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
}
else
lines[i].args[2] = lines[i].args[3] = 0;
lines[i].special = 321;
break;
case 323: //NiGHTSerize - Each time
case 324: //NiGHTSerize - Once
case 325: //DeNiGHTSerize - Each time
case 326: //DeNiGHTSerize - Once
case 327: //NiGHTS lap - Each time
case 328: //NiGHTS lap - Once
case 329: //Ideya capture touch - Each time
case 330: //Ideya capture touch - Once
lines[i].args[0] = (lines[i].special + 1) % 2;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] = TMC_LTE;
else if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[3] = TMC_GTE;
else
lines[i].args[3] = TMC_EQUAL;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[4] = TMC_LTE;
else if (lines[i].flags & ML_NOSKEW)
lines[i].args[4] = TMC_GTE;
else
lines[i].args[4] = TMC_EQUAL;
if (lines[i].flags & ML_DONTPEGBOTTOM)
lines[i].args[5] = TMNP_SLOWEST;
else if (lines[i].flags & ML_MIDSOLID)
lines[i].args[5] = TMNP_TRIGGERER;
else
lines[i].args[5] = TMNP_FASTEST;
if (lines[i].special % 2 == 0)
lines[i].special--;
if (lines[i].special == 323)
{
if (lines[i].flags & ML_TFERLINE)
lines[i].args[6] = TMN_FROMNONIGHTS;
else if (lines[i].flags & ML_DONTPEGTOP)
lines[i].args[6] = TMN_FROMNIGHTS;
else
lines[i].args[6] = TMN_ALWAYS;
if (lines[i].flags & ML_MIDPEG)
lines[i].args[7] |= TMN_BONUSLAPS;
if (lines[i].flags & ML_NOTBOUNCY)
lines[i].args[7] |= TMN_LEVELCOMPLETION;
}
else if (lines[i].special == 325)
{
if (lines[i].flags & ML_TFERLINE)
lines[i].args[6] = TMD_NOBODYNIGHTS;
else if (lines[i].flags & ML_DONTPEGTOP)
lines[i].args[6] = TMD_SOMEBODYNIGHTS;
else
lines[i].args[6] = TMD_ALWAYS;
lines[i].args[7] = !!(lines[i].flags & ML_MIDPEG);
}
else if (lines[i].special == 327)
lines[i].args[6] = !!(lines[i].flags & ML_MIDPEG);
else
{
if (lines[i].flags & ML_DONTPEGTOP)
lines[i].args[6] = TMS_ALWAYS;
else if (lines[i].flags & ML_NOTBOUNCY)
lines[i].args[6] = TMS_IFNOTENOUGH;
else
lines[i].args[6] = TMS_IFENOUGH;
if (lines[i].flags & ML_MIDPEG)
lines[i].args[7] |= TMI_BONUSLAPS;
if (lines[i].flags & ML_TFERLINE)
lines[i].args[7] |= TMI_ENTER;
}
break;
case 331: // Player skin - continuous
case 332: // Player skin - each time
case 333: // Player skin - once
if (lines[i].special == 303)
lines[i].args[0] = TMT_ONCE;
else if (lines[i].special == 302)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
lines[i].special = 331;
break;
case 334: // Object dye - continuous
case 335: // Object dye - each time
case 336: // Object dye - once
if (lines[i].special == 336)
lines[i].args[0] = TMT_ONCE;
else if (lines[i].special == 335)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
lines[i].special = 334;
break;
case 337: //Emerald check - continuous
case 338: //Emerald check - each time
case 339: //Emerald check - once
if (lines[i].special == 339)
lines[i].args[0] = TMT_ONCE;
else if (lines[i].special == 338)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].args[1] = EMERALD_ALLCHAOS;
lines[i].args[2] = TMF_HASALL;
lines[i].special = 337;
break;
case 340: //NiGHTS mare - continuous
case 341: //NiGHTS mare - each time
case 342: //NiGHTS mare - once
if (lines[i].special == 342)
lines[i].args[0] = TMT_ONCE;
else if (lines[i].special == 341)
lines[i].args[0] = (lines[i].flags & ML_NOTBOUNCY) ? TMT_EACHTIMEENTERANDEXIT : TMT_EACHTIMEENTER;
else
lines[i].args[0] = TMT_CONTINUOUS;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] = TMC_LTE;
else if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[2] = TMC_GTE;
else
lines[i].args[2] = TMC_EQUAL;
lines[i].special = 340;
break;
case 400: //Copy tagged sector's floor height/texture
case 401: //Copy tagged sector's ceiling height/texture
lines[i].args[0] = 0;
lines[i].args[1] = tag;
lines[i].args[2] = lines[i].special - 400;
lines[i].args[3] = !(lines[i].flags & ML_NOCLIMB);
lines[i].special = 400;
break;
case 402: //Copy light level
lines[i].args[0] = 0;
lines[i].args[1] = tag;
lines[i].args[2] = 0;
break;
case 403: //Copy-move tagged sector's floor height/texture
case 404: //Copy-move tagged sector's ceiling height/texture
lines[i].args[0] = 0;
lines[i].args[1] = tag;
lines[i].args[2] = (lines[i].special == 403) ? TMP_FLOOR : TMP_CEILING;
lines[i].args[3] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[4] = (lines[i].flags & ML_BLOCKPLAYERS) ? sides[lines[i].sidenum[0]].textureoffset >> FRACBITS : 0;
lines[i].args[5] = !!(lines[i].flags & ML_NOCLIMB);
lines[i].special = 403;
break;
case 405: //Move floor according to front texture offsets
case 407: //Move ceiling according to front texture offsets
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 405) ? TMP_FLOOR : TMP_CEILING;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[4] = !!(lines[i].flags & ML_NOCLIMB);
lines[i].special = 405;
break;
case 408: //Copy flats
lines[i].args[0] = 0;
lines[i].args[1] = tag;
if ((lines[i].flags & (ML_NOCLIMB|ML_MIDSOLID)) == (ML_NOCLIMB|ML_MIDSOLID))
{
CONS_Alert(CONS_WARNING, M_GetText("Copy flats linedef (tag %d) doesn't have anything to do.\nConsider changing the linedef's flag configuration or removing it entirely.\n"), tag);
lines[i].special = 0;
}
else if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] = TMP_CEILING;
else if (lines[i].flags & ML_MIDSOLID)
lines[i].args[2] = TMP_FLOOR;
else
lines[i].args[2] = TMP_BOTH;
break;
case 409: //Change tagged sector's tag
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] = TMT_ADD;
else if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[2] = TMT_REMOVE;
else
lines[i].args[2] = TMT_REPLACEFIRST;
break;
case 410: //Change front sector's tag
lines[i].args[0] = 0;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] = TMT_ADD;
else if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[2] = TMT_REMOVE;
else
lines[i].args[2] = TMT_REPLACEFIRST;
break;
case 411: //Stop plane movement
lines[i].args[0] = tag;
break;
case 412: //Teleporter
lines[i].args[0] = tag;
if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[1] |= TMT_SILENT;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[1] |= TMT_KEEPANGLE;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[1] |= TMT_KEEPMOMENTUM;
if (lines[i].flags & ML_MIDPEG)
lines[i].args[1] |= TMT_RELATIVE;
lines[i].args[2] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[4] = lines[i].frontsector->ceilingheight >> FRACBITS;
break;
case 414: //Play sound effect
lines[i].args[3] = tag;
if (tag != 0)
{
if (lines[i].flags & ML_WRAPMIDTEX)
{
lines[i].args[1] = TMSS_TAGGEDSECTOR;
lines[i].args[2] = TMSL_EVERYONE;
}
else
{
lines[i].args[1] = TMSS_NOWHERE;
lines[i].args[2] = TMSL_TAGGEDSECTOR;
}
}
else
{
if (lines[i].flags & ML_NOCLIMB)
{
lines[i].args[1] = TMSS_NOWHERE;
lines[i].args[2] = TMSL_TRIGGERER;
}
else if (lines[i].flags & ML_MIDSOLID)
{
lines[i].args[1] = TMSS_NOWHERE;
lines[i].args[2] = TMSL_EVERYONE;
}
else if (lines[i].flags & ML_BLOCKPLAYERS)
{
lines[i].args[1] = TMSS_TRIGGERSECTOR;
lines[i].args[2] = TMSL_EVERYONE;
}
else
{
lines[i].args[1] = TMSS_TRIGGERMOBJ;
lines[i].args[2] = TMSL_EVERYONE;
}
}
break;
case 416: //Start adjustable flickering light
case 417: //Start adjustable pulsating light
case 602: //Adjustable pulsating light
case 603: //Adjustable flickering light
lines[i].args[0] = tag;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[2] = lines[i].frontsector->lightlevel;
if ((lines[i].flags & ML_NOCLIMB) && lines[i].backsector)
lines[i].args[4] = lines[i].backsector->lightlevel;
else
lines[i].args[3] = 1;
break;
case 418: //Start adjustable blinking light (unsynchronized)
case 419: //Start adjustable blinking light (synchronized)
case 604: //Adjustable blinking light (unsynchronized)
case 605: //Adjustable blinking light (synchronized)
lines[i].args[0] = tag;
lines[i].args[1] = abs(lines[i].dx) >> FRACBITS;
lines[i].args[2] = abs(lines[i].dy) >> FRACBITS;
lines[i].args[3] = lines[i].frontsector->lightlevel;
if ((lines[i].flags & ML_NOCLIMB) && lines[i].backsector)
lines[i].args[5] = lines[i].backsector->lightlevel;
else
lines[i].args[4] |= TMB_USETARGET;
if (lines[i].special % 2 == 1)
{
lines[i].args[4] |= TMB_SYNC;
lines[i].special--;
}
break;
case 420: //Fade light level
lines[i].args[0] = tag;
if (lines[i].flags & ML_DONTPEGBOTTOM)
{
lines[i].args[1] = std::max<fixed_t>(sides[lines[i].sidenum[0]].textureoffset >> FRACBITS, 0);
// failsafe: if user specifies Back Y Offset and NOT Front Y Offset, use the Back Offset
// to be consistent with other light and fade specials
lines[i].args[2] = ((lines[i].sidenum[1] != 0xFFFF && !(sides[lines[i].sidenum[0]].rowoffset >> FRACBITS)) ?
std::max<fixed_t>(std::min<fixed_t>(sides[lines[i].sidenum[1]].rowoffset >> FRACBITS, 255), 0)
: std::max<fixed_t>(std::min<fixed_t>(sides[lines[i].sidenum[0]].rowoffset >> FRACBITS, 255), 0));
}
else
{
lines[i].args[1] = lines[i].frontsector->lightlevel;
lines[i].args[2] = abs(P_AproxDistance(lines[i].dx, lines[i].dy)) >> FRACBITS;
}
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[3] |= TMF_TICBASED;
if (lines[i].flags & ML_WRAPMIDTEX)
lines[i].args[3] |= TMF_OVERRIDE;
break;
case 421: //Stop lighting effect
lines[i].args[0] = tag;
break;
case 422: //Switch to cut-away view
lines[i].args[0] = tag;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[2] = (lines[i].flags & ML_NOCLIMB) ? sides[lines[i].sidenum[0]].textureoffset >> FRACBITS : 0;
break;
case 423: //Change sky
case 424: //Change weather
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 426: //Stop object
lines[i].args[0] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 427: //Award score
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
break;
case 428: //Start platform movement
lines[i].args[0] = tag;
lines[i].args[1] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[4] = (lines[i].flags & ML_NOCLIMB) ? 1 : 0;
break;
case 429: //Crush ceiling once
case 430: //Crush floor once
case 431: //Crush floor and ceiling once
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 429) ? TMP_CEILING : ((lines[i].special == 430) ? TMP_FLOOR : TMP_BOTH);
if (lines[i].special == 430 || lines[i].flags & ML_MIDSOLID)
{
lines[i].args[2] = abs(lines[i].dx) >> FRACBITS;
lines[i].args[3] = lines[i].args[2];
}
else
{
lines[i].args[2] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> (FRACBITS + 1);
lines[i].args[3] = lines[i].args[2] / 4;
}
lines[i].special = 429;
break;
case 432: //Enable/disable 2D mode
lines[i].args[0] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 433: //Enable/disable gravity flip
lines[i].args[0] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 435: //Change plane scroller direction
lines[i].args[0] = tag;
lines[i].args[1] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
lines[i].args[2] = AngleFixed(R_PointToAngle2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y)) >> FRACBITS;
break;
case 436: //Shatter FOF
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
break;
case 437: //Disable player control
lines[i].args[0] = ((sides[lines[i].sidenum[0]].textureoffset >> FRACBITS) != 0);
break;
case 438: //Change object size
lines[i].args[0] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
break;
case 439: //Change tagged linedef's textures
lines[i].args[0] = 0;
lines[i].args[1] = tag;
lines[i].args[2] = TMSD_FRONTBACK;
lines[i].args[3] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 441: //Condition set trigger
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
break;
case 442: //Change object type state
lines[i].args[2] = tag;
lines[i].args[3] = (lines[i].sidenum[1] == 0xffff) ? 1 : 0;
break;
case 444: //Earthquake
lines[i].args[0] = P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
break;
case 445: //Make FOF disappear/reappear
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 446: //Make FOF crumble
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] |= TMFR_NORETURN;
if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[2] |= TMFR_CHECKFLAG;
break;
case 447: //Change colormap
lines[i].args[0] = tag;
if (lines[i].flags & ML_MIDPEG)
lines[i].args[2] |= TMCF_RELATIVE;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[2] |= TMCF_SUBLIGHTR|TMCF_SUBFADER;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[2] |= TMCF_SUBLIGHTG|TMCF_SUBFADEG;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[2] |= TMCF_SUBLIGHTB|TMCF_SUBFADEB;
break;
case 448: //Change skybox
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if ((lines[i].flags & (ML_MIDSOLID|ML_BLOCKPLAYERS)) == ML_MIDSOLID) // Solid Midtexture is on but Block Enemies is off?
{
CONS_Alert(CONS_WARNING,
M_GetText("Skybox switch linedef (tag %d) doesn't have anything to do.\nConsider changing the linedef's flag configuration or removing it entirely.\n"),
tag);
lines[i].special = 0;
break;
}
else if ((lines[i].flags & (ML_MIDSOLID|ML_BLOCKPLAYERS)) == (ML_MIDSOLID|ML_BLOCKPLAYERS))
lines[i].args[2] = TMS_CENTERPOINT;
else if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[2] = TMS_BOTH;
else
lines[i].args[2] = TMS_VIEWPOINT;
lines[i].args[3] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 449: //Enable bosses with parameters
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 450: //Execute linedef executor (specific tag)
lines[i].args[0] = tag;
break;
case 451: //Execute linedef executor (random tag in range)
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
break;
case 452: //Set FOF translucency
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = lines[i].sidenum[1] != 0xffff ? (sides[lines[i].sidenum[1]].textureoffset >> FRACBITS) : (P_AproxDistance(lines[i].dx, lines[i].dy) >> FRACBITS);
if (lines[i].flags & ML_MIDPEG)
lines[i].args[3] |= TMST_RELATIVE;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] |= TMST_DONTDOTRANSLUCENT;
break;
case 453: //Fade FOF
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = lines[i].sidenum[1] != 0xffff ? (sides[lines[i].sidenum[1]].textureoffset >> FRACBITS) : (lines[i].dx >> FRACBITS);
lines[i].args[3] = lines[i].sidenum[1] != 0xffff ? (sides[lines[i].sidenum[1]].rowoffset >> FRACBITS) : (abs(lines[i].dy) >> FRACBITS);
if (lines[i].flags & ML_MIDPEG)
lines[i].args[4] |= TMFT_RELATIVE;
if (lines[i].flags & ML_WRAPMIDTEX)
lines[i].args[4] |= TMFT_OVERRIDE;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[4] |= TMFT_TICBASED;
if (lines[i].flags & ML_NOTBOUNCY)
lines[i].args[4] |= TMFT_IGNORECOLLISION;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[4] |= TMFT_GHOSTFADE;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[4] |= TMFT_DONTDOTRANSLUCENT;
if (lines[i].flags & ML_BLOCKPLAYERS)
lines[i].args[4] |= TMFT_DONTDOEXISTS;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[4] |= (TMFT_DONTDOLIGHTING|TMFT_DONTDOCOLORMAP);
if (lines[i].flags & ML_TFERLINE)
lines[i].args[4] |= TMFT_USEEXACTALPHA;
break;
case 454: //Stop fading FOF
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = !!(lines[i].flags & ML_BLOCKPLAYERS);
break;
case 455: //Fade colormap
{
INT32 speed = (INT32)((((lines[i].flags & ML_DONTPEGBOTTOM) || !sides[lines[i].sidenum[0]].rowoffset) && lines[i].sidenum[1] != 0xFFFF) ?
abs(sides[lines[i].sidenum[1]].rowoffset >> FRACBITS)
: abs(sides[lines[i].sidenum[0]].rowoffset >> FRACBITS));
lines[i].args[0] = tag;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[2] = speed;
else
lines[i].args[2] = (256 + speed - 1)/speed;
if (lines[i].flags & ML_MIDPEG)
lines[i].args[3] |= TMCF_RELATIVE;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[3] |= TMCF_SUBLIGHTR|TMCF_SUBFADER;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] |= TMCF_SUBLIGHTG|TMCF_SUBFADEG;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[3] |= TMCF_SUBLIGHTB|TMCF_SUBFADEB;
if (lines[i].flags & ML_NOTBOUNCY)
lines[i].args[3] |= TMCF_FROMBLACK;
if (lines[i].flags & ML_WRAPMIDTEX)
lines[i].args[3] |= TMCF_OVERRIDE;
break;
}
case 456: //Stop fading colormap
lines[i].args[0] = tag;
break;
case 457: //Track object's angle
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[3] = (lines[i].sidenum[1] != 0xffff) ? sides[lines[i].sidenum[1]].textureoffset >> FRACBITS : 0;
lines[i].args[4] = !!(lines[i].flags & ML_NOSKEW);
break;
case 460: //Award rings
lines[i].args[0] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[1] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[2] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 461: //Spawn object
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[3] = lines[i].frontsector->floorheight >> FRACBITS;
lines[i].args[4] = (lines[i].flags & ML_SKEWTD) ? AngleFixed(R_PointToAngle2(lines[i].v1->x, lines[i].v1->y, lines[i].v2->x, lines[i].v2->y)) >> FRACBITS : 0;
if (lines[i].flags & ML_NOCLIMB)
{
if (lines[i].sidenum[1] != 0xffff) // Make sure the linedef has a back side
{
lines[i].args[5] = 1;
lines[i].args[6] = sides[lines[i].sidenum[1]].textureoffset >> FRACBITS;
lines[i].args[7] = sides[lines[i].sidenum[1]].rowoffset >> FRACBITS;
lines[i].args[8] = lines[i].frontsector->ceilingheight >> FRACBITS;
}
else
{
CONS_Alert(CONS_WARNING, "Linedef Type %d - Spawn Object: Linedef is set for random range but has no back side.\n", lines[i].special);
lines[i].args[5] = 0;
}
}
else
lines[i].args[5] = 0;
break;
case 464: //Trigger egg capsule
lines[i].args[0] = tag;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 466: //Set level failure state
lines[i].args[0] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 467: //Set light level
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = TML_SECTOR;
lines[i].args[3] = !!(lines[i].flags & ML_MIDPEG);
break;
case 480: //Polyobject - door slide
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = AngleFixed(R_PointToAngle2(lines[i].v1->x, lines[i].v1->y, lines[i].v2->x, lines[i].v2->y)) >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if (lines[i].sidenum[1] != 0xffff)
lines[i].args[4] = sides[lines[i].sidenum[1]].textureoffset >> FRACBITS;
break;
case 481: //Polyobject - door swing
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if (lines[i].sidenum[1] != 0xffff)
lines[i].args[3] = sides[lines[i].sidenum[1]].textureoffset >> FRACBITS;
break;
case 482: //Polyobject - move
case 483: //Polyobject - move, override
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = AngleFixed(R_PointToAngle2(lines[i].v1->x, lines[i].v1->y, lines[i].v2->x, lines[i].v2->y)) >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
lines[i].args[4] = lines[i].special == 483;
lines[i].special = 482;
break;
case 484: //Polyobject - rotate right
case 485: //Polyobject - rotate right, override
case 486: //Polyobject - rotate left
case 487: //Polyobject - rotate left, override
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if (lines[i].args[2] == 360)
lines[i].args[3] |= TMPR_CONTINUOUS;
else if (lines[i].args[2] == 0)
lines[i].args[2] = 360;
if (lines[i].special < 486)
lines[i].args[2] *= -1;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[3] |= TMPR_DONTROTATEOTHERS;
else if (lines[i].flags & ML_MIDSOLID)
lines[i].args[3] |= TMPR_ROTATEPLAYERS;
if (lines[i].special % 2 == 1)
lines[i].args[3] |= TMPR_OVERRIDE;
lines[i].special = 484;
break;
case 488: //Polyobject - move by waypoints
lines[i].args[0] = tag;
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
if (lines[i].flags & ML_MIDPEG)
lines[i].args[3] = PWR_WRAP;
else if (lines[i].flags & ML_NOSKEW)
lines[i].args[3] = PWR_COMEBACK;
else
lines[i].args[3] = PWR_STOP;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[4] |= PWF_REVERSE;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[4] |= PWF_LOOP;
break;
case 489: //Polyobject - turn invisible, intangible
case 490: //Polyobject - turn visible, tangible
lines[i].args[0] = tag;
lines[i].args[1] = 491 - lines[i].special;
if (!(lines[i].flags & ML_NOCLIMB))
lines[i].args[2] = lines[i].args[1];
lines[i].special = 489;
break;
case 491: //Polyobject - set translucency
lines[i].args[0] = tag;
// If Front X Offset is specified, use that. Else, use floorheight.
lines[i].args[1] = (sides[lines[i].sidenum[0]].textureoffset ? sides[lines[i].sidenum[0]].textureoffset : lines[i].frontsector->floorheight) >> FRACBITS;
// If DONTPEGBOTTOM, specify raw translucency value. Else, take it out of 1000.
if (!(lines[i].flags & ML_DONTPEGBOTTOM))
lines[i].args[1] /= 100;
lines[i].args[2] = !!(lines[i].flags & ML_MIDPEG);
break;
case 492: //Polyobject - fade translucency
lines[i].args[0] = tag;
// If Front X Offset is specified, use that. Else, use floorheight.
lines[i].args[1] = (sides[lines[i].sidenum[0]].textureoffset ? sides[lines[i].sidenum[0]].textureoffset : lines[i].frontsector->floorheight) >> FRACBITS;
// If DONTPEGBOTTOM, specify raw translucency value. Else, take it out of 1000.
if (!(lines[i].flags & ML_DONTPEGBOTTOM))
lines[i].args[1] /= 100;
// allow Back Y Offset to be consistent with other fade specials
lines[i].args[2] = (lines[i].sidenum[1] != 0xffff && !sides[lines[i].sidenum[0]].rowoffset) ?
abs(sides[lines[i].sidenum[1]].rowoffset >> FRACBITS)
: abs(sides[lines[i].sidenum[0]].rowoffset >> FRACBITS);
if (lines[i].flags & ML_MIDPEG)
lines[i].args[3] |= TMPF_RELATIVE;
if (lines[i].flags & ML_WRAPMIDTEX)
lines[i].args[3] |= TMPF_OVERRIDE;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[3] |= TMPF_TICBASED;
if (lines[i].flags & ML_NOTBOUNCY)
lines[i].args[3] |= TMPF_IGNORECOLLISION;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[3] |= TMPF_GHOSTFADE;
break;
case 499: //Ring Racers - Toggle waypoints
lines[i].args[0] = tag;
lines[i].args[1] = !!(lines[i].flags & ML_NOCLIMB);
break;
case 500: //Scroll front wall left
case 501: //Scroll front wall right
lines[i].args[0] = 0;
lines[i].args[1] = ((lines[i].special == 500) ? -1 : 1) * (1 << SCROLL_SHIFT);
lines[i].args[2] = 0;
lines[i].special = 500;
break;
case 502: //Scroll tagged wall
case 503: //Scroll tagged wall (accelerative)
case 504: //Scroll tagged wall (displacement)
lines[i].args[0] = tag;
if (lines[i].flags & ML_MIDPEG)
{
if (lines[i].sidenum[1] == 0xffff)
{
CONS_Debug(DBG_GAMELOGIC, "Line special %d (line #%s) missing back side!\n", lines[i].special, sizeu1(i));
lines[i].special = 0;
break;
}
lines[i].args[1] = 1;
}
else
lines[i].args[1] = 0;
if (lines[i].flags & ML_NOSKEW)
{
lines[i].args[2] = sides[lines[i].sidenum[0]].textureoffset >> (FRACBITS - SCROLL_SHIFT);
lines[i].args[3] = sides[lines[i].sidenum[0]].rowoffset >> (FRACBITS - SCROLL_SHIFT);
}
else
{
lines[i].args[2] = lines[i].dx >> FRACBITS;
lines[i].args[3] = lines[i].dy >> FRACBITS;
}
lines[i].args[4] = lines[i].special - 502;
lines[i].special = 502;
break;
case 505: //Scroll front wall by front side offsets
case 506: //Scroll front wall by back side offsets
case 507: //Scroll back wall by front side offsets
case 508: //Scroll back wall by back side offsets
lines[i].args[0] = lines[i].special >= 507;
if (lines[i].special % 2 == 0)
{
if (lines[i].sidenum[1] == 0xffff)
{
CONS_Debug(DBG_GAMELOGIC, "Line special %d (line #%s) missing back side!\n", lines[i].special, sizeu1(i));
lines[i].special = 0;
break;
}
lines[i].args[1] = sides[lines[i].sidenum[1]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[1]].rowoffset >> FRACBITS;
}
else
{
lines[i].args[1] = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
lines[i].args[2] = sides[lines[i].sidenum[0]].rowoffset >> FRACBITS;
}
lines[i].special = 500;
break;
case 510: //Scroll floor texture
case 511: //Scroll floor texture (accelerative)
case 512: //Scroll floor texture (displacement)
case 513: //Scroll ceiling texture
case 514: //Scroll ceiling texture (accelerative)
case 515: //Scroll ceiling texture (displacement)
case 520: //Carry objects on floor
case 521: //Carry objects on floor (accelerative)
case 522: //Carry objects on floor (displacement)
case 523: //Carry objects on ceiling
case 524: //Carry objects on ceiling (accelerative)
case 525: //Carry objects on ceiling (displacement)
case 530: //Scroll floor texture and carry objects
case 531: //Scroll floor texture and carry objects (accelerative)
case 532: //Scroll floor texture and carry objects (displacement)
case 533: //Scroll ceiling texture and carry objects
case 534: //Scroll ceiling texture and carry objects (accelerative)
case 535: //Scroll ceiling texture and carry objects (displacement)
lines[i].args[0] = tag;
lines[i].args[1] = ((lines[i].special % 10) < 3) ? TMP_FLOOR : TMP_CEILING;
lines[i].args[2] = ((lines[i].special - 510)/10 + 1) % 3;
lines[i].args[3] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
lines[i].args[4] = (lines[i].special % 10) % 3;
if (lines[i].args[2] != TMS_SCROLLONLY && !(lines[i].flags & ML_NOCLIMB))
lines[i].args[4] |= TMST_NONEXCLUSIVE;
lines[i].special = 510;
break;
case 540: //Floor friction
{
INT32 s;
fixed_t strength; // friction value of sector
fixed_t friction; // friction value to be applied during movement
strength = sides[lines[i].sidenum[0]].textureoffset >> FRACBITS;
if (strength > 0) // sludge
strength = strength*2; // otherwise, the maximum sludginess value is +967...
// The following might seem odd. At the time of movement,
// the move distance is multiplied by 'friction/0x10000', so a
// higher friction value actually means 'less friction'.
friction = ORIG_FRICTION - (0x1EB8*strength)/0x80; // ORIG_FRICTION is 0xE800
TAG_ITER_SECTORS(tag, s)
sectors[s].friction = friction;
break;
}
case 541: //Wind
case 542: //Upwards wind
case 543: //Downwards wind
case 544: //Current
case 545: //Upwards current
case 546: //Downwards current
lines[i].args[0] = tag;
switch ((lines[i].special - 541) % 3)
{
case 0:
lines[i].args[1] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
break;
case 1:
lines[i].args[2] = R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
break;
case 2:
lines[i].args[2] = -R_PointToDist2(lines[i].v2->x, lines[i].v2->y, lines[i].v1->x, lines[i].v1->y) >> FRACBITS;
break;
}
lines[i].args[3] = (lines[i].special >= 544) ? p_current : p_wind;
if (lines[i].flags & ML_MIDSOLID)
lines[i].args[4] |= TMPF_SLIDE;
if (!(lines[i].flags & ML_NOCLIMB))
lines[i].args[4] |= TMPF_NONEXCLUSIVE;
lines[i].special = 541;
break;
case 600: //Floor lighting
case 601: //Ceiling lighting
lines[i].args[0] = tag;
lines[i].args[1] = (lines[i].special == 601) ? TMP_CEILING : TMP_FLOOR;
lines[i].special = 600;
break;
case 606: //Colormap
lines[i].args[0] = tag;
break;
case 700: //Slope front sector floor
case 701: //Slope front sector ceiling
case 702: //Slope front sector floor and ceiling
case 703: //Slope front sector floor and back sector ceiling
case 710: //Slope back sector floor
case 711: //Slope back sector ceiling
case 712: //Slope back sector floor and ceiling
case 713: //Slope back sector floor and front sector ceiling
{
boolean frontfloor = (lines[i].special == 700 || lines[i].special == 702 || lines[i].special == 703);
boolean backfloor = (lines[i].special == 710 || lines[i].special == 712 || lines[i].special == 713);
boolean frontceil = (lines[i].special == 701 || lines[i].special == 702 || lines[i].special == 713);
boolean backceil = (lines[i].special == 711 || lines[i].special == 712 || lines[i].special == 703);
lines[i].args[0] = backfloor ? TMS_BACK : (frontfloor ? TMS_FRONT : TMS_NONE);
lines[i].args[1] = backceil ? TMS_BACK : (frontceil ? TMS_FRONT : TMS_NONE);
if (lines[i].flags & ML_NETONLY)
lines[i].args[2] |= TMSL_NOPHYSICS;
if (lines[i].flags & ML_NONET)
lines[i].args[2] |= TMSL_DYNAMIC;
if (lines[i].flags & ML_TFERLINE)
lines[i].args[2] |= TMSL_COPY;
lines[i].special = 700;
break;
}
case 704: //Slope front sector floor by 3 tagged vertices
case 705: //Slope front sector ceiling by 3 tagged vertices
case 714: //Slope back sector floor by 3 tagged vertices
case 715: //Slope back sector ceiling by 3 tagged vertices
{
if (lines[i].special == 704)
lines[i].args[0] = TMSP_FRONTFLOOR;
else if (lines[i].special == 705)
lines[i].args[0] = TMSP_FRONTCEILING;
else if (lines[i].special == 714)
lines[i].args[0] = TMSP_BACKFLOOR;
else if (lines[i].special == 715)
lines[i].args[0] = TMSP_BACKCEILING;
lines[i].args[1] = tag;
if (lines[i].flags & ML_BLOCKMONSTERS)
{
UINT8 side = lines[i].special >= 714;
if (side == 1 && lines[i].sidenum[1] == 0xffff)
CONS_Debug(DBG_GAMELOGIC, "P_ConvertBinaryMap: Line special %d (line #%s) missing 2nd side!\n", lines[i].special, sizeu1(i));
else
{
lines[i].args[2] = sides[lines[i].sidenum[side]].textureoffset >> FRACBITS;
lines[i].args[3] = sides[lines[i].sidenum[side]].rowoffset >> FRACBITS;
}
}
else
{
lines[i].args[2] = lines[i].args[1];
lines[i].args[3] = lines[i].args[1];
}
if (lines[i].flags & ML_NETONLY)
lines[i].args[4] |= TMSL_NOPHYSICS;
if (lines[i].flags & ML_NONET)
lines[i].args[4] |= TMSL_DYNAMIC;
lines[i].special = 704;
break;
}
case 720: //Copy front side floor slope
case 721: //Copy front side ceiling slope
case 722: //Copy front side floor and ceiling slope
if (lines[i].special != 721)
lines[i].args[0] = tag;
if (lines[i].special != 720)
lines[i].args[1] = tag;
lines[i].special = 720;
break;
case 723: //Copy back side floor slope
case 724: //Copy back side ceiling slope
case 725: //Copy back side floor and ceiling slope
if (lines[i].special != 724)
lines[i].args[2] = tag;
if (lines[i].special != 723)
lines[i].args[3] = tag;
lines[i].special = 720;
break;
case 730: //Copy front side floor slope to back side
case 731: //Copy front side ceiling slope to back side
case 732: //Copy front side floor and ceiling slope to back side
if (lines[i].special != 731)
lines[i].args[4] |= TMSC_FRONTTOBACKFLOOR;
if (lines[i].special != 730)
lines[i].args[4] |= TMSC_FRONTTOBACKCEILING;
lines[i].special = 720;
break;
case 733: //Copy back side floor slope to front side
case 734: //Copy back side ceiling slope to front side
case 735: //Copy back side floor and ceiling slope to front side
if (lines[i].special != 734)
lines[i].args[4] |= TMSC_BACKTOFRONTFLOOR;
if (lines[i].special != 733)
lines[i].args[4] |= TMSC_BACKTOFRONTCEILING;
lines[i].special = 720;
break;
case 799: //Set dynamic slope vertex to front sector height
lines[i].args[0] = !!(lines[i].flags & ML_NOCLIMB);
break;
case LT_SLOPE_ANCHORS_OLD_FLOOR: //Slope front sector floor by 3 tagged vertices
case LT_SLOPE_ANCHORS_OLD_CEILING: //Slope front sector ceiling by 3 tagged vertices
case LT_SLOPE_ANCHORS_OLD: //Slope back sector floor by 3 tagged vertices
{
if (lines[i].special == LT_SLOPE_ANCHORS_OLD_FLOOR)
lines[i].args[0] = TMSA_FLOOR;
else if (lines[i].special == LT_SLOPE_ANCHORS_OLD_CEILING)
lines[i].args[0] = TMSA_CEILING;
else if (lines[i].special == LT_SLOPE_ANCHORS_OLD)
lines[i].args[0] = (TMSA_FLOOR|TMSA_CEILING);
if (lines[i].flags & ML_NETONLY)
lines[i].args[1] |= TMSAF_NOPHYSICS;
if (lines[i].flags & ML_NONET)
lines[i].args[1] |= TMSAF_DYNAMIC;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[1] |= TMSAF_BACKSIDE;
if (lines[i].flags & ML_BLOCKMONSTERS)
lines[i].args[1] |= TMSAF_MIRROR;
lines[i].args[2] = tag;
lines[i].special = LT_SLOPE_ANCHORS;
break;
}
case 909: //Fog wall
lines[i].blendmode = AST_FOG;
break;
case 2001: //Finish line
lines[i].activation |= (SPAC_CROSS|SPAC_REPEATSPECIAL);
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[0] |= TMCFF_FLIP;
break;
case 2003: //Respawn line
lines[i].activation |= (SPAC_CROSS|SPAC_REPEATSPECIAL);
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[0] |= TMCRF_FRONTONLY;
break;
case 2004: //Bot controller
lines[i].args[0] = sides[lines[i].sidenum[0]].rowoffset / FRACUNIT;
if (lines[i].flags & ML_NOCLIMB)
lines[i].args[1] |= TMBOT_NORUBBERBAND;
if (lines[i].flags & ML_NOSKEW)
lines[i].args[1] |= TMBOT_NOCONTROL;
if (lines[i].flags & ML_SKEWTD)
lines[i].args[1] |= TMBOT_FORCEDIR;
lines[i].args[2] = sides[lines[i].sidenum[0]].textureoffset / FRACUNIT;
break;
default:
break;
}
// Set alpha for translucent walls
if (lines[i].special >= 900 && lines[i].special < 909)
lines[i].alpha = ((909 - lines[i].special) << FRACBITS)/10;
// Set alpha for additive/subtractive/reverse subtractive walls
if (lines[i].special >= 910 && lines[i].special <= 939)
lines[i].alpha = ((10 - lines[i].special % 10) << FRACBITS)/10;
if (lines[i].special >= 910 && lines[i].special <= 919) // additive
lines[i].blendmode = AST_ADD;
if (lines[i].special >= 920 && lines[i].special <= 929) // subtractive
lines[i].blendmode = AST_SUBTRACT;
if (lines[i].special >= 930 && lines[i].special <= 939) // reverse subtractive
lines[i].blendmode = AST_REVERSESUBTRACT;
if (lines[i].special == 940) // modulate
lines[i].blendmode = AST_MODULATE;
//Linedef executor delay
if (lines[i].special >= 400 && lines[i].special < 500)
{
//Dummy value to indicate that this executor is delayed.
//The real value is taken from the back sector at runtime.
if (lines[i].flags & ML_DONTPEGTOP)
lines[i].executordelay = 1;
}
}
}
static void P_ConvertBinarySectorTypes(void)
{
size_t i;
for (i = 0; i < numsectors; i++)
{
mtag_t tag = Tag_FGet(&sectors[i].tags);
switch(GETSECSPECIAL(sectors[i].special, 1))
{
case 1: //Damage
sectors[i].damagetype = SD_GENERIC;
break;
case 2: //Offroad (Weak)
CONS_Alert(CONS_WARNING, "Offroad specials will be deprecated soon. Use the TERRAIN effect!\n");
sectors[i].offroad = FRACUNIT;
break;
case 3: //Offroad
CONS_Alert(CONS_WARNING, "Offroad specials will be deprecated soon. Use the TERRAIN effect!\n");
sectors[i].offroad = 2*FRACUNIT;
break;
case 4: //Offroad (Strong)
CONS_Alert(CONS_WARNING, "Offroad specials will be deprecated soon. Use the TERRAIN effect!\n");
sectors[i].offroad = 3*FRACUNIT;
break;
case 5: //Spikes
sectors[i].damagetype = SD_GENERIC;
break;
case 6: //Death pit (camera tilt)
case 7: //Death pit (no camera tilt)
sectors[i].damagetype = SD_DEATHPIT;
break;
case 8: //Instakill
sectors[i].damagetype = SD_INSTAKILL;
break;
//case 9: -- Ring Drainer (Floor Touch)
//case 10: -- Ring Drainer (No Floor Touch)
case 11: // Stumble
sectors[i].damagetype = SD_STUMBLE;
break;
case 12: //Wall sector
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_NOSTEPUP);
break;
case 13: //Ramp sector
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_DOUBLESTEPUP);
break;
case 14: //Non-ramp sector
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_NOSTEPDOWN);
break;
default:
break;
}
switch(GETSECSPECIAL(sectors[i].special, 2))
{
case 1: //Trigger linedef executor (pushable objects)
sectors[i].triggertag = tag;
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_TRIGGERLINE_PLANE);
sectors[i].triggerer = TO_MOBJ;
break;
case 2: //Trigger linedef executor (Anywhere in sector, all players)
sectors[i].triggertag = tag;
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags & ~MSF_TRIGGERLINE_PLANE);
sectors[i].triggerer = TO_ALLPLAYERS;
break;
case 3: //Trigger linedef executor (Floor touch, all players)
sectors[i].triggertag = tag;
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_TRIGGERLINE_PLANE);
sectors[i].triggerer = TO_ALLPLAYERS;
break;
case 4: //Trigger linedef executor (Anywhere in sector)
sectors[i].triggertag = tag;
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags & ~MSF_TRIGGERLINE_PLANE);
sectors[i].triggerer = TO_PLAYER;
break;
case 5: //Trigger linedef executor (Floor touch)
sectors[i].triggertag = tag;
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_TRIGGERLINE_PLANE);
sectors[i].triggerer = TO_PLAYER;
break;
case 8: //Check for linedef executor on FOFs
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_TRIGGERLINE_MOBJ);
break;
case 15: //Invert Encore
sectors[i].flags = static_cast<sectorflags_t>(sectors[i].flags | MSF_INVERTENCORE);
break;
default:
break;
}
switch(GETSECSPECIAL(sectors[i].special, 3))
{
case 1: //Trick panel
case 3:
CONS_Alert(CONS_WARNING, "Trick Panel special is deprecated. Use the TERRAIN effect!\n");
break;
case 5: //Speed pad
CONS_Alert(CONS_WARNING, "Speed Pad special is deprecated. Use the TERRAIN effect!\n");
break;
default:
break;
}
switch(GETSECSPECIAL(sectors[i].special, 4))
{
case 1: //Cheat Check activator
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_CHEATCHECKACTIVATOR);
break;
case 2: //Exit
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_EXIT);
break;
case 5: //Fan sector
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_FAN);
break;
case 6: //Sneaker panel
CONS_Alert(CONS_WARNING, "Sneaker Panel special is deprecated. Use the TERRAIN effect!\n");
break;
case 7: //Destroy items
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_DELETEITEMS);
break;
case 8: //Zoom tube start
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_ZOOMTUBESTART);
break;
case 9: //Zoom tube end
sectors[i].specialflags = static_cast<sectorspecialflags_t>(sectors[i].specialflags | SSF_ZOOMTUBEEND);
break;
default:
break;
}
}
}
static void P_ConvertBinaryThingTypes(void)
{
size_t i;
mobjtype_t mobjtypeofthing[4096] {};
mobjtype_t mobjtype;
for (i = 0; i < NUMMOBJTYPES; i++)
{
if (mobjinfo[i].doomednum < 0 || mobjinfo[i].doomednum >= 4096)
continue;
mobjtypeofthing[mobjinfo[i].doomednum] = (mobjtype_t)i;
}
for (i = 0; i < nummapthings; i++)
{
mobjtype = mobjtypeofthing[mapthings[i].type];
if (mobjtype)
{
if (mobjinfo[mobjtype].flags & MF_BOSS)
{
INT32 paramoffset = mapthings[i].extrainfo*LE_PARAMWIDTH;
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_OBJECTSPECIAL);
mapthings[i].thing_args[2] = LE_BOSSDEAD + paramoffset;
mapthings[i].thing_args[3] = LE_ALLBOSSESDEAD + paramoffset;
mapthings[i].thing_args[4] = LE_PINCHPHASE + paramoffset;
}
if (mobjinfo[mobjtype].flags & MF_PUSHABLE)
{
if ((mapthings[i].options & (MTF_OBJECTSPECIAL|MTF_AMBUSH)) == (MTF_OBJECTSPECIAL|MTF_AMBUSH))
mapthings[i].thing_args[0] = TMP_CLASSIC;
else if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[0] = TMP_SLIDE;
else if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[0] = TMP_IMMOVABLE;
else
mapthings[i].thing_args[0] = TMP_NORMAL;
}
if (K_IsDuelItem(mobjtype) == true)
{
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_EXTRA);
}
}
if (mapthings[i].type >= 1 && mapthings[i].type <= 35) //Player starts
{
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
continue;
}
else if (mapthings[i].type >= 2200 && mapthings[i].type <= 2217) //Flickies
{
mapthings[i].thing_args[0] = mapthings[i].angle;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[1] |= TMFF_AIMLESS;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[1] |= TMFF_STATIONARY;
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[1] |= TMFF_HOP;
if (mapthings[i].type == 2207)
mapthings[i].thing_args[2] = mapthings[i].extrainfo;
continue;
}
switch (mapthings[i].type)
{
case 102: //SDURF
case 1805: //Puma
mapthings[i].thing_args[0] = mapthings[i].angle;
break;
case 110: //THZ Turret
mapthings[i].thing_args[0] = LE_TURRET;
break;
case 111: //Pop-up Turret
mapthings[i].thing_args[0] = mapthings[i].angle;
break;
case 103: //Buzz (Gold)
case 104: //Buzz (Red)
case 105: //Jetty-syn Bomber
case 106: //Jetty-syn Gunner
case 117: //Robo-Hood
case 126: //Crushstacean
case 128: //Bumblebore
case 132: //Cacolantern
case 138: //Banpyura
case 1602: //Pian
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 119: //Egg Guard
if ((mapthings[i].options & (MTF_EXTRA|MTF_OBJECTSPECIAL)) == MTF_OBJECTSPECIAL)
mapthings[i].thing_args[0] = TMGD_LEFT;
else if ((mapthings[i].options & (MTF_EXTRA|MTF_OBJECTSPECIAL)) == MTF_EXTRA)
mapthings[i].thing_args[0] = TMGD_RIGHT;
else
mapthings[i].thing_args[0] = TMGD_BACK;
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 127: //Hive Elemental
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
break;
case 135: //Pterabyte Spawner
mapthings[i].thing_args[0] = mapthings[i].extrainfo + 1;
break;
case 136: //Pyre Fly
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 201: //Egg Slimer
mapthings[i].thing_args[5] = !(mapthings[i].options & MTF_AMBUSH);
break;
case 203: //Egg Colosseum
mapthings[i].thing_args[5] = LE_BOSS4DROP + mapthings[i].extrainfo * LE_PARAMWIDTH;
break;
case 204: //Fang
mapthings[i].thing_args[4] = LE_BOSS4DROP + mapthings[i].extrainfo*LE_PARAMWIDTH;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[5] |= TMF_GRAYSCALE;
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[5] |= TMF_SKIPINTRO;
break;
case 206: //Brak Eggman (Old)
mapthings[i].thing_args[5] = LE_BRAKPLATFORM + mapthings[i].extrainfo*LE_PARAMWIDTH;
break;
case 207: //Metal Sonic (Race)
case 2104: //Amy Cameo
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_EXTRA);
break;
case 208: //Metal Sonic (Battle)
mapthings[i].thing_args[5] = !!(mapthings[i].options & MTF_EXTRA);
break;
case 209: //Brak Eggman
mapthings[i].thing_args[5] = LE_BRAKVILEATACK + mapthings[i].extrainfo*LE_PARAMWIDTH;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[6] |= TMB_NODEATHFLING;
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[6] |= TMB_BARRIER;
break;
case 292: //Boss waypoint
mapthings[i].thing_args[0] = mapthings[i].angle;
mapthings[i].thing_args[1] = mapthings[i].options & 7;
break;
case 294: //Fang waypoint
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 300: //Ring
case 301: //Bounce ring
case 302: //Rail ring
case 303: //Infinity ring
case 304: //Automatic ring
case 305: //Explosion ring
case 306: //Scatter ring
case 307: //Grenade ring
case 308: //Red team ring
case 309: //Blue team ring
case 312: //Emerald token
case 320: //Emerald hunt location
case 321: //Match chaos emerald spawn
case 322: //Emblem
case 330: //Bounce ring panel
case 331: //Rail ring panel
case 332: //Automatic ring panel
case 333: //Explosion ring panel
case 334: //Scatter ring panel
case 335: //Grenade ring panel
case 520: //Bomb sphere
case 521: //Spikeball
case 1706: //Blue sphere
case 1800: //Coin
mapthings[i].thing_args[0] = !(mapthings[i].options & MTF_AMBUSH);
break;
case 409: //Extra life monitor
mapthings[i].thing_args[2] = !(mapthings[i].options & (MTF_AMBUSH|MTF_OBJECTSPECIAL));
break;
case 500: //Air bubble patch
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 502: //Cheat Check
if (mapthings[i].extrainfo)
// Allow thing Parameter to define star post num too!
// For cheatchecks above param 15 (the 16th), add 360 to the angle like before and start parameter from 1 (NOT 0)!
// So the 16th cheatcheck is angle=0 param=15, the 17th would be angle=360 param=1.
// This seems more intuitive for mappers to use, since most SP maps won't have over 16 consecutive star posts.
mapthings[i].thing_args[0] = mapthings[i].extrainfo + (mapthings[i].angle/360) * 15;
else
// Old behavior if Parameter is 0; add 360 to the angle for each consecutive star post.
mapthings[i].thing_args[0] = (mapthings[i].angle/360);
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_OBJECTSPECIAL);
break;
case 522: //Wall spike
if (mapthings[i].options & MTF_OBJECTSPECIAL)
{
mapthings[i].thing_args[0] = mobjinfo[MT_WALLSPIKE].speed + mapthings[i].angle/360;
mapthings[i].thing_args[1] = (16 - mapthings[i].extrainfo) * mapthings[i].thing_args[0]/16;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[2] |= TMSF_RETRACTED;
}
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[2] |= TMSF_INTANGIBLE;
break;
case 523: //Spike
if (mapthings[i].options & MTF_OBJECTSPECIAL)
{
mapthings[i].thing_args[0] = mobjinfo[MT_SPIKE].speed + mapthings[i].angle;
mapthings[i].thing_args[1] = (16 - mapthings[i].extrainfo) * mapthings[i].thing_args[0]/16;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[2] |= TMSF_RETRACTED;
}
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[2] |= TMSF_INTANGIBLE;
break;
case 540: //Fan
mapthings[i].thing_args[0] = mapthings[i].angle;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[1] |= TMF_INVISIBLE;
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[1] |= TMF_NODISTANCECHECK;
break;
case 541: //Gas jet
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_OBJECTSPECIAL);
break;
case 543: //Balloon
if (mapthings[i].angle > 0)
{
P_WriteSkincolor(((mapthings[i].angle - 1) % (numskincolors - 1)) + 1, &mapthings[i].thing_stringargs[0]);
}
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 555: //Diagonal yellow spring
case 556: //Diagonal red spring
case 557: //Diagonal blue spring
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[0] |= TMDS_NOGRAVITY;
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[0] |= TMDS_ROTATEEXTRA;
break;
case 558: //Horizontal yellow spring
case 559: //Horizontal red spring
case 560: //Horizontal blue spring
mapthings[i].thing_args[0] = !(mapthings[i].options & MTF_AMBUSH);
break;
case 700: //Water ambience A
case 701: //Water ambience B
case 702: //Water ambience C
case 703: //Water ambience D
case 704: //Water ambience E
case 705: //Water ambience F
case 706: //Water ambience G
case 707: //Water ambience H
mapthings[i].thing_args[0] = 35;
P_WriteSfx(sfx_amwtr1 + mapthings[i].type - 700, &mapthings[i].thing_stringargs[0]);
mapthings[i].type = 700;
break;
case 708: //Disco ambience
mapthings[i].thing_args[0] = 512;
P_WriteSfx(sfx_ambint, &mapthings[i].thing_stringargs[0]);
mapthings[i].type = 700;
break;
case 709: //Volcano ambience
mapthings[i].thing_args[0] = 220;
P_WriteSfx(sfx_ambin2, &mapthings[i].thing_stringargs[0]);
mapthings[i].type = 700;
break;
case 710: //Machine ambience
mapthings[i].thing_args[0] = 24;
P_WriteSfx(sfx_ambmac, &mapthings[i].thing_stringargs[0]);
mapthings[i].type = 700;
break;
case 750: //Slope vertex
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
break;
case 753: //Zoom tube waypoint
mapthings[i].thing_args[0] = mapthings[i].angle >> 8;
mapthings[i].thing_args[1] = mapthings[i].angle & 255;
break;
case 754: //Push point
case 755: //Pull point
{
subsector_t *ss = R_PointInSubsector(mapthings[i].x << FRACBITS, mapthings[i].y << FRACBITS);
sector_t *s;
line_t *line;
if (!ss)
{
CONS_Debug(DBG_GAMELOGIC, "Push/pull point: Placed outside of map bounds!\n");
break;
}
s = ss->sector;
line = P_FindPointPushLine(&s->tags);
if (!line)
{
CONS_Debug(DBG_GAMELOGIC, "Push/pull point: Unable to find line of type 547 tagged to sector %s!\n", sizeu1((size_t)(s - sectors)));
break;
}
mapthings[i].thing_args[0] = mapthings[i].angle;
mapthings[i].thing_args[1] = P_AproxDistance(line->dx >> FRACBITS, line->dy >> FRACBITS);
if (mapthings[i].type == 755)
mapthings[i].thing_args[1] *= -1;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[2] |= TMPP_NOZFADE;
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[2] |= TMPP_PUSHZ;
if (!(line->flags & ML_NOCLIMB))
mapthings[i].thing_args[2] |= TMPP_NONEXCLUSIVE;
mapthings[i].type = 754;
break;
}
case 756: //Blast linedef executor
mapthings[i].thing_args[0] = mapthings[i].angle;
break;
case 757: //Fan particle generator
{
INT32 j = Tag_FindLineSpecial(15, mapthings[i].angle);
if (j == -1)
{
CONS_Debug(DBG_GAMELOGIC, "Particle generator (mapthing #%s) needs to be tagged to a #15 parameter line (trying to find tag %d).\n", sizeu1(i), mapthings[i].angle);
break;
}
mapthings[i].thing_args[0] = mapthings[i].z;
mapthings[i].thing_args[1] = R_PointToDist2(lines[j].v1->x, lines[j].v1->y, lines[j].v2->x, lines[j].v2->y) >> FRACBITS;
mapthings[i].thing_args[2] = sides[lines[j].sidenum[0]].textureoffset >> FRACBITS;
mapthings[i].thing_args[3] = sides[lines[j].sidenum[0]].rowoffset >> FRACBITS;
mapthings[i].thing_args[4] = lines[j].backsector ? sides[lines[j].sidenum[1]].textureoffset >> FRACBITS : 0;
mapthings[i].thing_args[6] = mapthings[i].angle;
P_WriteDuplicateText(lines[j].stringargs[0], &mapthings[i].thing_stringargs[0]);
break;
}
case 762: //PolyObject spawn point (crush)
{
INT32 check = -1;
INT32 firstline = -1;
TAG_ITER_LINES(mapthings[i].tid, check)
{
if (lines[check].special == 20)
{
firstline = check;
break;
}
}
if (firstline != -1)
lines[firstline].args[3] |= TMPF_CRUSH;
mapthings[i].type = 761;
break;
}
case 780: //Skybox
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_OBJECTSPECIAL);
break;
case 799: //Tutorial plant
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
break;
case 1002: //Dripping water
mapthings[i].thing_args[0] = mapthings[i].angle;
break;
case 1007: //Kelp
case 1008: //Stalagmite (DSZ1)
case 1011: //Stalagmite (DSZ2)
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_OBJECTSPECIAL);
break;
case 1102: //Eggman Statue
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_EXTRA);
break;
case 1104: //Mace spawnpoint
case 1105: //Chain with maces spawnpoint
case 1106: //Chained spring spawnpoint
case 1107: //Chain spawnpoint
case 1109: //Firebar spawnpoint
case 1110: //Custom mace spawnpoint
{
mtag_t tag = (mtag_t)mapthings[i].angle;
INT32 j = Tag_FindLineSpecial(9, tag);
if (j == -1)
{
CONS_Debug(DBG_GAMELOGIC, "Chain/mace setup: Unable to find parameter line 9 (tag %d)!\n", tag);
break;
}
mapthings[i].angle = lines[j].frontsector->ceilingheight >> FRACBITS;
mapthings[i].pitch = lines[j].frontsector->floorheight >> FRACBITS;
mapthings[i].thing_args[0] = lines[j].dx >> FRACBITS;
mapthings[i].thing_args[1] = mapthings[i].extrainfo;
mapthings[i].thing_args[3] = lines[j].dy >> FRACBITS;
mapthings[i].thing_args[4] = sides[lines[j].sidenum[0]].textureoffset >> FRACBITS;
mapthings[i].thing_args[7] = -sides[lines[j].sidenum[0]].rowoffset >> FRACBITS;
if (lines[j].backsector)
{
mapthings[i].roll = lines[j].backsector->ceilingheight >> FRACBITS;
mapthings[i].thing_args[2] = sides[lines[j].sidenum[1]].rowoffset >> FRACBITS;
mapthings[i].thing_args[5] = lines[j].backsector->floorheight >> FRACBITS;
mapthings[i].thing_args[6] = sides[lines[j].sidenum[1]].textureoffset >> FRACBITS;
}
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[8] |= TMM_DOUBLESIZE;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[8] |= TMM_SILENT;
if (lines[j].flags & ML_NOCLIMB)
mapthings[i].thing_args[8] |= TMM_ALLOWYAWCONTROL;
if (lines[j].flags & ML_SKEWTD)
mapthings[i].thing_args[8] |= TMM_SWING;
if (lines[j].flags & ML_NOSKEW)
mapthings[i].thing_args[8] |= TMM_MACELINKS;
if (lines[j].flags & ML_MIDPEG)
mapthings[i].thing_args[8] |= TMM_CENTERLINK;
if (lines[j].flags & ML_MIDSOLID)
mapthings[i].thing_args[8] |= TMM_CLIP;
if (lines[j].flags & ML_WRAPMIDTEX)
mapthings[i].thing_args[8] |= TMM_ALWAYSTHINK;
if (mapthings[i].type == 1110)
{
P_WriteDuplicateText(lines[j].stringargs[0], &mapthings[i].thing_stringargs[0]);
P_WriteDuplicateText(lines[j].stringargs[1], &mapthings[i].thing_stringargs[1]);
}
break;
}
case 1101: //Torch
case 1119: //Candle
case 1120: //Candle pricket
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_EXTRA);
break;
case 1121: //Flame holder
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[0] |= TMFH_NOFLAME;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[0] |= TMFH_CORONA;
break;
case 1127: //Spectator EggRobo
if (mapthings[i].options & MTF_AMBUSH)
mapthings[i].thing_args[0] = TMED_LEFT;
else if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[0] = TMED_RIGHT;
else
mapthings[i].thing_args[0] = TMED_NONE;
break;
case 1200: //Tumbleweed (Big)
case 1201: //Tumbleweed (Small)
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1202: //Rock spawner
{
mtag_t tag = (mtag_t)mapthings[i].angle;
INT32 j = Tag_FindLineSpecial(12, tag);
if (j == -1)
{
CONS_Debug(DBG_GAMELOGIC, "Rock spawner: Unable to find parameter line 12 (tag %d)!\n", tag);
break;
}
mapthings[i].angle = AngleFixed(R_PointToAngle2(lines[j].v2->x, lines[j].v2->y, lines[j].v1->x, lines[j].v1->y)) >> FRACBITS;
mapthings[i].thing_args[0] = P_AproxDistance(lines[j].dx, lines[j].dy) >> FRACBITS;
mapthings[i].thing_args[1] = sides[lines[j].sidenum[0]].textureoffset >> FRACBITS;
mapthings[i].thing_args[2] = !!(lines[j].flags & ML_NOCLIMB);
INT32 id = (sides[lines[j].sidenum[0]].rowoffset >> FRACBITS);
// Rather than introduce deh_tables.h as a dependency for literally one
// conversion, we just... recreate the string expected to be produced.
if (id > 0 && id < 16)
P_WriteDuplicateText(va("MT_ROCKCRUMBLE%d", id+1), &mapthings[i].thing_stringargs[0]);
break;
}
case 1221: //Minecart saloon door
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1229: //Minecart switch point
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1300: //Flame jet (horizontal)
case 1301: //Flame jet (vertical)
mapthings[i].thing_args[0] = (mapthings[i].angle >> 13)*TICRATE/2;
mapthings[i].thing_args[1] = ((mapthings[i].angle >> 10) & 7)*TICRATE/2;
mapthings[i].thing_args[2] = 80 - 5*mapthings[i].extrainfo;
mapthings[i].thing_args[3] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1304: //Lavafall
mapthings[i].thing_args[0] = mapthings[i].angle;
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1305: //Rollout Rock
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1488: // Follower Audience (unfortunately numbered)
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[2] |= TMAUDIM_FLOAT;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[2] |= TMAUDIM_BORED;
mapthings[i].thing_args[3] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1500: //Glaregoyle
case 1501: //Glaregoyle (Up)
case 1502: //Glaregoyle (Down)
case 1503: //Glaregoyle (Long)
if (mapthings[i].angle >= 360)
mapthings[i].thing_args[1] = 7*(mapthings[i].angle/360) + 1;
break;
case 1700: //Axis
mapthings[i].thing_args[2] = mapthings[i].angle & 16383;
mapthings[i].thing_args[3] = !!(mapthings[i].angle & 16384);
/* FALLTHRU */
case 1701: //Axis transfer
case 1702: //Axis transfer line
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
mapthings[i].thing_args[1] = mapthings[i].options;
break;
case 1703: //Ideya drone
mapthings[i].thing_args[0] = mapthings[i].angle & 0xFFF;
mapthings[i].thing_args[1] = mapthings[i].extrainfo*32;
mapthings[i].thing_args[2] = ((mapthings[i].angle & 0xF000) >> 12)*32;
if ((mapthings[i].options & (MTF_OBJECTSPECIAL|MTF_EXTRA)) == (MTF_OBJECTSPECIAL|MTF_EXTRA))
mapthings[i].thing_args[3] = TMDA_BOTTOM;
else if ((mapthings[i].options & (MTF_OBJECTSPECIAL|MTF_EXTRA)) == MTF_OBJECTSPECIAL)
mapthings[i].thing_args[3] = TMDA_TOP;
else if ((mapthings[i].options & (MTF_OBJECTSPECIAL|MTF_EXTRA)) == MTF_EXTRA)
mapthings[i].thing_args[3] = TMDA_MIDDLE;
else
mapthings[i].thing_args[3] = TMDA_BOTTOMOFFSET;
mapthings[i].thing_args[4] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1704: //NiGHTS bumper
mapthings[i].pitch = 30 * (((mapthings[i].options & 15) + 9) % 12);
mapthings[i].options &= ~0xF;
break;
case 1705: //Hoop
case 1713: //Hoop (Customizable)
{
UINT16 oldangle = mapthings[i].angle;
mapthings[i].angle = ((oldangle >> 8)*360)/256;
mapthings[i].pitch = ((oldangle & 255)*360)/256;
mapthings[i].thing_args[0] = (mapthings[i].type == 1705) ? 96 : (mapthings[i].options & 0xF)*16 + 32;
mapthings[i].options &= ~0xF;
mapthings[i].type = 1713;
break;
}
case 1710: //Ideya capture
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
mapthings[i].thing_args[1] = mapthings[i].angle;
break;
case 1714: //Ideya anchor point
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
break;
case 1806: //King Bowser
mapthings[i].thing_args[0] = LE_KOOPA;
break;
case 1807: //Axe
mapthings[i].thing_args[0] = LE_AXE;
break;
case 2000: //Smashing spikeball
mapthings[i].thing_args[0] = mapthings[i].angle;
break;
case 2006: //Jack-o'-lantern 1
case 2007: //Jack-o'-lantern 2
case 2008: //Jack-o'-lantern 3
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_EXTRA);
break;
case 2001: // MT_WAYPOINT
{
INT32 firstline = Tag_FindLineSpecial(2000, (INT16)mapthings[i].angle);
mapthings[i].tid = mapthings[i].angle;
mapthings[i].thing_args[0] = mapthings[i].z;
mapthings[i].z = 0;
if (firstline != -1)
{
fixed_t lineradius = sides[lines[firstline].sidenum[0]].textureoffset;
fixed_t linez = sides[lines[firstline].sidenum[0]].rowoffset;
if (lineradius > 0)
mapthings[i].thing_args[1] = lineradius / FRACUNIT;
mapthings[i].z = linez / FRACUNIT;
}
if (mapthings[i].extrainfo == 1)
{
mapthings[i].thing_args[2] |= TMWPF_FINISHLINE;
}
if (mapthings[i].options & MTF_EXTRA)
{
mapthings[i].thing_args[2] |= TMWPF_DISABLED;
}
if (mapthings[i].options & MTF_OBJECTSPECIAL)
{
mapthings[i].thing_args[2] |= TMWPF_SHORTCUT;
}
if (mapthings[i].options & MTF_AMBUSH)
{
mapthings[i].thing_args[2] |= TMWPF_NORESPAWN;
}
break;
}
case 2004: // MT_BOTHINT
mapthings[i].thing_args[0] = mapthings[i].angle;
mapthings[i].thing_args[1] = mapthings[i].extrainfo;
mapthings[i].thing_args[2] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 2010: // MT_ITEMCAPSULE
mapthings[i].thing_args[0] = mapthings[i].angle;
mapthings[i].thing_args[1] = mapthings[i].extrainfo;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
{
// Special = +16 items (+80 for rings)
mapthings[i].thing_args[1] += 16;
}
if (mapthings[i].options & MTF_EXTRA)
{
// was advertised as an "invert time attack" flag, actually was an "all gamemodes" flag
mapthings[i].thing_args[3] = TMICM_MULTIPLAYER|TMICM_TIMEATTACK;
}
else
{
mapthings[i].thing_args[3] = TMICM_DEFAULT;
}
if (mapthings[i].options & MTF_AMBUSH)
{
mapthings[i].thing_args[2] |= TMICF_INVERTSIZE;
}
break;
case 2020: // MT_LOOPENDPOINT
{
mapthings[i].thing_args[0] =
mapthings[i].options & MTF_AMBUSH ?
TMLOOP_BETA : TMLOOP_ALPHA;
break;
}
case 2021: // MT_LOOPCENTERPOINT
mapthings[i].thing_args[0] = (mapthings[i].options & MTF_AMBUSH) == MTF_AMBUSH;
mapthings[i].thing_args[1] = mapthings[i].angle;
break;
case 2050: // MT_DUELBOMB
mapthings[i].thing_args[1] = !!(mapthings[i].options & MTF_AMBUSH);
break;
case 1950: // MT_AAZTREE_HELPER
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
mapthings[i].thing_args[1] = mapthings[i].angle;
break;
case 2333: // MT_BATTLECAPSULE
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
mapthings[i].thing_args[1] = mapthings[i].angle;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
{
mapthings[i].thing_args[2] |= TMBCF_REVERSE;
}
if (mapthings[i].options & MTF_AMBUSH)
{
mapthings[i].thing_args[2] |= TMBCF_BACKANDFORTH;
}
break;
case 3122: // MT_MAYONAKAARROW
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[0] = TMMA_WARN;
else if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[0] = TMMA_FLIP;
break;
case 2018: // MT_PETSMOKER
mapthings[i].thing_args[0] = !!(mapthings[i].options & MTF_OBJECTSPECIAL);
break;
case 3786: // MT_BATTLEUFO_SPAWNER
mapthings[i].thing_args[0] = mapthings[i].angle;
break;
case 3400: // MT_WATERPALACETURBINE
{
mtag_t tag = (mtag_t)mapthings[i].angle;
INT32 j = Tag_FindLineSpecial(2009, tag);
if (j == -1)
{
CONS_Debug(DBG_GAMELOGIC, "Water Palace Turbine setup: Unable to find parameter line 2009 (tag %d)!\n", tag);
break;
}
if (!lines[j].backsector)
{
CONS_Debug(DBG_GAMELOGIC, "Water Palace Turbine setup: No backside for parameter line 2009 (tag %d)!\n", tag);
break;
}
mapthings[i].angle = sides[lines[j].sidenum[0]].rowoffset >> FRACBITS;
if (mapthings[i].options & MTF_EXTRA)
mapthings[i].thing_args[0] = 1;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
mapthings[i].thing_args[1] = 1;
mapthings[i].thing_args[2] = lines[j].frontsector->floorheight >> FRACBITS;
mapthings[i].thing_args[3] = lines[j].frontsector->ceilingheight >> FRACBITS;
mapthings[i].thing_args[4] = lines[j].backsector->floorheight >> FRACBITS;
mapthings[i].thing_args[5] = sides[lines[j].sidenum[0]].textureoffset >> FRACBITS;
if (mapthings[i].thing_args[5] < 0)
mapthings[i].thing_args[5] = -mapthings[i].thing_args[5];
mapthings[i].thing_args[6] = sides[lines[j].sidenum[1]].rowoffset >> FRACBITS;
if (mapthings[i].thing_args[6] < 0)
mapthings[i].thing_args[6] = -mapthings[i].thing_args[6];
mapthings[i].thing_args[7] = sides[lines[j].sidenum[1]].textureoffset >> FRACBITS;
if (mapthings[i].thing_args[7] < 0)
mapthings[i].thing_args[7] = -mapthings[i].thing_args[7];
if (lines[j].flags & ML_SKEWTD)
mapthings[i].thing_args[8] = R_PointToDist2(lines[j].v2->x, lines[j].v2->y, lines[j].v1->x, lines[j].v1->y) >> FRACBITS;
if (lines[j].flags & ML_NOSKEW)
mapthings[i].thing_args[9] = 1;
break;
}
case 3441: // MT_DASHRING
case 3442: // MT_RAINBOWDASHRING
mapthings[i].thing_args[0] = mapthings[i].options & 13;
mapthings[i].thing_args[1] = mapthings[i].extrainfo;
break;
case FLOOR_SLOPE_THING:
case CEILING_SLOPE_THING:
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
break;
case 4094: // MT_ARKARROW
mapthings[i].thing_args[0] = mapthings[i].extrainfo;
if (mapthings[i].options & MTF_OBJECTSPECIAL)
{
// Special = add 16 to the symbol type
mapthings[i].thing_args[0] += 16;
}
if (mapthings[i].options & MTF_AMBUSH)
{
// Ambush = add 32 to the symbol type
mapthings[i].thing_args[0] += 32;
}
break;
default:
break;
}
}
}
static void P_ConvertBinaryLinedefFlags(void)
{
size_t i;
for (i = 0; i < numlines; i++)
{
if (!!(lines[i].flags & ML_DONTPEGBOTTOM) ^ !!(lines[i].flags & ML_MIDPEG))
lines[i].flags |= ML_MIDPEG;
else
lines[i].flags &= ~ML_MIDPEG;
if (lines[i].special >= 100 && lines[i].special < 300)
{
if (lines[i].flags & ML_DONTPEGTOP)
lines[i].flags |= ML_SKEWTD;
else
lines[i].flags &= ~ML_SKEWTD;
if ((lines[i].flags & ML_TFERLINE) && lines[i].frontsector)
{
size_t j;
for (j = 0; j < lines[i].frontsector->linecount; j++)
{
if (lines[i].frontsector->lines[j]->flags & ML_DONTPEGTOP)
lines[i].frontsector->lines[j]->flags |= ML_SKEWTD;
else
lines[i].frontsector->lines[j]->flags &= ~ML_SKEWTD;
}
}
}
}
}
//For maps in binary format, converts setup of specials to UDMF format.
static void P_ConvertBinaryMap(void)
{
P_ConvertBinaryLinedefTypes();
P_ConvertBinarySectorTypes();
P_ConvertBinaryThingTypes();
P_ConvertBinaryLinedefFlags();
}
/** Compute MD5 message digest for bytes read from memory source
*
* The resulting message digest number will be written into the 16 bytes
* beginning at RESBLOCK.
*
* \param filename path of file
* \param resblock resulting MD5 checksum
* \return 0 if MD5 checksum was made, and is at resblock, 1 if error was found
*/
static INT32 P_MakeBufferMD5(const char *buffer, size_t len, void *resblock)
{
#ifdef NOMD5
(void)buffer;
(void)len;
memset(resblock, 0x00, 16);
return 1;
#else
tic_t t = I_GetTime();
CONS_Debug(DBG_SETUP, "Making MD5\n");
if (md5_buffer(buffer, len, resblock) == NULL)
return 1;
CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetTime() - t)/NEWTICRATE);
return 0;
#endif
}
static void P_MakeMapMD5(virtres_t *virt, void *dest)
{
unsigned char resmd5[16];
if (udmf)
{
virtlump_t *textmap = vres_Find(virt, "TEXTMAP");
P_MakeBufferMD5((char*)textmap->data, textmap->size, resmd5);
}
else
{
unsigned char linemd5[16];
unsigned char sectormd5[16];
unsigned char thingmd5[16];
unsigned char sidedefmd5[16];
UINT8 i;
// Create a hash for the current map
// get the actual lumps!
virtlump_t* virtlines = vres_Find(virt, "LINEDEFS");
virtlump_t* virtsectors = vres_Find(virt, "SECTORS");
virtlump_t* virtmthings = vres_Find(virt, "THINGS");
virtlump_t* virtsides = vres_Find(virt, "SIDEDEFS");
P_MakeBufferMD5((char*)virtlines->data, virtlines->size, linemd5);
P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size, sectormd5);
P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size, thingmd5);
P_MakeBufferMD5((char*)virtsides->data, virtsides->size, sidedefmd5);
for (i = 0; i < 16; i++)
resmd5[i] = (linemd5[i] + sectormd5[i] + thingmd5[i] + sidedefmd5[i]) & 0xFF;
}
M_Memcpy(dest, &resmd5, 16);
}
static boolean P_LoadMapFromFile(void)
{
TracyCZone(__zone, true);
virtlump_t *textmap = vres_Find(curmapvirt, "TEXTMAP");
udmf = textmap != NULL;
udmf_version = 0;
if (!P_LoadMapData(curmapvirt))
{
TracyCZoneEnd(__zone);
return false;
}
P_LoadMapBSP(curmapvirt);
P_LoadMapLUT(curmapvirt);
P_LinkMapData();
if (!udmf)
P_AddBinaryMapTags();
Taglist_InitGlobalTables();
if (!udmf)
P_ConvertBinaryMap();
if (P_CanWriteTextmap())
P_WriteTextmap();
// Copy relevant map data for NetArchive purposes.
P_DeepCopySectors(&spawnsectors, &sectors, numsectors);
P_DeepCopyLines(&spawnlines, &lines, numlines);
P_DeepCopySides(&spawnsides, &sides, numsides);
P_MakeMapMD5(curmapvirt, &mapmd5);
TracyCZoneEnd(__zone);
return true;
}
//
// LEVEL INITIALIZATION FUNCTIONS
//
/** Sets up a sky texture to use for the level.
* The sky texture is used instead of F_SKY1.
*/
void P_SetupLevelSky(const char *skytexname, boolean global)
{
char tex[9];
if (!skytexname || !skytexname[0])
return;
strncpy(tex, skytexname, 9);
tex[8] = 0;
skytexture = R_TextureNumForName(tex);
strncpy(levelskytexture, tex, 9);
// Global change
if (global)
strncpy(globallevelskytexture, tex, 9);
// Don't go beyond for dedicated servers
if (dedicated)
return;
// scale up the old skies, if needed
R_SetupSkyDraw();
}
static const char *maplumpname;
lumpnum_t lastloadedmaplumpnum; // for comparative savegame
//
// P_LevelInitStuff
//
// Some player initialization for map start.
//
static void P_InitLevelSettings(void)
{
INT32 i;
UINT8 p = 0;
leveltime = 0;
modulothing = 0;
P_SetFreezeLevel(false);
P_SetFreezeCheat(false);
K_TimerReset();
nummaprings = 0;
nummapboxes = numgotboxes = 0;
maptargets = numtargets = 0;
battleprisons = false;
nummapspraycans = 0;
numchallengedestructibles = 0;
// circuit, race and competition stuff
numcheatchecks = 0;
if (!g_reloadinggamestate)
timeinmap = 0;
// special stage
stagefailed = true; // assume failed unless proven otherwise - P_GiveEmerald or emerald touchspecial
// Reset temporary record data
//memset(&ntemprecords, 0, sizeof(nightsdata_t));
// earthquake camera
g_quakes = NULL;
// song credit init
if (!Music_Playing("credits"))
{
S_StopMusicCredit();
cursongcredit.trans = NUMTRANSMAPS;
}
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i] && !players[i].spectator)
p++;
if (grandprixinfo.gp == false)
players[i].lives = 3;
G_PlayerReborn(i, true);
K_UpdateShrinkCheat(&players[i]);
}
racecountdown = exitcountdown = musiccountdown = exitfadestarted = 0;
g_exit.losing = false;
g_exit.retry = false;
// Gamespeed and frantic items
const boolean multi_speed = (gametypes[gametype]->speed == KARTSPEED_AUTO);
gamespeed = multi_speed ? KARTSPEED_EASY : gametypes[gametype]->speed;
franticitems = false;
g_teamplay = false;
if (K_PodiumSequence() == true)
{
// Okay, now that everything preceding is handled, set the position.
for (i = 0; i < MAXPLAYERS; i++)
{
players[i].position = K_GetPodiumPosition(&players[i]);
}
// We don't touch the gamespeed, though!
}
else if (tutorialchallenge == TUTORIALSKIP_INPROGRESS)
{
gamespeed = KARTSPEED_NORMAL;
}
else if (grandprixinfo.gp == true)
{
if (multi_speed)
{
gamespeed = grandprixinfo.gamespeed;
}
}
else if (modeattacking != ATTACKING_NONE)
{
if (multi_speed)
{
if ((gametyperules & GTR_CATCHER) && encoremode == false)
{
gamespeed = KARTSPEED_NORMAL;
}
else
{
gamespeed = KARTSPEED_HARD;
}
}
}
else
{
if (multi_speed)
{
if (cv_kartspeed.value == KARTSPEED_AUTO)
gamespeed = ((speedscramble == -1) ? KARTSPEED_NORMAL : (UINT8)speedscramble);
else
gamespeed = (UINT8)cv_kartspeed.value;
}
franticitems = (boolean)cv_kartfrantic.value;
g_teamplay = (boolean)cv_teamplay.value; // we will overwrite this later if there is not enough players
}
memset(&battleovertime, 0, sizeof(struct battleovertime));
speedscramble = encorescramble = -1;
K_ResetSpecialStage();
K_ResetBossInfo();
memset(&g_endcam, 0, sizeof g_endcam);
}
#if 0
// Respawns all the mapthings and mobjs in the map from the already loaded map data.
void P_RespawnThings(void)
{
// Search through all the thinkers.
thinker_t *think;
INT32 i, viewid = -1, centerid = -1; // for skyboxes
// check if these are any of the normal viewpoint/centerpoint mobjs in the level or not
if (skyboxmo[0] || skyboxmo[1])
for (i = 0; i < 16; i++)
{
if (skyboxmo[0] && skyboxmo[0] == skyboxviewpnts[i])
viewid = i; // save id just in case
if (skyboxmo[1] && skyboxmo[1] == skyboxcenterpnts[i])
centerid = i; // save id just in case
}
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
continue;
P_RemoveMobj((mobj_t *)think);
}
P_InitLevelSettings();
memset(localaiming, 0, sizeof(localaiming));
P_SpawnMapThings(true);
// restore skybox viewpoint/centerpoint if necessary, set them to defaults if we can't do that
skyboxmo[0] = skyboxviewpnts[(viewid >= 0) ? viewid : 0];
skyboxmo[1] = skyboxcenterpnts[(centerid >= 0) ? centerid : 0];
}
#endif
static void P_ResetSpawnpoints(void)
{
UINT8 i, j;
// reset the player starts
for (i = 0; i < MAXPLAYERS; i++)
{
playerstarts[i] = NULL;
if (playeringame[i])
{
players[i].skybox.viewpoint = NULL;
players[i].skybox.centerpoint = NULL;
}
}
numfaultstarts = 0;
faultstart = NULL;
numdmstarts = 0;
for (i = 0; i < MAX_DM_STARTS; i++)
deathmatchstarts[i] = NULL;
for (i = 0; i < TEAM__MAX; i++)
{
numteamstarts[i] = 0;
for (j = 0; j < MAXPLAYERS; j++)
{
teamstarts[i][j] = NULL;
}
}
for (i = 0; i < 16; i++)
skyboxviewpnts[i] = skyboxcenterpnts[i] = NULL;
}
static void P_TryAddExternalGhost(const char *defdemoname)
{
if (FIL_FileExists(defdemoname))
{
savebuffer_t buf = {0};
if (P_SaveBufferFromFile(&buf, defdemoname))
{
Z_ChangeTag(buf.buffer, PU_LEVEL);
G_AddGhost(&buf, defdemoname);
}
else
{
CONS_Alert(CONS_ERROR, M_GetText("Failed to read file '%s'.\n"), defdemoname);
}
}
}
static void P_LoadRecordGhosts(void)
{
// see also /menus/play-local-race-time-attack.c's M_PrepareTimeAttack
char *gpath;
const char *modeprefix = "";
INT32 i;
gpath = Z_StrDup(va("%s" PATHSEP "media" PATHSEP "replay" PATHSEP "%s" PATHSEP "%s", srb2home, timeattackfolder, G_BuildMapName(gamemap)));
if (encoremode)
modeprefix = "spb-";
enum
{
kTime = 1 << 0,
kLap = 1 << 1,
kLast = 1 << 2,
};
auto map_ghosts = [](int value)
{
auto map = [](const consvar_t& cvar, int value, UINT8 bit) { return cvar.value == value ? bit : 0; };
return
// Best Time ghost
((modeattacking & ATTACKING_TIME) ? map(cv_ghost_besttime, value, kTime) : 0) |
// Best Lap ghost
((modeattacking & ATTACKING_LAP) ? map(cv_ghost_bestlap, value, kLap) : 0) |
// Best Lap ghost
map(cv_ghost_last, value, kLast);
};
auto add_ghosts = [gpath](const std::string& base, UINT8 bits)
{
auto load = [base](const char* suffix) { P_TryAddExternalGhost(fmt::format("{}-{}.lmp", base, suffix).c_str()); };
if (bits & kTime)
load("time-best");
if (bits & kLap)
load("lap-best");
if (bits & kLast)
load("last");
};
UINT8 allGhosts = map_ghosts(2);
UINT8 sameGhosts = map_ghosts(1);
if (allGhosts)
{
for (i = 0; i < numskins; ++i)
add_ghosts(fmt::format("{}-{}{}", gpath, skins[i].name, modeprefix), allGhosts);
}
if (sameGhosts)
{
INT32 skin = R_SkinAvailableEx(cv_skin[0].string, false);
if (skin < 0 || !R_SkinUsable(-1, skin, false))
skin = 0; // use default skin
add_ghosts(fmt::format("{}-{}{}", gpath, skins[skin].name, modeprefix), sameGhosts);
}
// Guest ghost
if (cv_ghost_guest.value)
P_TryAddExternalGhost(va("%s-%sguest.lmp", gpath, modeprefix));
// Staff Attack ghosts
if (cv_ghost_staff.value && !modeprefix[0])
{
for (i = mapheaderinfo[gamemap-1]->ghostCount; i > 0; i--)
{
savebuffer_t buf = {0};
staffbrief_t* ghostbrief = mapheaderinfo[gamemap-1]->ghostBrief[i - 1];
const char* lumpname = W_CheckLongNameForNumPwad(ghostbrief->wad, ghostbrief->lump);
size_t lumplength = W_LumpLengthPwad(ghostbrief->wad, ghostbrief->lump);
if (lumplength == 0)
{
if (lumpname)
{
CONS_Alert(CONS_ERROR, M_GetText("Failed to read staff ghost lump '%s'.\n"), lumpname);
}
else
{
CONS_Alert(CONS_ERROR, M_GetText("Failed to read staff ghost lump for map '%s'.\n"), mapheaderinfo[gamemap-1]->lumpname);
}
continue;
}
P_SaveBufferZAlloc(&buf, lumplength, PU_LEVEL, NULL);
W_ReadLumpPwad(ghostbrief->wad, ghostbrief->lump, buf.buffer);
G_AddGhost(&buf, (char*)lumpname);
}
}
Z_Free(gpath);
}
static void P_SetupCamera(UINT8 pnum, camera_t *cam)
{
if (players[pnum].mo && (server || addedtogame))
{
cam->x = players[pnum].mo->x;
cam->y = players[pnum].mo->y;
cam->z = players[pnum].mo->z;
cam->angle = players[pnum].mo->angle;
cam->subsector = R_PointInSubsector(cam->x, cam->y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
}
else
{
mapthing_t *thing;
if (gametyperules & GTR_BATTLESTARTS)
thing = deathmatchstarts[0];
else
thing = playerstarts[0];
if (thing)
{
cam->x = thing->x;
cam->y = thing->y;
cam->z = thing->z;
cam->angle = FixedAngle((fixed_t)thing->angle << FRACBITS);
cam->subsector = R_PointInSubsector(cam->x, cam->y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
}
}
cam->chase = false; // tell camera to reset its position next tic
}
static void P_InitCamera(void)
{
if (!dedicated)
{
UINT8 i;
for (i = 0; i <= r_splitscreen; i++)
{
//displayplayers[i] = g_localplayers[i]; // Start with your OWN view, please!
P_SetupCamera(displayplayers[i], &camera[i]);
}
}
}
static void P_ShuffleTeams(void)
{
size_t i;
if (G_GametypeHasTeams() == false)
{
// Teams are not enabled, force to TEAM_UNASSIGNED
for (i = 0; i < MAXPLAYERS; i++)
{
players[i].team = TEAM_UNASSIGNED;
}
return;
}
// The following will sort TEAM_UNASSIGNED players at random.
// In addition, you should know all players will have their team
// unset every round unless certain conditions are met.
// See Y_MidIntermission, G_InitNew (where resetplayer == true)
CONS_Debug(DBG_TEAMS, "Shuffling player teams...\n");
std::vector<UINT8> player_shuffle;
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i] == false || players[i].spectator == true)
{
continue;
}
player_shuffle.push_back(i);
}
size_t n = player_shuffle.size();
if (inDuel == true || n <= 2) // cv_teamplay_min.value
{
CONS_Debug(DBG_TEAMS, "Not enough players to support teams; forcing teamplay preference off.\n");
// Not enough players for teams.
// Turn off the preference for this match.
g_teamplay = false;
// But we may still be in a forced
// teams gametype, so only return false
// if our preference means anything.
if (G_GametypeHasTeams() == false)
{
return;
}
}
if (n > 1)
{
for (i = n - 1; i > 0; i--)
{
size_t j = P_RandomKey(PR_TEAMS, i + 1);
size_t temp = player_shuffle[i];
player_shuffle[i] = player_shuffle[j];
player_shuffle[j] = temp;
}
}
for (i = 0; i < n; i++)
{
G_AutoAssignTeam(&players[ player_shuffle[i] ]);
}
}
static void P_InitPlayers(void)
{
INT32 i, skin = -1, follower = -1;
// Make sure objectplace is OFF when you first start the level!
OP_ResetObjectplace();
// Update skins / colors between levels.
G_UpdateAllPlayerPreferences();
// Are we forcing a character?
if (gametype == GT_TUTORIAL)
{
// Get skin from name.
if (mapheaderinfo[gamemap-1] && mapheaderinfo[gamemap-1]->relevantskin[0])
{
skin = R_SkinAvailable(mapheaderinfo[gamemap-1]->relevantskin);
}
else
{
skin = R_SkinAvailable(DEFAULTSKIN);
}
// Handle invalid case.
if (skin == -1)
{
skin = 0;
}
if (netgame)
; // shouldn't happen but at least attempt to sync if it does
else for (i = 0; i < numfollowers; i++)
{
if (followers[i].hornsound != sfx_melody)
continue;
if (K_FollowerUsable(i))
follower = i;
break;
}
}
for (i = 0; i < MAXPLAYERS; i++)
{
if (!playeringame[i])
continue;
players[i].mo = NULL;
// If we're forcing a character, do it now.
if (skin != -1)
{
SetPlayerSkinByNum(i, skin);
players[i].skincolor = skins[skin].prefcolor;
players[i].followerskin = follower;
if (follower != -1)
players[i].followercolor = followers[follower].defaultcolor;
}
G_SpawnPlayer(i);
players[i].xtralife = 0; // extra lives do not ever carry over from the previous round
if (P_MobjWasRemoved(players[i].mo) == false && !players[i].spectator)
{
// Rooooooolllling staaaaaaart
if ((gametyperules & (GTR_ROLLINGSTART|GTR_CIRCUIT)) == (GTR_ROLLINGSTART|GTR_CIRCUIT))
{
P_InstaThrust(players[i].mo, players[i].mo->angle, K_GetKartSpeed(&players[i], false, false));
}
}
}
K_UpdateAllPlayerPositions();
}
static void P_InitGametype(void)
{
size_t i;
spectateGriefed = 0;
K_CashInPowerLevels(); // Pushes power level changes even if intermission was skipped
if (modeattacking && !demo.playback)
P_LoadRecordGhosts();
numlaps = K_RaceLapCount(gamemap - 1);
wantedcalcdelay = wantedfrequency*2;
for (i = 0; i < NUMKARTITEMS-1; i++)
itemCooldowns[i] = 0;
mapreset = 0;
thwompsactive = false;
lastLowestLap = 0;
spbplace = -1;
G_ClearRetryFlag();
// Start recording replay in multiplayer with a temp filename
//@TODO I'd like to fix dedis crashing when recording replays for the future too...
if (gamestate == GS_LEVEL && !demo.playback && multiplayer && !dedicated)
{
char buf[MAX_WADPATH];
char ver[128];
int parts;
#ifdef DEVELOP
if (strcmp(compbranch, ""))
sprintf(ver, "%s-%s", compbranch, comprevision);
else
strcpy(ver, comprevision);
#else
strcpy(ver, VERSIONSTRING);
#endif
sprintf(buf, "%s" PATHSEP "media" PATHSEP "replay" PATHSEP "online" PATHSEP "%s" PATHSEP "%d-%s",
srb2home, ver, (int) (time(NULL)), G_BuildMapName(gamemap));
parts = M_PathParts(buf);
M_MkdirEachUntil(buf, parts - 5, parts - 1, 0755);
G_RecordDemo(buf);
}
if (gamestate != GS_TITLESCREEN && M_GameTrulyStarted())
{
// Started a game? Move on to the next jam when you go back to the title screen
// this permits all but titlescreen, instead of only GS_LEVEL
// because that one's way too easy to activate again and again
CV_SetValue(&cv_menujam_update, 1);
gamedata->musicstate = GDMUSIC_NONE;
}
}
struct minimapinfo minimapinfo;
static void P_InitMinimapInfo(void)
{
size_t i, count;
fixed_t a;
fixed_t b;
node_t *bsp = &nodes[numnodes-1];
minimapinfo.minimap_pic = static_cast<patch_t*>(mapheaderinfo[gamemap-1]->minimapPic);
minimapinfo.min_x = minimapinfo.max_x = minimapinfo.min_y = minimapinfo.max_y = INT32_MAX;
count = 0;
for (i = 0; i < nummapthings; i++)
{
if (mapthings[i].type != mobjinfo[MT_MINIMAPBOUND].doomednum)
continue;
count++;
if (mapthings[i].x < minimapinfo.min_x)
{
minimapinfo.max_x = minimapinfo.min_x;
minimapinfo.min_x = mapthings[i].x;
}
else
{
minimapinfo.max_x = mapthings[i].x;
}
if (mapthings[i].y < minimapinfo.min_y)
{
minimapinfo.max_y = minimapinfo.min_y;
minimapinfo.min_y = mapthings[i].y;
}
else
{
minimapinfo.max_y = mapthings[i].y;
}
}
if (count == 0)
{
minimapinfo.min_x = bsp->bbox[0][BOXLEFT];
minimapinfo.max_x = bsp->bbox[0][BOXRIGHT];
minimapinfo.min_y = bsp->bbox[0][BOXBOTTOM];
minimapinfo.max_y = bsp->bbox[0][BOXTOP];
if (bsp->bbox[1][BOXLEFT] < minimapinfo.min_x)
minimapinfo.min_x = bsp->bbox[1][BOXLEFT];
if (bsp->bbox[1][BOXRIGHT] > minimapinfo.max_x)
minimapinfo.max_x = bsp->bbox[1][BOXRIGHT];
if (bsp->bbox[1][BOXBOTTOM] < minimapinfo.min_y)
minimapinfo.min_y = bsp->bbox[1][BOXBOTTOM];
if (bsp->bbox[1][BOXTOP] > minimapinfo.max_y)
minimapinfo.max_y = bsp->bbox[1][BOXTOP];
// You might be wondering why these are being bitshift here
// it's because mapwidth and height would otherwise overflow for maps larger than half the size possible...
// map boundaries and sizes will ALWAYS be whole numbers thankfully
// later calculations take into consideration that these are actually not in terms of FRACUNIT though
minimapinfo.min_x >>= FRACBITS;
minimapinfo.max_x >>= FRACBITS;
minimapinfo.min_y >>= FRACBITS;
minimapinfo.max_y >>= FRACBITS;
}
else if (count != 2)
{
I_Error("P_InitMinimapInfo: Too %s minimap helper objects! (found %s of mapthingnum %d, should have 2)",
(count < 2 ? "few" : "many"), sizeu1(count), mobjinfo[MT_MINIMAPBOUND].doomednum);
}
minimapinfo.map_w = minimapinfo.max_x - minimapinfo.min_x;
minimapinfo.map_h = minimapinfo.max_y - minimapinfo.min_y;
minimapinfo.minimap_w = minimapinfo.minimap_h = 100;
a = FixedDiv(minimapinfo.minimap_w<<FRACBITS, minimapinfo.map_w<<4);
b = FixedDiv(minimapinfo.minimap_h<<FRACBITS, minimapinfo.map_h<<4);
if (a < b)
{
minimapinfo.minimap_h = FixedMul(a, minimapinfo.map_h)>>(FRACBITS-4);
minimapinfo.zoom = a;
}
else
{
if (a != b)
{
minimapinfo.minimap_w = FixedMul(b, minimapinfo.map_w)>>(FRACBITS-4);
}
minimapinfo.zoom = b;
}
minimapinfo.zoom >>= (FRACBITS-4);
minimapinfo.zoom -= (minimapinfo.zoom/20);
// These should always be small enough to be bitshift back right now
minimapinfo.offs_x = FixedMul((minimapinfo.min_x + minimapinfo.map_w/2) << FRACBITS, minimapinfo.zoom);
minimapinfo.offs_y = FixedMul((minimapinfo.min_y + minimapinfo.map_h/2) << FRACBITS, minimapinfo.zoom);
}
void P_ResetLevelMusic(void)
{
UINT8 idx = 0;
mapheader_t* mapheader = mapheaderinfo[gamemap - 1];
UINT8 truesize = (encoremode && mapheader->encoremusname_size)
? mapheader->encoremusname_size
: mapheader->musname_size;
// To keep RNG in sync, we will always pull from RNG, even if unused
UINT32 random = P_Random(PR_MUSICSELECT);
if (demo.playback)
{
// mapmusrng has already been set by the demo; just make sure it's valid
if (mapmusrng >= truesize)
{
mapmusrng = 0;
}
return;
}
if (truesize > 1)
{
UINT8 tempmapmus[MAXMUSNAMES], tempmapmus_size = 1, i;
tempmapmus[0] = 0;
for (i = 1; i < truesize; i++)
{
if (mapheader->cache_muslock[i-1] < MAXUNLOCKABLES
&& !M_CheckNetUnlockByID(mapheader->cache_muslock[i-1]))
continue;
tempmapmus[tempmapmus_size++] = i;
}
if (tempmapmus_size > 1)
{
if (g_reloadingMap == (modeattacking == ATTACKING_NONE))
{
// If restarting the map, simply cycle
// through available alt music.
idx = (mapmusrng + 1) % tempmapmus_size;
}
else if (modeattacking)
{
// Short circuit the cycle.
idx = mapmusrng % tempmapmus_size;
}
else
{
idx = random % tempmapmus_size;
}
idx = tempmapmus[idx];
}
}
mapmusrng = idx;
}
boolean P_UseContinuousLevelMusic(void)
{
if (gametyperules & GTR_BOSS)
return false;
if (modeattacking != ATTACKING_NONE)
return cv_continuousmusic.value;
return (gametyperules & GTR_NOPOSITION) != 0;
}
void P_LoadLevelMusic(void)
{
mapheader_t* mapheader = mapheaderinfo[gamemap-1];
const char *music = mapheader->musname[0];
if (encoremode && mapheader->encoremusname_size
&& mapmusrng < mapheader->encoremusname_size)
{
music = mapheader->encoremusname[mapmusrng];
}
else if (mapmusrng < mapheader->musname_size)
{
music = mapheader->musname[mapmusrng];
}
if (P_UseContinuousLevelMusic())
{
if (!stricmp(Music_Song("level_nosync"), music))
{
// Do not reset music if it is the same
Music_BatchExempt("level_nosync");
}
Music_StopAll();
Music_Remap("level_nosync", music);
}
else
{
Music_StopAll();
Music_Remap("level", music);
tic_t level_music_start = starttime + (TICRATE/2);
Music_Seek("level", (std::max(leveltime, level_music_start) - level_music_start) * 1000UL / TICRATE);
}
Music_ResetLevelVolume();
}
/** Loads a level from a lump or external wad.
*
* \param fromnetsave If true, skip some stuff because we're loading a netgame snapshot.
* \todo Clean up, refactor, split up; get rid of the bloat.
*/
boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate)
{
TracyCZone(__zone, true);
// use gamemap to get map number.
// 99% of the things already did, so.
// Map header should always be in place at this point
INT32 i, ranspecialwipe = 0;
sector_t *ss;
virtlump_t *encoreLump = NULL;
levelloading = true;
g_reloadinggamestate = reloadinggamestate;
// This is needed. Don't touch.
maptol = mapheaderinfo[gamemap-1]->typeoflevel;
CON_Drawer(); // let the user know what we are going to do
I_FinishUpdate(); // page flip or blit buffer
// Reset the palette
if (rendermode != render_none)
V_SetPaletteLump("PLAYPAL");
// Initialize sector node list.
P_Initsecnode();
// Clear CECHO messages
HU_ClearCEcho();
HU_ClearTitlecardCEcho();
if (mapheaderinfo[gamemap-1]->runsoc[0] != '#')
P_RunSOC(mapheaderinfo[gamemap-1]->runsoc);
P_InitLevelSettings();
if (demo.attract != DEMO_ATTRACT_TITLE && gamestate != GS_TITLESCREEN)
{
// Stop titlescreen music from overriding level music.
// Except on the title screen, where an attract demo or title map may be used.
Music_Stop("title");
}
if (demo.attract != DEMO_ATTRACT_CREDITS)
{
Music_Stop("credits");
}
for (i = 0; i <= r_splitscreen; i++)
postimgtype[i] = postimg_none;
// Initial height of PointOfView
// will be set by player think.
players[consoleplayer].viewz = 1;
// (This define might be useful for other areas of code? Not sure)
tic_t locstarttime, endtime, nowtime;
#define WAIT(timetowait) \
locstarttime = nowtime = lastwipetic; \
endtime = locstarttime + timetowait; \
while (nowtime < endtime) \
{ \
while (!((nowtime = I_GetTime()) - lastwipetic)) \
{ \
I_Sleep(cv_sleep.value); \
I_UpdateTime(); \
} \
lastwipetic = nowtime; \
if (moviemode && rendermode == render_opengl) \
M_LegacySaveFrame(); \
else if (moviemode && rendermode != render_none) \
I_CaptureVideoFrame(); \
NetKeepAlive(); \
} \
// Cancel all d_main.c fadeouts (keep fade in though).
if (reloadinggamestate)
wipegamestate = gamestate; // Don't fade if reloading the gamestate
// Encore mode fade to pink to white
// This is handled BEFORE sounds are stopped.
else if (encoremode && !prevencoremode && modeattacking == ATTACKING_NONE && !demo.rewinding)
{
if (rendermode != render_none)
{
Music_StopAll(); // er, about that...
// Fade to an inverted screen, with a circle fade...
F_WipeStartScreen();
V_EncoreInvertScreen();
F_WipeEndScreen();
S_StartSound(NULL, sfx_ruby1);
F_RunWipe(wipe_encore_toinvert, wipedefs[wipe_encore_toinvert], false, NULL, false, false);
// Hold on invert for extra effect.
WAIT((3*TICRATE)/2);
S_StartSound(NULL, sfx_ruby2);
// Then fade to a white screen
F_WipeStartScreen();
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 0);
F_WipeEndScreen();
F_RunWipe(wipe_encore_towhite, wipedefs[wipe_encore_towhite], false, "FADEMAP1", false, true); // wiggle the screen during this!
// THEN fade to a black screen.
F_WipeStartScreen();
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
F_WipeEndScreen();
F_RunWipe(wipe_level_toblack, wipedefs[wipe_level_toblack], false, "FADEMAP0", false, false);
// Wait a bit longer.
WAIT((3*TICRATE)/4);
}
else
{
// dedicated servers can call this now, to wait the appropriate amount of time for clients to wipe
F_RunWipe(wipe_encore_towhite, wipedefs[wipe_encore_towhite], false, "FADEMAP1", false, true);
WAIT((3*TICRATE)/2);
F_RunWipe(wipe_level_toblack, wipedefs[wipe_level_toblack], false, "FADEMAP0", false, false);
WAIT((3*TICRATE)/4);
}
}
#undef WAIT
// Special stage & record attack retry fade to white
// This is handled BEFORE sounds are stopped.
if (G_IsModeAttackRetrying() && !demo.playback && (gametyperules & GTR_BOSS) == 0)
{
ranspecialwipe = 2;
//wipestyleflags |= (WSF_FADEOUT|WSF_TOWHITE);
}
// Make sure all sounds are stopped before Z_FreeTags.
S_StopSounds();
S_ClearSfx();
// Reset the palette now all fades have been done
if (rendermode != render_none)
V_ReloadPalette(); // Set the level palette
// Let's fade to white here
// But only if we didn't do the encore startup wipe
if (!demo.rewinding && !reloadinggamestate)
{
int wipetype = wipe_level_toblack;
// TODO: What is this?? This does nothing because P_LoadLevelMusic is gonna halt music, anyway.
#if 0
// Fade out music here. Deduct 2 tics so the fade volume actually reaches 0.
// But don't halt the music! S_Start will take care of that. This dodges a MIDI crash bug.
if (gamestate == GS_LEVEL)
S_FadeMusic(0, FixedMul(
FixedDiv((F_GetWipeLength(wipedefs[wipe_level_toblack])-2)*NEWTICRATERATIO, NEWTICRATE), MUSICRATE));
#endif
if (demo.attract)
{
; // Leave the music alone! We're already playing what we want!
// Pull from RNG even though music will never change
// To silence playback has desynced warning
P_Random(PR_MUSICSELECT);
}
else if (K_PodiumSequence())
{
// mapmusrng is set by local player position in K_ResetCeremony
P_LoadLevelMusic();
}
else if (gamestate == GS_LEVEL)
{
if (ranspecialwipe == 2)
{
pausedelay = -3; // preticker plus one
}
// We should be fine starting music here.
// Don't do this during titlemap, because the menu code handles music by itself.
// Netsave loading does this itself, because leveltime isn't set yet!
if (!fromnetsave)
{
P_ResetLevelMusic();
P_LoadLevelMusic();
}
}
// Default
levelfadecol = 31;
if (gamestate == GS_TITLESCREEN)
{
;
}
else if (K_PodiumHasEmerald())
{
// Special Stage out
if (ranspecialwipe != 2)
S_StartSound(NULL, sfx_s3k6a);
levelfadecol = 0;
wipetype = wipe_encore_towhite;
}
else if (gametyperules & GTR_SPECIALSTART)
{
// Special Stage in
if (ranspecialwipe != 2)
S_StartSound(NULL, sfx_s3kaf);
levelfadecol = 0;
wipetype = wipe_encore_towhite;
}
else if (skipstats == 1 && (gametyperules & GTR_BOSS) == 0)
{
// MapWarp
if (ranspecialwipe != 2)
S_StartSound(NULL, sfx_s3k73);
levelfadecol = 0;
wipetype = wipe_encore_towhite;
}
else if (encoremode)
{
// Encore
levelfadecol = 0;
wipetype = wipe_encore_towhite;
}
if (g_attractnowipe)
{
// Attract demos do a custom fade on exit, so
// don't run a wipe here.
g_attractnowipe = false;
}
else
{
if (rendermode != render_none)
{
F_WipeStartScreen();
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, levelfadecol);
F_WipeEndScreen();
}
F_RunWipe(wipetype, wipedefs[wipetype], false, ((levelfadecol == 0) ? "FADEMAP1" : "FADEMAP0"), false, false);
}
}
/*
if (!titlemapinaction)
wipegamestate = GS_LEVEL;
*/
// Close text prompt before freeing the old level
F_EndTextPrompt(false, true);
K_UnsetDialogue();
ACS_InvalidateMapScope();
LUA_InvalidateLevel();
Obj_ClearCheckpoints();
for (ss = sectors; sectors+numsectors != ss; ss++)
{
Z_Free(ss->attached);
Z_Free(ss->attachedsolid);
}
// Clear pointers that would be left dangling by the purge
R_FlushTranslationColormapCache();
#ifdef HWRENDER
// Free GPU textures before freeing patches.
if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
HWR_ClearAllTextures();
#endif
G_FreeGhosts(); // ghosts are allocated with PU_LEVEL
Patch_FreeTag(PU_PATCH_LOWPRIORITY);
Patch_FreeTag(PU_PATCH_ROTATED);
Z_FreeTags(PU_LEVEL, PU_PURGELEVEL - 1);
R_InitializeLevelInterpolators();
P_InitThinkers();
P_InitTIDHash();
R_InitMobjInterpolators();
P_InitCachedActions();
K_ClearPersistentMessages();
// internal game map
maplumpname = mapheaderinfo[gamemap-1]->lumpname;
lastloadedmaplumpnum = mapheaderinfo[gamemap-1]->lumpnum;
if (lastloadedmaplumpnum == LUMPERROR)
I_Error("Map %s not found.\n", maplumpname);
curmapvirt = vres_GetMap(lastloadedmaplumpnum);
if (mapheaderinfo[gamemap-1])
{
if (encoremode
#ifdef DEVELOP
&& cv_kartencoremap.value
#endif
)
{
encoreLump = vres_Find(curmapvirt, "ENCORE");
}
else
{
encoreLump = vres_Find(curmapvirt, "TWEAKMAP");
}
}
if (encoreLump)
{
if (encoreLump->size != 256)
{
I_Error("%s: %s lump is not 256 bytes (actual size %s bytes)\n"
"Make sure the lump is in DOOM Flat or SRB2 Encore format and 16x16",
maplumpname, encoreLump->name, sizeu1(encoreLump->size));
}
R_ReInitColormaps(mapheaderinfo[gamemap-1]->palette, encoreLump->data, encoreLump->size);
}
else
{
R_ReInitColormaps(mapheaderinfo[gamemap-1]->palette, NULL, 0);
}
CON_SetupBackColormap();
// SRB2 determines the sky texture to be used depending on the map header.
P_SetupLevelSky(mapheaderinfo[gamemap-1]->skytexture, true);
P_ResetSpawnpoints();
P_ResetTubeWaypoints();
P_MapStart(); // tm.thing can be used starting from this point
// init anything that P_SpawnSlopes/P_LoadThings needs to know
P_InitSpecials();
P_InitSlopes(); //Initialize slopes before the map loads.
if (!P_LoadMapFromFile())
{
TracyCZoneEnd(__zone);
return false;
}
// set up world state
// jart: needs to be done here so anchored slopes know the attached list
P_SpawnSpecials(fromnetsave);
P_SpawnSlopes(fromnetsave);
P_SpawnMapThings(!fromnetsave);
P_InitMinimapInfo();
for (numcoopstarts = 0; numcoopstarts < MAXPLAYERS; numcoopstarts++)
if (!playerstarts[numcoopstarts])
break;
P_SpawnSpecialsThatRequireObjects(fromnetsave);
if (!udmf)
{
// Backwards compatibility for non-UDMF maps
K_AdjustWaypointsParameters();
if (P_CanWriteTextmap())
P_WriteTextmapWaypoints();
}
if (!fromnetsave) // ugly hack for P_NetUnArchiveMisc (and P_LoadNetGame)
P_SpawnPrecipitation();
// The waypoint data that's in PU_LEVEL needs to be reset back to 0/NULL now since PU_LEVEL was cleared
K_ClearWaypoints();
K_ClearFinishBeamLine();
// Load the waypoints please!
if (gametyperules & GTR_CIRCUIT && gamestate != GS_TITLESCREEN)
{
if (K_SetupWaypointList() == false)
{
CONS_Alert(CONS_ERROR, "Waypoints were not able to be setup! Player positions will not work correctly.\n");
}
if (K_GenerateFinishBeamLine() == false)
{
CONS_Alert(CONS_ERROR, "No valid finish line beam setup could be found.\n");
}
}
#ifdef HWRENDER // not win32 only 19990829 by Kin
gl_maploaded = false;
// Lactozilla: Free extrasubsectors regardless of renderer.
HWR_FreeExtraSubsectors();
// Create plane polygons.
if (rendermode == render_opengl)
HWR_LoadLevel();
#endif
// oh god I hope this helps
// (addendum: apparently it does!
// none of this needs to be done because it's not the beginning of the map when
// a netgame save is being loaded, and could actively be harmful by messing with
// the client's view of the data.)
if (!fromnetsave)
{
P_InitGametype();
// Initialize ACS scripts
ACS_LoadLevelScripts(gamemap-1);
}
// Now safe to free.
// We do the following silly
// construction because vres_Free
// no-sells deletions of pointers
// that are == curmapvirt.
{
virtres_t *temp = curmapvirt;
curmapvirt = NULL;
vres_Free(temp);
}
if (!reloadinggamestate)
{
P_InitCamera();
memset(localaiming, 0, sizeof(localaiming));
K_InitDirector();
}
// Remove the loading shit from the screen
if (rendermode != render_none && !titlemapinaction && !reloadinggamestate)
F_WipeColorFill(levelfadecol);
if (precache || dedicated)
R_PrecacheLevel();
if (!demo.playback)
{
mapheaderinfo[gamemap-1]->records.mapvisited |= MV_VISITED;
M_UpdateUnlockablesAndExtraEmblems(true, true);
G_SaveGameData();
}
oldbest = G_GetBestTime(gamemap - 1);
P_MapEnd(); // tm.thing is no longer needed from this point onwards
if (!udmf && !P_CanWriteTextmap())
{
// *Playing* binary maps is disabled; the support is kept in the code for binary map conversions only.
// This is to make sure people use UDMF and, indirectly, guarantee that they will ship their PWAD
// maps with extended GL nodes, as per UDMF requirement. We can retrofit a modern hardware renderer
// into the game in the future without disrupting existing PWADs, which does not suffer from the issues
// of the current GL renderer.
I_Error("Playing binary maps is disabled; please convert to UDMF TEXTMAP and rebuild nodes.");
}
if (!fromnetsave)
{
INT32 buf = gametic % BACKUPTICS;
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i])
{
G_CopyTiccmd(&players[i].cmd, &netcmds[buf][i], 1);
}
}
for (i = 0; i <= r_splitscreen; i++)
{
postimgtype[i] = postimg_none;
}
if (marathonmode & MA_INGAME)
{
marathonmode = static_cast<marathonmode_t>(marathonmode | MA_INIT);
}
}
else
{
// Don't run P_PostLoadLevel when loading netgames.
levelloading = false;
}
if (rendermode != render_none && reloadinggamestate == false)
{
R_ResetViewInterpolation(0);
R_UpdateMobjInterpolators();
// Title card!
G_StartTitleCard();
// Can the title card actually run, though?
if (WipeStageTitle && ranspecialwipe != 2 && fromnetsave == false)
{
G_PreLevelTitleCard();
}
// Apply FOV override.
R_CheckFOV();
}
TracyCZoneEnd(__zone);
return true;
}
void P_PostLoadLevel(void)
{
TracyCZone(__zone, true);
INT32 i;
P_MapStart();
if (G_GametypeHasSpectators())
{
K_CheckSpectateStatus(false);
}
if (demo.playback)
;
else if (grandprixinfo.gp == true)
{
if (savedata.lives > 0)
{
K_LoadGrandPrixSaveGame();
savedata.lives = 0;
}
else if (grandprixinfo.initalize == true)
{
K_InitGrandPrixRank(&grandprixinfo.rank);
K_InitGrandPrixBots();
grandprixinfo.initalize = false;
}
else
{
K_UpdateGrandPrixBots();
grandprixinfo.wonround = false;
}
}
else
{
// We're in a Match Race, use simplistic randomized bots.
K_UpdateMatchRaceBots();
}
if (roundqueue.snapshotmaps == true)
{
// Force spectator for snapshotmaps command
for (i = 0; i < MAXPLAYERS; i++)
{
if (!playeringame[i])
{
continue;
}
players[i].spectator = true;
}
}
P_ShuffleTeams();
K_TimerInit();
P_InitPlayers();
if (demo.recording) // Okay, level loaded, character spawned and skinned,
G_BeginRecording(); // I AM NOW READY TO RECORD.
demo.deferstart = true;
nextmapoverride = 0;
skipstats = 0;
P_RunCachedActions();
G_HandleSaveLevel(false);
if (marathonmode & MA_INGAME)
{
marathonmode = static_cast<marathonmode_t>(marathonmode & ~MA_INIT);
}
ACS_RunLevelStartScripts();
LUA_HookInt(gamemap, HOOK(MapLoad));
for (i = 0; i < MAXPLAYERS; i++)
{
if (!playeringame[i])
continue;
if (players[i].spectator)
continue;
ACS_RunPlayerEnterScript(&players[i]);
}
P_MapEnd();
// We're now done loading the level.
levelloading = false;
if (roundqueue.snapshotmaps == true)
{
if (roundqueue.size > 0)
{
D_TakeMapSnapshots();
G_GetNextMap();
// roundqueue is wiped after the last round, but
// preserve this to track state into the Podium!
roundqueue.snapshotmaps = true;
G_NextLevel();
return;
}
else
{
// Podium: snapshotmaps is finished. Yay!
HU_DoTitlecardCEcho(NULL, va("Congratulations,\\%s!\\Check the console!", cv_playername[0].string), true);
livestudioaudience_timer = 0;
LiveStudioAudience();
CONS_Printf("\n\n\x83""snapshotmaps: Find your images in %s\n", srb2home);
roundqueue.snapshotmaps = false;
}
}
TracyCZoneEnd(__zone);
}
//
// P_RunSOC
//
// Runs a SOC file or a lump, depending on if ".SOC" exists in the filename
//
boolean P_RunSOC(const char *socfilename)
{
lumpnum_t lump;
if (strstr(socfilename, ".soc") != NULL)
return P_AddWadFile(socfilename);
lump = W_CheckNumForName(socfilename);
if (lump == LUMPERROR)
return false;
CONS_Printf(M_GetText("Loading SOC lump: %s\n"), socfilename);
DEH_LoadDehackedLump(lump);
return true;
}
// Auxiliary function for PK3 loading - looks for sound replacements.
// NOTE: it does not really add any new sound entry or anything.
void P_LoadSoundsRange(UINT16 wadnum, UINT16 first, UINT16 num)
{
size_t j;
lumpinfo_t *lumpinfo = wadfiles[wadnum]->lumpinfo + first;
for (; num > 0; num--, lumpinfo++)
{
// Let's check whether it's replacing an existing sound or it's a brand new one.
for (j = 1; j < NUMSFX; j++)
{
if (S_sfx[j].name && !strnicmp(S_sfx[j].name, lumpinfo->name + 2, 6))
{
// the sound will be reloaded when needed,
// since sfx->data will be NULL
CONS_Debug(DBG_SETUP, "Sound %.8s replaced\n", lumpinfo->name);
I_FreeSfx(&S_sfx[j]);
break; // there shouldn't be two sounds with the same name, so stop looking
}
}
}
}
// Auxiliary function for PK3 loading - looks for music and music replacements.
// NOTE: does nothing but print debug messages. The code is handled somewhere else.
void P_LoadMusicsRange(UINT16 wadnum, UINT16 first, UINT16 num)
{
lumpinfo_t *lumpinfo = wadfiles[wadnum]->lumpinfo + first;
char *name;
for (; num > 0; num--, lumpinfo++)
{
name = lumpinfo->name;
if (name[0] == 'O' && name[1] == '_')
{
CONS_Debug(DBG_SETUP, "Music %.8s replaced\n", name);
}
else if (name[0] == 'D' && name[1] == '_')
{
CONS_Debug(DBG_SETUP, "Music %.8s replaced\n", name);
}
}
return;
}
// Auxiliary function - input a folder name and gives us the resource markers positions.
static lumpinfo_t* FindFolder(const char *folName, UINT16 *start, UINT16 *end, lumpinfo_t *lumpinfo, UINT16 *pnumlumps, size_t *pi)
{
UINT16 numlumps = *pnumlumps;
size_t i = *pi;
if (!stricmp(lumpinfo->fullname, folName))
{
lumpinfo++;
*start = ++i;
for (; i < numlumps; i++, lumpinfo++)
if (strnicmp(lumpinfo->fullname, folName, strlen(folName)))
break;
lumpinfo--;
*end = i-- - *start;
*pi = i;
*pnumlumps = numlumps;
return lumpinfo;
}
return lumpinfo;
}
static tic_t round_to_next_second(tic_t time)
{
return static_cast<tic_t>(std::ceil(time / static_cast<float>(TICRATE)) * TICRATE);
}
static void P_DeriveAutoMedalTimes(mapheader_t& map)
{
// Gather staff ghost times
std::vector<tic_t> stafftimes;
for (int i = 0; i < map.ghostCount; i++)
{
tic_t time = map.ghostBrief[i]->time;
if (time <= 0)
{
continue;
}
stafftimes.push_back(map.ghostBrief[i]->time);
}
if (stafftimes.empty())
{
// Use fallback times
map.automedaltime[0] = 1;
map.automedaltime[1] = 2;
map.automedaltime[2] = 3;
map.automedaltime[3] = 4;
return;
}
std::sort(stafftimes.begin(), stafftimes.end());
// Auto Platinum is the best staff ghost time
// Auto Gold is the median staff ghost time or 10% longer than Platinum, whichever is higher
// Silver and Bronze are 10% longer and 10% longer successively
// Gold, Silver and Bronze are rounded up to the next second
tic_t best = stafftimes.at(0);
tic_t gold = std::max(
round_to_next_second(stafftimes.at(stafftimes.size() / 2)),
round_to_next_second(static_cast<tic_t>(std::ceil(best * 1.1f)))
);
if (gold == best)
{
gold += 1;
}
tic_t silver = round_to_next_second(static_cast<tic_t>(std::ceil(gold * 1.1f)));
if (silver == gold)
{
silver += 1;
}
tic_t bronze = round_to_next_second(static_cast<tic_t>(std::ceil(silver * 1.1f)));
if (bronze == silver)
{
bronze += 1;
}
map.automedaltime[0] = best;
map.automedaltime[1] = gold;
map.automedaltime[2] = silver;
map.automedaltime[3] = bronze;
}
lumpnum_t wadnamelump = LUMPERROR;
INT16 wadnamemap = 0; // gamemap based
// Initialising map data (and catching replacements)...
UINT8 P_InitMapData(void)
{
UINT8 ret = 0;
INT32 i, j;
lumpnum_t maplump;
virtres_t *virtmap;
virtlump_t *minimap, *thumbnailPic;
char *name;
for (i = 0; i < nummapheaders; ++i)
{
name = mapheaderinfo[i]->lumpname;
maplump = W_CheckNumForMap(name, (mapheaderinfo[i]->lumpnum == LUMPERROR));
// Always check for cup cache reassociations.
// (The core assumption is that cups < headers.)
if (maplump != LUMPERROR || mapheaderinfo[i]->lumpnum != LUMPERROR)
{
cupheader_t *cup = kartcupheaders;
while (cup)
{
for (j = 0; j < CUPCACHE_MAX; j++)
{
// No level in this slot?
if (!cup->levellist[j])
continue;
// Already discovered?
if (cup->cachedlevels[j] != NEXTMAP_INVALID)
continue;
// Not your name?
if (strcasecmp(cup->levellist[j], name) != 0)
continue;
// Have a map recognise the first cup it's a part of.
if (!mapheaderinfo[i]->cup)
mapheaderinfo[i]->cup = cup;
cup->cachedlevels[j] = i;
}
cup = cup->next;
}
}
// Doesn't exist in this set of files?
if (maplump == LUMPERROR)
{
#ifndef DEVELOP
if (!basenummapheaders)
{
I_Error("P_InitMapData: Base map %s has a header but no level\n", name);
}
#endif
continue;
}
// No change?
if (mapheaderinfo[i]->lumpnum == maplump)
continue;
// Okay, it does...
{
ret |= MAPRET_ADDED;
if (basenummapheaders)
{
CONS_Printf("%s\n", name);
if (mapheaderinfo[i]->lumpnum != LUMPERROR)
{
G_SetGameModified(multiplayer, true); // oops, double-defined - no record attack privileges for you
//If you replaced the map you're on, end the level when done.
if (i == gamemap - 1)
ret |= MAPRET_CURRENTREPLACED;
}
}
mapheaderinfo[i]->lumpnum = maplump;
if (maplump == wadnamelump)
wadnamemap = i+1;
// Get map thumbnail and minimap
virtmap = vres_GetMap(mapheaderinfo[i]->lumpnum);
thumbnailPic = vres_Find(virtmap, "PICTURE");
minimap = vres_Find(virtmap, "MINIMAP");
// Clear out existing graphics...
if (mapheaderinfo[i]->thumbnailPic)
{
Patch_Free(static_cast<patch_t*>(mapheaderinfo[i]->thumbnailPic));
mapheaderinfo[i]->thumbnailPic = NULL;
}
if (mapheaderinfo[i]->minimapPic)
{
Patch_Free(static_cast<patch_t*>(mapheaderinfo[i]->minimapPic));
mapheaderinfo[i]->minimapPic = NULL;
}
// Now apply the new ones!
if (thumbnailPic != NULL)
{
mapheaderinfo[i]->thumbnailPic = vres_GetPatch(thumbnailPic, PU_STATIC);
}
if (minimap != NULL)
{
mapheaderinfo[i]->minimapPic = vres_GetPatch(minimap, PU_STATIC);
}
// Staff ghosts.
// The trouble with staff ghosts is that they're too large to cache.
// So we store extra information about them, and load later.
while (mapheaderinfo[i]->ghostCount > 0)
{
mapheaderinfo[i]->ghostCount--;
Z_Free(mapheaderinfo[i]->ghostBrief[mapheaderinfo[i]->ghostCount]);
mapheaderinfo[i]->ghostBrief[mapheaderinfo[i]->ghostCount] = NULL;
}
for (INT32 wadindex = 0; wadindex < numwadfiles; wadindex++)
{
if (wadfiles[wadindex]->type != RET_PK3)
{
continue;
}
std::string ghostdirname = fmt::format("staffghosts/{}/", mapheaderinfo[i]->lumpname);
UINT16 lumpstart = W_CheckNumForFolderStartPK3(ghostdirname.c_str(), wadindex, 0);
if (lumpstart == INT16_MAX)
{
continue;
}
UINT16 lumpend = W_CheckNumForFolderEndPK3(ghostdirname.c_str(), wadindex, lumpstart);
if (lumpend == INT16_MAX)
{
continue;
}
for (UINT16 lumpnum = lumpstart; lumpnum < lumpend; lumpnum++)
{
if (W_IsLumpFolder(wadindex, lumpnum))
{
continue;
}
size_t lumplength = W_LumpLengthPwad(wadindex, lumpnum);
UINT8* ghostdata = static_cast<UINT8*>(Z_Malloc(lumplength, PU_STATIC, nullptr));
auto ghostdata_finalizer = srb2::finally([=]() { Z_Free(ghostdata); });
W_ReadLumpPwad(wadindex, lumpnum, ghostdata);
staffbrief_t* briefghost = G_GetStaffGhostBrief(ghostdata);
if (briefghost == nullptr)
{
continue;
}
briefghost->wad = wadindex;
briefghost->lump = lumpnum;
// Resize ghostBrief if needed
if (mapheaderinfo[i]->ghostBriefSize < static_cast<UINT32>(mapheaderinfo[i]->ghostCount + 1))
{
UINT32 newsize = mapheaderinfo[i]->ghostBriefSize + 4;
mapheaderinfo[i]->ghostBrief = static_cast<staffbrief_t**>(Z_Realloc(mapheaderinfo[i]->ghostBrief, sizeof(staffbrief_t*) * newsize, PU_STATIC, NULL));
mapheaderinfo[i]->ghostBriefSize = newsize;
}
mapheaderinfo[i]->ghostBrief[mapheaderinfo[i]->ghostCount] = briefghost;
mapheaderinfo[i]->ghostCount++;
}
// Sort shortest to longest for Time Attack menu
std::sort(
mapheaderinfo[i]->ghostBrief,
mapheaderinfo[i]->ghostBrief + mapheaderinfo[i]->ghostCount,
[](staffbrief_t* a, staffbrief_t* b) { return a->time < b->time; }
);
}
P_DeriveAutoMedalTimes(*mapheaderinfo[i]);
vres_Free(virtmap);
}
}
return ret;
}
//
// Add a wadfile to the active wad files,
// replace sounds, musics, patches, textures, sprites and maps
//
boolean P_AddWadFile(const char *wadfilename)
{
UINT16 wadnum;
if ((wadnum = P_PartialAddWadFile(wadfilename)) == UINT16_MAX)
return false;
if (P_PartialAddGetStage() >= 0)
P_MultiSetupWadFiles(true);
return true;
}
//
// Add a WAD file and do the per-WAD setup stages.
// Call P_MultiSetupWadFiles as soon as possible after any number of these.
//
UINT16 P_PartialAddWadFile(const char *wadfilename)
{
size_t i, j, sreplaces = 0, mreplaces = 0, digmreplaces = 0;
UINT16 numlumps, wadnum;
char *name;
lumpinfo_t *lumpinfo;
// Vars to help us with the position start and amount of each resource type.
// Useful for PK3s since they use folders.
// WADs use markers for some resources, but others such as sounds are checked lump-by-lump anyway.
// UINT16 luaPos, luaNum = 0;
// UINT16 socPos, socNum = 0;
UINT16 sfxPos = 0, sfxNum = 0;
UINT16 musPos = 0, musNum = 0;
// UINT16 sprPos, sprNum = 0;
UINT16 texPos = 0, texNum = 0;
// UINT16 patPos, patNum = 0;
// UINT16 flaPos, flaNum = 0;
// UINT16 mapPos, mapNum = 0;
// Init file.
if ((numlumps = W_InitFile(wadfilename, false, false)) == INT16_MAX)
{
refreshdirmenu |= REFRESHDIR_NOTLOADED;
return false;
}
wadnum = (UINT16)(numwadfiles-1);
// Init partadd.
if (wadfiles[wadnum]->important)
{
partadd_important = true;
}
if (partadd_stage != 0)
{
partadd_earliestfile = wadnum;
}
partadd_stage = 0;
switch(wadfiles[wadnum]->type)
{
case RET_PK3:
// Look for the lumps that act as resource delimitation markers.
lumpinfo = wadfiles[wadnum]->lumpinfo;
for (i = 0; i < numlumps; i++, lumpinfo++)
{
// lumpinfo = FindFolder("Lua/", &luaPos, &luaNum, lumpinfo, &numlumps, &i);
// lumpinfo = FindFolder("SOC/", &socPos, &socNum, lumpinfo, &numlumps, &i);
lumpinfo = FindFolder("Sounds/", &sfxPos, &sfxNum, lumpinfo, &numlumps, &i);
lumpinfo = FindFolder("Music/", &musPos, &musNum, lumpinfo, &numlumps, &i);
// lumpinfo = FindFolder("Sprites/", &sprPos, &sprNum, lumpinfo, &numlumps, &i);
lumpinfo = FindFolder("Textures/", &texPos, &texNum, lumpinfo, &numlumps, &i);
// lumpinfo = FindFolder("Patches/", &patPos, &patNum, lumpinfo, &numlumps, &i);
// lumpinfo = FindFolder("Flats/", &flaPos, &flaNum, lumpinfo, &numlumps, &i);
// lumpinfo = FindFolder("Maps/", &mapPos, &mapNum, lumpinfo, &numlumps, &i);
}
// Update the detected resources.
// Note: ALWAYS load Lua scripts first, SOCs right after, and the remaining resources afterwards.
// if (luaNum) // Lua scripts.
// P_LoadLuaScrRange(wadnum, luaPos, luaNum);
// if (socNum) // SOCs.
// P_LoadDehackRange(wadnum, socPos, socNum);
if (sfxNum) // Sounds. TODO: Function currently only updates already existing sounds, the rest is handled somewhere else.
P_LoadSoundsRange(wadnum, sfxPos, sfxNum);
if (musNum) // Music. TODO: Useless function right now.
P_LoadMusicsRange(wadnum, musPos, musNum);
// if (sprNum) // Sprites.
// R_LoadSpritsRange(wadnum, sprPos, sprNum);
// if (texNum) // Textures. TODO: R_LoadTextures() does the folder positioning once again. New function maybe?
// R_LoadTextures();
break;
default:
lumpinfo = wadfiles[wadnum]->lumpinfo;
for (i = 0; i < numlumps; i++, lumpinfo++)
{
name = lumpinfo->name;
if (name[0] == 'D')
{
if (name[1] == 'S')
{
for (j = 1; j < NUMSFX; j++)
{
if (S_sfx[j].name && !strnicmp(S_sfx[j].name, name + 2, 6))
{
// the sound will be reloaded when needed,
// since sfx->data will be NULL
CONS_Debug(DBG_SETUP, "Sound %.8s replaced\n", name);
I_FreeSfx(&S_sfx[j]);
sreplaces++;
break; // there shouldn't be two sounds with the same name, so stop looking
}
}
}
else if (name[1] == '_')
{
CONS_Debug(DBG_SETUP, "Music %.8s ignored\n", name);
mreplaces++;
}
}
else if (name[0] == 'O' && name[1] == '_')
{
CONS_Debug(DBG_SETUP, "Music %.8s replaced\n", name);
digmreplaces++;
}
}
break;
}
if (!devparm && sreplaces)
CONS_Printf(M_GetText("%s sounds replaced\n"), sizeu1(sreplaces));
if (!devparm && mreplaces)
CONS_Printf(M_GetText("%s midi musics ignored\n"), sizeu1(mreplaces));
if (!devparm && digmreplaces)
CONS_Printf(M_GetText("%s digital musics replaced\n"), sizeu1(digmreplaces));
#ifdef HWRENDER
// Free GPU textures before freeing patches.
if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
HWR_ClearAllTextures();
#endif
//
// search for sprite replacements
//
Patch_FreeTag(PU_SPRITE);
Patch_FreeTag(PU_PATCH_ROTATED);
R_AddSpriteDefs(wadnum);
// Reload it all anyway, just in case they
// added some textures but didn't insert a
// TEXTURES/etc. list.
R_LoadTexturesPwad(wadnum); // numtexture changes
// Reload BRIGHT
K_InitBrightmapsPwad(wadnum);
//
// look for skins
//
R_AddSkins(wadnum, false); // faB: wadfile index in wadfiles[]
R_PatchSkins(wadnum, false); // toast: PATCH PATCH
//
// edit music defs
//
S_LoadMusicDefs(wadnum);
//
// extra sprite/skin data
//
R_LoadSpriteInfoLumps(wadnum, numlumps);
// For anything that has to be done over every wadfile at once, see P_MultiSetupWadFiles.
refreshdirmenu &= ~REFRESHDIR_GAMEDATA; // Under usual circumstances we'd wait for REFRESHDIR_ flags to disappear the next frame, but this one's a bit too dangerous for that...
return true;
}
// Only exists to make sure there's no way to overwrite partadd_stage externally
// unless you really push yourself.
SINT8 P_PartialAddGetStage(void)
{
return partadd_stage;
}
//
// Set up a series of partially added WAD files.
// Setup functions that iterate over every loaded WAD go here.
// If fullsetup false, only do one stage per call.
//
boolean P_MultiSetupWadFiles(boolean fullsetup)
{
if (partadd_stage < 0)
I_Error(M_GetText("P_MultiSetupWadFiles: Post-load addon setup attempted without loading any addons first"));
if (partadd_stage == 0)
{
// Flush and reload HUD graphics
//ST_UnloadGraphics();
HU_LoadGraphics();
ST_LoadGraphics();
ST_ReloadSkinFaceGraphics();
if (!partadd_important)
partadd_stage = -1; // everything done
else if (fullsetup)
partadd_stage++;
}
if (partadd_stage == 1)
{
// Prevent savefile cheating
if (cursaveslot >= 0)
cursaveslot = 0;
// Reload ANIMATED / ANIMDEFS
P_InitPicAnims();
// reload status bar (warning should have valid player!)
if (gamestate == GS_LEVEL)
ST_Start();
#ifdef HWRENDER
HWR_ReloadModels();
#endif
if (fullsetup)
partadd_stage++;
}
if (partadd_stage == 2)
{
UINT8 mapsadded = P_InitMapData();
if (!mapsadded)
CONS_Printf(M_GetText("No maps added\n"));
if ((mapsadded & MAPRET_CURRENTREPLACED)
&& (gamestate == GS_LEVEL)
&& (netgame || multiplayer))
{
CONS_Printf(M_GetText("Current map %d replaced by added file, ending the level to ensure consistency.\n"), gamemap);
if (server)
SendNetXCmd(XD_EXITLEVEL, NULL, 0);
}
//if (fullsetup)
//partadd_stage++;
partadd_stage = -1;
}
I_Assert(!fullsetup || partadd_stage < 0);
if (partadd_stage < 0)
{
// possible future work: only do this if musicdefs/map headers changed
S_PopulateSoundTestSequence();
partadd_important = false;
partadd_earliestfile = UINT16_MAX;
return true;
}
partadd_stage++;
return false;
}
Reference in a new issue View git blame Copy permalink