zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-12-14 22:41:53 +00:00
Code Issues Projects Releases Packages Wiki Activity
qzdoom/src/doomdata.h
PaulyB 573b2958c6 Added MTF_NOCOUNT to spawn flags
2020-04-27 20:30:37 +02:00

455 lines
12 KiB
C
Raw Blame History

//-----------------------------------------------------------------------------
//
// Copyright 1993-1996 id Software
// Copyright 1994-1996 Raven Software
// Copyright 1999-2016 Randy Heit
// Copyright 2002-2016 Christoph Oelckers
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see http://www.gnu.org/licenses/
//
//-----------------------------------------------------------------------------
//
// DESCRIPTION:
// all external data is defined here
// most of the data is loaded into different structures at run time
// some internal structures shared by many modules are here
//
//-----------------------------------------------------------------------------
#ifndef __DOOMDATA__
#define __DOOMDATA__
// The most basic types we use, portability.
#include "doomtype.h"
#include "vectors.h"
// Some global defines, that configure the game.
#include "doomdef.h"
#include "m_swap.h"
//
// Map level types.
// The following data structures define the persistent format
// used in the lumps of the WAD files.
//
// Lump order in a map WAD: each map needs a couple of lumps
// to provide a complete scene geometry description.
enum
{
ML_LABEL, // A separator, name, ExMx or MAPxx
ML_THINGS, // Monsters, items
ML_LINEDEFS, // LineDefs, from editing
ML_SIDEDEFS, // SideDefs, from editing
ML_VERTEXES, // Vertices, edited and BSP splits generated
ML_SEGS, // LineSegs, from LineDefs split by BSP
ML_SSECTORS, // SubSectors, list of LineSegs
ML_NODES, // BSP nodes
ML_SECTORS, // Sectors, from editing
ML_REJECT, // LUT, sector-sector visibility
ML_BLOCKMAP, // LUT, motion clipping, walls/grid element
ML_BEHAVIOR, // [RH] Hexen-style scripts. If present, THINGS
// and LINEDEFS are also Hexen-style.
ML_CONVERSATION, // Strife dialog (only for TEXTMAP format)
ML_MAX,
// [RH] These are compressed (and extended) nodes. They combine the data from
// vertexes, segs, ssectors, and nodes into a single lump.
ML_ZNODES = ML_NODES,
ML_GLZNODES = ML_SSECTORS,
// for text map format
ML_TEXTMAP = ML_THINGS,
};
// A single Vertex.
struct mapvertex_t
{
int16_t x, y;
};
// A SideDef, defining the visual appearance of a wall,
// by setting textures and offsets.
struct mapsidedef_t
{
int16_t textureoffset;
int16_t rowoffset;
char toptexture[8];
char bottomtexture[8];
char midtexture[8];
int16_t sector; // Front sector, towards viewer.
};
struct intmapsidedef_t
{
FString toptexture;
FString bottomtexture;
FString midtexture;
};
// A LineDef, as used for editing, and as input to the BSP builder.
struct maplinedef_t
{
uint16_t v1;
uint16_t v2;
uint16_t flags;
uint16_t special;
int16_t tag;
uint16_t sidenum[2]; // sidenum[1] will be -1 if one sided
} ;
// [RH] Hexen-compatible LineDef.
struct maplinedef2_t
{
uint16_t v1;
uint16_t v2;
uint16_t flags;
uint8_t special;
uint8_t args[5];
uint16_t sidenum[2];
} ;
//
// LineDef attributes.
//
enum ELineFlags : unsigned
{
ML_BLOCKING =0x00000001, // solid, is an obstacle
ML_BLOCKMONSTERS =0x00000002, // blocks monsters only
ML_TWOSIDED =0x00000004, // backside will not be present at all if not two sided
// If a texture is pegged, the texture will have
// the end exposed to air held constant at the
// top or bottom of the texture (stairs or pulled
// down things) and will move with a height change
// of one of the neighbor sectors.
// Unpegged textures always have the first row of
// the texture at the top pixel of the line for both
// top and bottom textures (use next to windows).
ML_DONTPEGTOP = 0x00000008, // upper texture unpegged
ML_DONTPEGBOTTOM = 0x00000010, // lower texture unpegged
ML_SECRET = 0x00000020, // don't map as two sided: IT'S A SECRET!
ML_SOUNDBLOCK = 0x00000040, // don't let sound cross two of these
ML_DONTDRAW = 0x00000080, // don't draw on the automap
ML_MAPPED = 0x00000100, // set if already drawn in automap
ML_REPEAT_SPECIAL = 0x00000200, // special is repeatable
// 0x400, 0x800 and 0x1000 are ML_SPAC_MASK, they can be used for internal things but not for real map flags.
ML_ADDTRANS = 0x00000400, // additive translucency (can only be set internally)
ML_COMPATSIDE = 0x00000800, // for compatible PointOnLineSide checks. Using the global compatibility check would be a bit expensive for this check.
// Extended flags
ML_NOSKYWALLS = 0x00001000, // Don't draw sky above or below walls
ML_MONSTERSCANACTIVATE = 0x00002000, // [RH] Monsters (as well as players) can activate the line
ML_BLOCK_PLAYERS = 0x00004000,
ML_BLOCKEVERYTHING = 0x00008000, // [RH] Line blocks everything
ML_ZONEBOUNDARY = 0x00010000,
ML_RAILING = 0x00020000,
ML_BLOCK_FLOATERS = 0x00040000,
ML_CLIP_MIDTEX = 0x00080000, // Automatic for every Strife line
ML_WRAP_MIDTEX = 0x00100000,
ML_3DMIDTEX = 0x00200000,
ML_CHECKSWITCHRANGE = 0x00400000,
ML_FIRSTSIDEONLY = 0x00800000, // activated only when crossed from front side
ML_BLOCKPROJECTILE = 0x01000000,
ML_BLOCKUSE = 0x02000000, // blocks all use actions through this line
ML_BLOCKSIGHT = 0x04000000, // blocks monster line of sight
ML_BLOCKHITSCAN = 0x08000000, // blocks hitscan attacks
ML_3DMIDTEX_IMPASS = 0x10000000, // [TP] if 3D midtex, behaves like a height-restricted ML_BLOCKING
ML_REVEALED = 0x20000000, // set if revealed in automap
ML_DRAWFULLHEIGHT = 0x40000000, // Draw the full height of the upper/lower sections
ML_PORTALCONNECT = 0x80000000, // for internal use only: This line connects to a sector with a linked portal (used to speed up sight checks.)
};
// Special activation types
enum SPAC
{
SPAC_Cross = 1<<0, // when player crosses line
SPAC_Use = 1<<1, // when player uses line
SPAC_MCross = 1<<2, // when monster crosses line
SPAC_Impact = 1<<3, // when projectile hits line
SPAC_Push = 1<<4, // when player pushes line
SPAC_PCross = 1<<5, // when projectile crosses line
SPAC_UseThrough = 1<<6, // when player uses line (doesn't block)
// SPAC_PTOUCH is mapped to SPAC_PCross|SPAC_Impact
SPAC_AnyCross = 1<<7, // when anything without the MF2_TELEPORT flag crosses the line
SPAC_MUse = 1<<8, // monsters can use
SPAC_MPush = 1<<9, // monsters can push
SPAC_UseBack = 1<<10, // Can be used from the backside
SPAC_Damage = 1<<11, // [ZZ] when linedef receives damage
SPAC_Death = 1<<12, // [ZZ] when linedef receives damage and has 0 health
SPAC_PlayerActivate = (SPAC_Cross|SPAC_Use|SPAC_Impact|SPAC_Push|SPAC_AnyCross|SPAC_UseThrough|SPAC_UseBack),
};
enum EMapLineFlags // These are flags that use different values internally
{
// For Hexen format maps
ML_SPAC_SHIFT = 10,
ML_SPAC_MASK = 0x1c00, // Hexen's activator mask.
// [RH] BOOM's ML_PASSUSE flag (conflicts with ML_REPEATSPECIAL)
ML_PASSUSE_BOOM = 0x0200,
ML_3DMIDTEX_ETERNITY = 0x0400,
// If this bit is set, then all non-original-Doom bits are cleared when
// translating the line. Only applies when playing Doom with Doom-format maps.
// Hexen format maps and the other games are not affected by this.
ML_RESERVED_ETERNITY = 0x0800,
// [RH] Extra flags for Strife
ML_RAILING_STRIFE = 0x0200,
ML_BLOCK_FLOATERS_STRIFE = 0x0400,
ML_TRANSPARENT_STRIFE = 0x0800,
ML_TRANSLUCENT_STRIFE = 0x1000,
};
static inline int GET_SPAC (int flags)
{
return (flags&ML_SPAC_MASK) >> ML_SPAC_SHIFT;
}
// Sector definition, from editing
struct mapsector_t
{
int16_t floorheight;
int16_t ceilingheight;
char floorpic[8];
char ceilingpic[8];
int16_t lightlevel;
int16_t special;
int16_t tag;
};
// SubSector, as generated by BSP
struct mapsubsector_t
{
uint16_t numsegs;
uint16_t firstseg; // index of first one, segs are stored sequentially
};
#pragma pack(1)
struct mapsubsector4_t
{
uint16_t numsegs;
uint32_t firstseg; // index of first one, segs are stored sequentially
};
#pragma pack()
// LineSeg, generated by splitting LineDefs
// using partition lines selected by BSP builder.
struct mapseg_t
{
uint16_t v1;
uint16_t v2;
int16_t angle;
uint16_t linedef;
int16_t side;
int16_t offset;
int V1() { return LittleShort(v1); }
int V2() { return LittleShort(v2); }
};
struct mapseg4_t
{
int32_t v1;
int32_t v2;
int16_t angle;
uint16_t linedef;
int16_t side;
int16_t offset;
int V1() { return LittleLong(v1); }
int V2() { return LittleLong(v2); }
};
// BSP node structure.
// Indicate a leaf.
struct mapnode_t
{
enum
{
NF_SUBSECTOR = 0x8000,
NF_LUMPOFFSET = 0
};
int16_t x,y,dx,dy; // partition line
int16_t bbox[2][4]; // bounding box for each child
// If NF_SUBSECTOR is or'ed in, it's a subsector,
// else it's a node of another subtree.
uint16_t children[2];
uint32_t Child(int num) { return LittleShort(children[num]); }
};
struct mapnode4_t
{
enum
{
NF_SUBSECTOR = 0x80000000,
NF_LUMPOFFSET = 8
};
int16_t x,y,dx,dy; // partition line
int16_t bbox[2][4]; // bounding box for each child
// If NF_SUBSECTOR is or'ed in, it's a subsector,
// else it's a node of another subtree.
uint32_t children[2];
uint32_t Child(int num) { return LittleLong(children[num]); }
};
// Thing definition, position, orientation and type,
// plus skill/visibility flags and attributes.
struct mapthing_t
{
int16_t x;
int16_t y;
int16_t angle;
int16_t type;
int16_t options;
};
// [RH] Hexen-compatible MapThing.
struct mapthinghexen_t
{
int16_t thingid;
int16_t x;
int16_t y;
int16_t z;
int16_t angle;
int16_t type;
uint16_t flags;
uint8_t special;
uint8_t args[5];
};
struct FDoomEdEntry;
// Internal representation of a mapthing
struct FMapThing
{
int thingid;
DVector3 pos;
int16_t angle;
uint16_t SkillFilter;
uint16_t ClassFilter;
int16_t EdNum;
FDoomEdEntry *info;
uint32_t flags;
int special;
int args[5];
int Conversation;
double Gravity;
double Alpha;
uint32_t fillcolor;
DVector2 Scale;
double Health;
int score;
int16_t pitch;
int16_t roll;
uint32_t RenderStyle;
int FloatbobPhase;
int friendlyseeblocks;
FName arg0str;
};
// [RH] MapThing flags.
enum EMapThingFlags
{
/*
MTF_EASY = 0x0001, // The skill flags are no longer used directly.
MTF_MEDIUM = 0x0002,
MTF_HARD = 0x0004,
*/
MTF_SKILLMASK = 0x0007,
MTF_SKILLSHIFT = 1, // Skill bits will be shifted 1 bit to the left to make room
// for a bit representing the lowest skill (sk_baby)
MTF_AMBUSH = 0x0008, // Thing is deaf
MTF_DORMANT = 0x0010, // Thing is dormant (use Thing_Activate)
/*
MTF_FIGHTER = 0x0020, // The class flags are no longer used directly.
MTF_CLERIC = 0x0040,
MTF_MAGE = 0x0080,
*/
MTF_CLASS_MASK = 0x00e0,
MTF_CLASS_SHIFT = 5,
MTF_SINGLE = 0x0100, // Thing appears in single-player games
MTF_COOPERATIVE = 0x0200, // Thing appears in cooperative games
MTF_DEATHMATCH = 0x0400, // Thing appears in deathmatch games
MTF_SHADOW = 0x0800,
MTF_ALTSHADOW = 0x1000,
MTF_FRIENDLY = 0x2000,
MTF_STANDSTILL = 0x4000,
MTF_STRIFESOMETHING = 0x8000,
MTF_SECRET = 0x080000, // Secret pickup
MTF_NOINFIGHTING = 0x100000,
MTF_NOCOUNT = 0x200000, // Removes COUNTKILL/COUNTITEM
// BOOM and DOOM compatible versions of some of the above
BTF_NOTSINGLE = 0x0010, // (TF_COOPERATIVE|TF_DEATHMATCH)
BTF_NOTDEATHMATCH = 0x0020, // (TF_SINGLE|TF_COOPERATIVE)
BTF_NOTCOOPERATIVE = 0x0040, // (TF_SINGLE|TF_DEATHMATCH)
BTF_FRIENDLY = 0x0080, // MBF friendly monsters
BTF_BADEDITORCHECK = 0x0100, // for detecting bad (Mac) editors
// Strife thing flags
STF_STANDSTILL = 0x0008,
STF_AMBUSH = 0x0020,
STF_FRIENDLY = 0x0040,
STF_SHADOW = 0x0100,
STF_ALTSHADOW = 0x0200,
};
// A simplified mapthing for player starts
struct FPlayerStart
{
DVector3 pos;
int16_t angle, type;
FPlayerStart() = default;
FPlayerStart(const FMapThing *mthing, int pnum)
: pos(mthing->pos),
angle(mthing->angle),
type(pnum)
{ }
};
#endif // __DOOMDATA__
Reference in a new issue View git blame Copy permalink