mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-12 09:57:05 +03:00
646 lines
9.4 KiB
C++
Executable File
646 lines
9.4 KiB
C++
Executable File
// Emacs style mode select -*- C++ -*-
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Id:$
|
|
//
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
//
|
|
// This source is available for distribution and/or modification
|
|
// only under the terms of the DOOM Source Code License as
|
|
// published by id Software. All rights reserved.
|
|
//
|
|
// The source is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code 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;
|
|
mobj_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
|
|
{
|
|
normal,
|
|
close30ThenOpen,
|
|
close,
|
|
open,
|
|
raiseIn5Mins,
|
|
blazeRaise,
|
|
blazeOpen,
|
|
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
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Log:$
|
|
//
|
|
//-----------------------------------------------------------------------------
|