ref: 8d3f31b70dd68e1bb49cbad976acc0119e329ef8
dir: /src/doom/p_spec.h/
//
// Copyright(C) 1993-1996 Id Software, Inc.
// Copyright(C) 2005-2014 Simon Howard
//
// 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 2
// 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.
//
// DESCRIPTION: none
// Implements special effects:
// Texture animation, height or lighting changes
// according to adjacent sectors, respective
// utility functions, etc.
//
#ifndef __P_SPEC__
#define __P_SPEC__
//
// End-level timer (-TIMER option)
//
extern boolean levelTimer;
extern int levelTimeCount;
// Define values for map objects
#define MO_TELEPORTMAN 14
// at game start
void P_InitPicAnims (void);
// at map load
void P_SpawnSpecials (void);
// every tic
void P_UpdateSpecials (void);
// when needed
boolean
P_UseSpecialLine
( mobj_t* thing,
line_t* line,
int side );
void
P_ShootSpecialLine
( mobj_t* thing,
line_t* line );
void
P_CrossSpecialLine
( int linenum,
int side,
mobj_t* thing );
void P_PlayerInSpecialSector (player_t* player);
int
twoSided
( int sector,
int line );
sector_t*
getSector
( int currentSector,
int line,
int side );
side_t*
getSide
( int currentSector,
int line,
int side );
fixed_t P_FindLowestFloorSurrounding(sector_t* sec);
fixed_t P_FindHighestFloorSurrounding(sector_t* sec);
fixed_t
P_FindNextHighestFloor
( sector_t* sec,
int currentheight );
fixed_t P_FindLowestCeilingSurrounding(sector_t* sec);
fixed_t P_FindHighestCeilingSurrounding(sector_t* sec);
int
P_FindSectorFromLineTag
( line_t* line,
int start );
int
P_FindMinSurroundingLight
( sector_t* sector,
int max );
sector_t*
getNextSector
( line_t* line,
sector_t* sec );
//
// SPECIAL
//
int EV_DoDonut(line_t* line);
//
// P_LIGHTS
//
typedef struct
{
thinker_t thinker;
sector_t* sector;
int count;
int maxlight;
int minlight;
} fireflicker_t;
typedef struct
{
thinker_t thinker;
sector_t* sector;
int count;
int maxlight;
int minlight;
int maxtime;
int mintime;
} lightflash_t;
typedef struct
{
thinker_t thinker;
sector_t* sector;
int count;
int minlight;
int maxlight;
int darktime;
int brighttime;
} strobe_t;
typedef struct
{
thinker_t thinker;
sector_t* sector;
int minlight;
int maxlight;
int direction;
} glow_t;
#define GLOWSPEED 8
#define STROBEBRIGHT 5
#define FASTDARK 15
#define SLOWDARK 35
void P_SpawnFireFlicker (sector_t* sector);
void T_LightFlash (lightflash_t* flash);
void P_SpawnLightFlash (sector_t* sector);
void T_StrobeFlash (strobe_t* flash);
void
P_SpawnStrobeFlash
( sector_t* sector,
int fastOrSlow,
int inSync );
void EV_StartLightStrobing(line_t* line);
void EV_TurnTagLightsOff(line_t* line);
void
EV_LightTurnOn
( line_t* line,
int bright );
void T_Glow(glow_t* g);
void P_SpawnGlowingLight(sector_t* sector);
//
// P_SWITCH
//
typedef struct
{
char name1[9];
char name2[9];
short episode;
} switchlist_t;
typedef enum
{
top,
middle,
bottom
} bwhere_e;
typedef struct
{
line_t* line;
bwhere_e where;
int btexture;
int btimer;
degenmobj_t *soundorg;
} button_t;
// max # of wall switches in a level
#define MAXSWITCHES 50
// 4 players, 4 buttons each at once, max.
#define MAXBUTTONS 16
// 1 second, in ticks.
#define BUTTONTIME 35
extern button_t buttonlist[MAXBUTTONS];
void
P_ChangeSwitchTexture
( line_t* line,
int useAgain );
void P_InitSwitchList(void);
//
// P_PLATS
//
typedef enum
{
up,
down,
waiting,
in_stasis
} plat_e;
typedef enum
{
perpetualRaise,
downWaitUpStay,
raiseAndChange,
raiseToNearestAndChange,
blazeDWUS
} plattype_e;
typedef struct
{
thinker_t thinker;
sector_t* sector;
fixed_t speed;
fixed_t low;
fixed_t high;
int wait;
int count;
plat_e status;
plat_e oldstatus;
boolean crush;
int tag;
plattype_e type;
} plat_t;
#define PLATWAIT 3
#define PLATSPEED FRACUNIT
#define MAXPLATS 30
extern plat_t* activeplats[MAXPLATS];
void T_PlatRaise(plat_t* plat);
int
EV_DoPlat
( line_t* line,
plattype_e type,
int amount );
void P_AddActivePlat(plat_t* plat);
void P_RemoveActivePlat(plat_t* plat);
void EV_StopPlat(line_t* line);
void P_ActivateInStasis(int tag);
//
// P_DOORS
//
typedef enum
{
vld_normal,
vld_close30ThenOpen,
vld_close,
vld_open,
vld_raiseIn5Mins,
vld_blazeRaise,
vld_blazeOpen,
vld_blazeClose
} vldoor_e;
typedef struct
{
thinker_t thinker;
vldoor_e type;
sector_t* sector;
fixed_t topheight;
fixed_t speed;
// 1 = up, 0 = waiting at top, -1 = down
int direction;
// tics to wait at the top
int topwait;
// (keep in case a door going down is reset)
// when it reaches 0, start going down
int topcountdown;
} vldoor_t;
#define VDOORSPEED FRACUNIT*2
#define VDOORWAIT 150
void
EV_VerticalDoor
( line_t* line,
mobj_t* thing );
int
EV_DoDoor
( line_t* line,
vldoor_e type );
int
EV_DoLockedDoor
( line_t* line,
vldoor_e type,
mobj_t* thing );
void T_VerticalDoor (vldoor_t* door);
void P_SpawnDoorCloseIn30 (sector_t* sec);
void
P_SpawnDoorRaiseIn5Mins
( sector_t* sec,
int secnum );
#if 0 // UNUSED
//
// Sliding doors...
//
typedef enum
{
sd_opening,
sd_waiting,
sd_closing
} sd_e;
typedef enum
{
sdt_openOnly,
sdt_closeOnly,
sdt_openAndClose
} sdt_e;
typedef struct
{
thinker_t thinker;
sdt_e type;
line_t* line;
int frame;
int whichDoorIndex;
int timer;
sector_t* frontsector;
sector_t* backsector;
sd_e status;
} slidedoor_t;
typedef struct
{
char frontFrame1[9];
char frontFrame2[9];
char frontFrame3[9];
char frontFrame4[9];
char backFrame1[9];
char backFrame2[9];
char backFrame3[9];
char backFrame4[9];
} slidename_t;
typedef struct
{
int frontFrames[4];
int backFrames[4];
} slideframe_t;
// how many frames of animation
#define SNUMFRAMES 4
#define SDOORWAIT 35*3
#define SWAITTICS 4
// how many diff. types of anims
#define MAXSLIDEDOORS 5
void P_InitSlidingDoorFrames(void);
void
EV_SlidingDoor
( line_t* line,
mobj_t* thing );
#endif
//
// P_CEILNG
//
typedef enum
{
lowerToFloor,
raiseToHighest,
lowerAndCrush,
crushAndRaise,
fastCrushAndRaise,
silentCrushAndRaise
} ceiling_e;
typedef struct
{
thinker_t thinker;
ceiling_e type;
sector_t* sector;
fixed_t bottomheight;
fixed_t topheight;
fixed_t speed;
boolean crush;
// 1 = up, 0 = waiting, -1 = down
int direction;
// ID
int tag;
int olddirection;
} ceiling_t;
#define CEILSPEED FRACUNIT
#define CEILWAIT 150
#define MAXCEILINGS 30
extern ceiling_t* activeceilings[MAXCEILINGS];
int
EV_DoCeiling
( line_t* line,
ceiling_e type );
void T_MoveCeiling (ceiling_t* ceiling);
void P_AddActiveCeiling(ceiling_t* c);
void P_RemoveActiveCeiling(ceiling_t* c);
int EV_CeilingCrushStop(line_t* line);
void P_ActivateInStasisCeiling(line_t* line);
//
// P_FLOOR
//
typedef enum
{
// lower floor to highest surrounding floor
lowerFloor,
// lower floor to lowest surrounding floor
lowerFloorToLowest,
// lower floor to highest surrounding floor VERY FAST
turboLower,
// raise floor to lowest surrounding CEILING
raiseFloor,
// raise floor to next highest surrounding floor
raiseFloorToNearest,
// raise floor to shortest height texture around it
raiseToTexture,
// lower floor to lowest surrounding floor
// and change floorpic
lowerAndChange,
raiseFloor24,
raiseFloor24AndChange,
raiseFloorCrush,
// raise to next highest floor, turbo-speed
raiseFloorTurbo,
donutRaise,
raiseFloor512
} floor_e;
typedef enum
{
build8, // slowly build by 8
turbo16 // quickly build by 16
} stair_e;
typedef struct
{
thinker_t thinker;
floor_e type;
boolean crush;
sector_t* sector;
int direction;
int newspecial;
short texture;
fixed_t floordestheight;
fixed_t speed;
} floormove_t;
#define FLOORSPEED FRACUNIT
typedef enum
{
ok,
crushed,
pastdest
} result_e;
result_e
T_MovePlane
( sector_t* sector,
fixed_t speed,
fixed_t dest,
boolean crush,
int floorOrCeiling,
int direction );
int
EV_BuildStairs
( line_t* line,
stair_e type );
int
EV_DoFloor
( line_t* line,
floor_e floortype );
void T_MoveFloor( floormove_t* floor);
//
// P_TELEPT
//
int
EV_Teleport
( line_t* line,
int side,
mobj_t* thing );
#endif