zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-29 23:33:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

- another large batch of level references removed.

Browse source
This commit is contained in:
Christoph Oelckers 2019-01-08 20:40:43 +01:00
parent d027ef95a3
commit e91971964f
27 changed files with 350 additions and 339 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/b_func.cpp
View file

@ -73,7 +73,7 @@ bool DBot::Reachable (AActor *rtarget)
double estimated_dist = player->mo->Distance2D(rtarget);
bool reachable = true;
FPathTraverse it(player->mo->X()+player->mo->Vel.X, player->mo->Y()+player->mo->Vel.Y, rtarget->X(), rtarget->Y(), PT_ADDLINES|PT_ADDTHINGS);
FPathTraverse it(player->mo->Level, player->mo->X()+player->mo->Vel.X, player->mo->Y()+player->mo->Vel.Y, rtarget->X(), rtarget->Y(), PT_ADDLINES|PT_ADDTHINGS);
intercept_t *in;
while ((in = it.Next()))
{

4
src/fragglescript/t_func.cpp
View file

@ -2042,7 +2042,7 @@ void FParser::SF_OpenDoor(void)
if(t_argc > 2) speed = intvalue(t_argv[2]);
else speed = 1; // 1= normal speed
EV_DoDoor(wait_time ? DDoor::doorRaise : DDoor::doorOpen, NULL, NULL, sectag, 2. * clamp(speed, 1, 127), wait_time, 0, 0);
EV_DoDoor(Level, wait_time ? DDoor::doorRaise : DDoor::doorOpen, NULL, NULL, sectag, 2. * clamp(speed, 1, 127), wait_time, 0, 0);
}
}
@ -2067,7 +2067,7 @@ void FParser::SF_CloseDoor(void)
if(t_argc > 1) speed = intvalue(t_argv[1]);
else speed = 1; // 1= normal speed
EV_DoDoor(DDoor::doorClose, NULL, NULL, sectag, 2.*clamp(speed, 1, 127), 0, 0, 0);
EV_DoDoor(Level, DDoor::doorClose, NULL, NULL, sectag, 2.*clamp(speed, 1, 127), 0, 0, 0);
}
}

2
src/maploader/maploader.cpp
View file

@ -3228,7 +3228,7 @@ void MapLoader::LoadLevel(MapData *map, const char *lumpname, int position)
SWRenderer->SetColormap(Level); //The SW renderer needs to do some special setup for the level's default colormap.
InitPortalGroups(Level);
P_InitHealthGroups();
P_InitHealthGroups(Level);
if (reloop) LoopSidedefs(false);
PO_Init(); // Initialize the polyobjs

8
src/p_acs.cpp
View file

@ -6670,17 +6670,17 @@ doplaysound: if (funcIndex == ACSF_PlayActorSound)
FHealthGroup* grp;
if (part == SECPART_Ceiling)
{
return (ss->healthceilinggroup && (grp = P_GetHealthGroup(ss->healthceilinggroup)))
return (ss->healthceilinggroup && (grp = P_GetHealthGroup(Level, ss->healthceilinggroup)))
? grp->health : ss->healthceiling;
}
else if (part == SECPART_Floor)
{
return (ss->healthfloorgroup && (grp = P_GetHealthGroup(ss->healthfloorgroup)))
return (ss->healthfloorgroup && (grp = P_GetHealthGroup(Level, ss->healthfloorgroup)))
? grp->health : ss->healthfloor;
}
else if (part == SECPART_3D)
{
return (ss->health3dgroup && (grp = P_GetHealthGroup(ss->health3dgroup)))
return (ss->health3dgroup && (grp = P_GetHealthGroup(Level, ss->health3dgroup)))
? grp->health : ss->health3d;
}
return 0;
@ -6695,7 +6695,7 @@ doplaysound: if (funcIndex == ACSF_PlayActorSound)
line_t* ll = &Level->lines[l];
if (ll->healthgroup > 0)
{
FHealthGroup* grp = P_GetHealthGroup(ll->healthgroup);
FHealthGroup* grp = P_GetHealthGroup(Level, ll->healthgroup);
if (grp) return grp->health;
}

22
src/p_ceiling.cpp
View file

@ -490,7 +490,7 @@ DEFINE_ACTION_FUNCTION(DCeiling, CreateCeiling)
//
//============================================================================
bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
bool EV_DoCeiling (FLevelLocals *Level, DCeiling::ECeiling type, line_t *line,
int tag, double speed, double speed2, double height,
int crush, int silent, int change, DCeiling::ECrushMode hexencrush)
{
@ -508,7 +508,7 @@ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
secnum = sec->sectornum;
// [RH] Hack to let manual crushers be retriggerable, too
tag ^= secnum | 0x1000000;
P_ActivateInStasisCeiling (tag);
P_ActivateInStasisCeiling (Level, tag);
return P_CreateCeiling(sec, type, line, tag, speed, speed2, height, crush, silent, change, hexencrush);
}
@ -516,14 +516,14 @@ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
// This restarts a crusher after it has been stopped
if (type == DCeiling::ceilCrushAndRaise)
{
P_ActivateInStasisCeiling (tag);
P_ActivateInStasisCeiling (Level, tag);
}
// affects all sectors with the same tag as the linedef
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
rtn |= P_CreateCeiling(&level.sectors[secnum], type, line, tag, speed, speed2, height, crush, silent, change, hexencrush);
rtn |= P_CreateCeiling(&Level->sectors[secnum], type, line, tag, speed, speed2, height, crush, silent, change, hexencrush);
}
return rtn;
}
@ -536,7 +536,7 @@ bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line,
//
//============================================================================
void P_ActivateInStasisCeiling (int tag)
void P_ActivateInStasisCeiling (FLevelLocals *Level, int tag)
{
DCeiling *scan;
TThinkerIterator<DCeiling> iterator;
@ -559,7 +559,7 @@ void P_ActivateInStasisCeiling (int tag)
//
//============================================================================
bool EV_CeilingCrushStop (int tag, bool remove)
bool EV_CeilingCrushStop (FLevelLocals *Level, int tag, bool remove)
{
bool rtn = false;
DCeiling *scan;
@ -589,17 +589,17 @@ bool EV_CeilingCrushStop (int tag, bool remove)
return rtn;
}
bool EV_StopCeiling(int tag, line_t *line)
bool EV_StopCeiling(FLevelLocals *Level, int tag, line_t *line)
{
int sec;
FSectorTagIterator it(tag, line);
while ((sec = it.Next()) >= 0)
{
if (level.sectors[sec].ceilingdata)
if (Level->sectors[sec].ceilingdata)
{
SN_StopSequence(&level.sectors[sec], CHAN_CEILING);
level.sectors[sec].ceilingdata->Destroy();
level.sectors[sec].ceilingdata = nullptr;
SN_StopSequence(&Level->sectors[sec], CHAN_CEILING);
Level->sectors[sec].ceilingdata->Destroy();
Level->sectors[sec].ceilingdata = nullptr;
}
}
return true;

68
src/p_destructible.cpp
View file

@ -75,9 +75,9 @@ void P_SetHealthGroupHealth(FHealthGroup* grp, int health)
}
}
void P_SetHealthGroupHealth(int id, int health)
void P_SetHealthGroupHealth(FLevelLocals *Level, int id, int health)
{
P_SetHealthGroupHealth(P_GetHealthGroup(id), health);
P_SetHealthGroupHealth(P_GetHealthGroup(Level, id), health);
}
void P_DamageHealthGroup(FHealthGroup* grp, void* object, AActor* source, int damage, FName damagetype, int side, int part, DVector3 position, bool isradius)
@ -133,6 +133,7 @@ void P_DamageLinedef(line_t* line, AActor* source, int damage, FName damagetype,
line->health -= damage;
if (line->health < 0) line->health = 0;
auto Level = line->GetLevel();
// callbacks here
// first off, call special if needed
@ -145,7 +146,7 @@ void P_DamageLinedef(line_t* line, AActor* source, int damage, FName damagetype,
if (dogroups && line->healthgroup)
{
FHealthGroup* grp = P_GetHealthGroup(line->healthgroup);
FHealthGroup* grp = P_GetHealthGroup(Level, line->healthgroup);
if (grp)
grp->health = line->health;
P_DamageHealthGroup(grp, line, source, damage, damagetype, side, -1, position, isradius);
@ -166,6 +167,7 @@ void P_DamageSector(sector_t* sector, AActor* source, int damage, FName damagety
if (!damage) return;
auto Level = sector->Level;
int* sectorhealth;
int group;
int dmg;
@ -209,7 +211,7 @@ void P_DamageSector(sector_t* sector, AActor* source, int damage, FName damagety
if (dogroups && group)
{
FHealthGroup* grp = P_GetHealthGroup(group);
FHealthGroup* grp = P_GetHealthGroup(Level, group);
if (grp)
grp->health = newhealth;
P_DamageHealthGroup(grp, sector, source, damage, damagetype, 0, part, position, isradius);
@ -225,35 +227,36 @@ void P_DamageSector(sector_t* sector, AActor* source, int damage, FName damagety
//
//===========================================================================
FHealthGroup* P_GetHealthGroup(int id)
FHealthGroup* P_GetHealthGroup(FLevelLocals *Level, int id)
{
FHealthGroup* grp = level.healthGroups.CheckKey(id);
FHealthGroup* grp = Level->healthGroups.CheckKey(id);
return grp;
}
FHealthGroup* P_GetHealthGroupOrNew(int id, int health)
FHealthGroup* P_GetHealthGroupOrNew(FLevelLocals *Level, int id, int health)
{
FHealthGroup* grp = level.healthGroups.CheckKey(id);
FHealthGroup* grp = Level->healthGroups.CheckKey(id);
if (!grp)
{
FHealthGroup newgrp;
newgrp.id = id;
newgrp.health = health;
grp = &(level.healthGroups.Insert(id, newgrp));
grp = &(Level->healthGroups.Insert(id, newgrp));
}
return grp;
}
void P_InitHealthGroups()
void P_InitHealthGroups(FLevelLocals *Level)
{
level.healthGroups.Clear();
Level->healthGroups.Clear();
TArray<int> groupsInError;
for (unsigned i = 0; i < level.lines.Size(); i++)
for (unsigned i = 0; i < Level->lines.Size(); i++)
{
line_t* lline = &level.lines[i];
line_t* lline = &Level->lines[i];
if (lline->healthgroup > 0)
{
FHealthGroup* grp = P_GetHealthGroupOrNew(lline->healthgroup, lline->health);
FHealthGroup* grp = P_GetHealthGroupOrNew(Level, lline->healthgroup, lline->health);
if (grp->health != lline->health)
{
Printf(TEXTCOLOR_RED "Warning: line %d in health group %d has different starting health (line health = %d, group health = %d)\n", i, lline->healthgroup, lline->health, grp->health);
@ -264,12 +267,12 @@ void P_InitHealthGroups()
grp->lines.Push(lline);
}
}
for (unsigned i = 0; i < level.sectors.Size(); i++)
for (unsigned i = 0; i < Level->sectors.Size(); i++)
{
sector_t* lsector = &level.sectors[i];
sector_t* lsector = &Level->sectors[i];
if (lsector->healthceilinggroup > 0)
{
FHealthGroup* grp = P_GetHealthGroupOrNew(lsector->healthceilinggroup, lsector->healthceiling);
FHealthGroup* grp = P_GetHealthGroupOrNew(Level, lsector->healthceilinggroup, lsector->healthceiling);
if (grp->health != lsector->healthceiling)
{
Printf(TEXTCOLOR_RED "Warning: sector ceiling %d in health group %d has different starting health (ceiling health = %d, group health = %d)\n", i, lsector->healthceilinggroup, lsector->healthceiling, grp->health);
@ -281,7 +284,7 @@ void P_InitHealthGroups()
}
if (lsector->healthfloorgroup > 0)
{
FHealthGroup* grp = P_GetHealthGroupOrNew(lsector->healthfloorgroup, lsector->healthfloor);
FHealthGroup* grp = P_GetHealthGroupOrNew(Level, lsector->healthfloorgroup, lsector->healthfloor);
if (grp->health != lsector->healthfloor)
{
Printf(TEXTCOLOR_RED "Warning: sector floor %d in health group %d has different starting health (floor health = %d, group health = %d)\n", i, lsector->healthfloorgroup, lsector->healthfloor, grp->health);
@ -295,7 +298,7 @@ void P_InitHealthGroups()
}
for (unsigned i = 0; i < groupsInError.Size(); i++)
{
FHealthGroup* grp = P_GetHealthGroup(groupsInError[i]);
FHealthGroup* grp = P_GetHealthGroup(Level, groupsInError[i]);
Printf(TEXTCOLOR_GOLD "Health group %d is using the highest found health value of %d", groupsInError[i], grp->health);
}
}
@ -520,7 +523,7 @@ void P_GeometryRadiusAttack(AActor* bombspot, AActor* bombsource, int bombdamage
// enumerate all lines around
FBoundingBox bombbox(bombspot->X(), bombspot->Y(), bombdistance);
FBlockLinesIterator it(bombbox);
FBlockLinesIterator it(bombspot->Level, bombbox);
line_t* ln;
int vc = validcount;
TArray<line_t*> lines;
@ -840,7 +843,7 @@ FSerializer &Serialize(FSerializer &arc, const char *key, FHealthGroup& g, FHeal
return arc;
}
void P_SerializeHealthGroups(FSerializer& arc)
void P_SerializeHealthGroups(FLevelLocals *Level, FSerializer& arc)
{
// todo : stuff
if (arc.BeginArray("healthgroups"))
@ -853,7 +856,7 @@ void P_SerializeHealthGroups(FSerializer& arc)
{
FHealthGroup grp;
arc(nullptr, grp);
FHealthGroup* existinggrp = P_GetHealthGroup(grp.id);
FHealthGroup* existinggrp = P_GetHealthGroup(Level, grp.id);
if (!existinggrp)
continue;
existinggrp->health = grp.health;
@ -861,7 +864,7 @@ void P_SerializeHealthGroups(FSerializer& arc)
}
else
{
TMap<int, FHealthGroup>::ConstIterator it(level.healthGroups);
TMap<int, FHealthGroup>::ConstIterator it(Level->healthGroups);
TMap<int, FHealthGroup>::ConstPair* pair;
while (it.NextPair(pair))
{
@ -883,11 +886,11 @@ DEFINE_FIELD_X(HealthGroup, FHealthGroup, health)
DEFINE_FIELD_X(HealthGroup, FHealthGroup, sectors)
DEFINE_FIELD_X(HealthGroup, FHealthGroup, lines)
DEFINE_ACTION_FUNCTION(FHealthGroup, Find)
DEFINE_ACTION_FUNCTION(FLevelLocals, FindHealthGroup)
{
PARAM_PROLOGUE;
PARAM_SELF_STRUCT_PROLOGUE(FLevelLocals);
PARAM_INT(id);
FHealthGroup* grp = P_GetHealthGroup(id);
FHealthGroup* grp = P_GetHealthGroup(self, id);
ACTION_RETURN_POINTER(grp);
}
@ -993,7 +996,7 @@ DEFINE_ACTION_FUNCTION(_Line, GetHealth)
PARAM_SELF_STRUCT_PROLOGUE(line_t);
if (self->healthgroup)
{
FHealthGroup* grp = P_GetHealthGroup(self->healthgroup);
FHealthGroup* grp = P_GetHealthGroup(self->GetLevel(), self->healthgroup);
if (grp) ACTION_RETURN_INT(grp->health);
}
@ -1011,7 +1014,7 @@ DEFINE_ACTION_FUNCTION(_Line, SetHealth)
self->health = newhealth;
if (self->healthgroup)
{
FHealthGroup* grp = P_GetHealthGroup(self->healthgroup);
FHealthGroup* grp = P_GetHealthGroup(self->GetLevel(), self->healthgroup);
if (grp) P_SetHealthGroupHealth(grp, newhealth);
}
@ -1024,14 +1027,15 @@ DEFINE_ACTION_FUNCTION(_Sector, GetHealth)
PARAM_INT(part);
FHealthGroup* grp;
auto Level = self->Level;
switch (part)
{
case SECPART_Floor:
ACTION_RETURN_INT((self->healthfloorgroup && (grp = P_GetHealthGroup(self->healthfloorgroup))) ? grp->health : self->healthfloor);
ACTION_RETURN_INT((self->healthfloorgroup && (grp = P_GetHealthGroup(Level, self->healthfloorgroup))) ? grp->health : self->healthfloor);
case SECPART_Ceiling:
ACTION_RETURN_INT((self->healthceilinggroup && (grp = P_GetHealthGroup(self->healthceilinggroup))) ? grp->health : self->healthceiling);
ACTION_RETURN_INT((self->healthceilinggroup && (grp = P_GetHealthGroup(Level, self->healthceilinggroup))) ? grp->health : self->healthceiling);
case SECPART_3D:
ACTION_RETURN_INT((self->health3dgroup && (grp = P_GetHealthGroup(self->health3dgroup))) ? grp->health : self->health3d);
ACTION_RETURN_INT((self->health3dgroup && (grp = P_GetHealthGroup(Level, self->health3dgroup))) ? grp->health : self->health3d);
default:
ACTION_RETURN_INT(0);
}
@ -1066,7 +1070,7 @@ DEFINE_ACTION_FUNCTION(_Sector, SetHealth)
return 0;
}
FHealthGroup* grp = group ? P_GetHealthGroup(group) : nullptr;
FHealthGroup* grp = group ? P_GetHealthGroup(self->Level, group) : nullptr;
*health = newhealth;
if (grp) P_SetHealthGroupHealth(grp, newhealth);
return 0;

11
src/p_destructible.h
View file

@ -21,13 +21,14 @@ enum
SECPART_3D = 2
};
void P_InitHealthGroups();
struct FLevelLocals;
void P_InitHealthGroups(FLevelLocals *Level);
void P_SetHealthGroupHealth(FHealthGroup* group, int health);
void P_SetHealthGroupHealth(int group, int health);
void P_SetHealthGroupHealth(FLevelLocals *Level, int group, int health);
FHealthGroup* P_GetHealthGroup(int id);
FHealthGroup* P_GetHealthGroupOrNew(int id, int startinghealth);
FHealthGroup* P_GetHealthGroup(FLevelLocals *Level, int id);
FHealthGroup* P_GetHealthGroupOrNew(FLevelLocals *Level, int id, int startinghealth);
void P_DamageSector(sector_t* sector, AActor* source, int damage, FName damagetype, int part, DVector3 position, bool isradius, bool dogroups);
void P_DamageLinedef(line_t* line, AActor* source, int damage, FName damagetype, int side, DVector3 position, bool isradius, bool dogroups);
@ -40,4 +41,4 @@ bool P_ProjectileHitPlane(AActor* projectile, int part);
bool P_CheckLinedefVulnerable(line_t* line, int side, int part = -1);
bool P_CheckSectorVulnerable(sector_t* sector, int part);
void P_SerializeHealthGroups(FSerializer& arc);
void P_SerializeHealthGroups(FLevelLocals *Level, FSerializer& arc);

12
src/p_doors.cpp
View file

@ -136,7 +136,7 @@ void DDoor::Tick ()
// killough 10/98: implement gradual lighting effects
if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fD())
{
EV_LightTurnOnPartway (m_LightTag,
EV_LightTurnOnPartway (Level, m_LightTag,
(m_Sector->ceilingplane.fD() + m_Sector->floorplane.fD()) / (m_TopDist + m_Sector->floorplane.fD()));
}
@ -182,7 +182,7 @@ void DDoor::Tick ()
// killough 10/98: implement gradual lighting effects
if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fD())
{
EV_LightTurnOnPartway (m_LightTag,
EV_LightTurnOnPartway (Level, m_LightTag,
(m_Sector->ceilingplane.fD() + m_Sector->floorplane.fD()) / (m_TopDist + m_Sector->floorplane.fD()));
}
@ -417,7 +417,7 @@ DDoor::DDoor (sector_t *sec, EVlDoor type, double speed, int delay, int lightTag
//
//============================================================================
bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing,
bool EV_DoDoor (FLevelLocals *Level, DDoor::EVlDoor type, line_t *line, AActor *thing,
int tag, double speed, int delay, int lock, int lightTag, bool boomgen, int topcountdown)
{
bool rtn = false;
@ -493,7 +493,7 @@ bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing,
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sec = &level.sectors[secnum];
sec = &Level->sectors[secnum];
// if the ceiling is already moving, don't start the door action
if (sec->PlaneMoving(sector_t::ceiling))
continue;
@ -748,7 +748,7 @@ DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay,
//
//============================================================================
bool EV_SlidingDoor (line_t *line, AActor *actor, int tag, int speed, int delay, DAnimatedDoor::EADType type)
bool EV_SlidingDoor (FLevelLocals *Level, line_t *line, AActor *actor, int tag, int speed, int delay, DAnimatedDoor::EADType type)
{
sector_t *sec;
int secnum;
@ -790,7 +790,7 @@ bool EV_SlidingDoor (line_t *line, AActor *actor, int tag, int speed, int delay,
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sec = &level.sectors[secnum];
sec = &Level->sectors[secnum];
if (sec->ceilingdata != NULL)
{
continue;

12
src/p_enemy.cpp
View file

@ -867,7 +867,7 @@ void P_NewChaseDir(AActor * actor)
!(actor->flags & MF_FLOAT) && !(i_compatflags & COMPATF_DROPOFF))
{
FBoundingBox box(actor->X(), actor->Y(), actor->radius);
FBlockLinesIterator it(box);
FBlockLinesIterator it(actor->Level, box);
line_t *line;
double deltax = 0;
@ -3140,13 +3140,13 @@ void A_BossDeath(AActor *self)
{
if (type == NAME_Fatso)
{
EV_DoFloor (DFloor::floorLowerToLowest, NULL, 666, 1., 0, -1, 0, false);
EV_DoFloor(Level, DFloor::floorLowerToLowest, NULL, 666, 1., 0, -1, 0, false);
return;
}
if (type == NAME_Arachnotron)
{
EV_DoFloor (DFloor::floorRaiseByTexture, NULL, 667, 1., 0, -1, 0, false);
EV_DoFloor(Level, DFloor::floorRaiseByTexture, NULL, 667, 1., 0, -1, 0, false);
return;
}
}
@ -3155,15 +3155,15 @@ void A_BossDeath(AActor *self)
switch (Level->flags & LEVEL_SPECACTIONSMASK)
{
case LEVEL_SPECLOWERFLOOR:
EV_DoFloor (DFloor::floorLowerToLowest, NULL, 666, 1., 0, -1, 0, false);
EV_DoFloor(Level, DFloor::floorLowerToLowest, NULL, 666, 1., 0, -1, 0, false);
return;
case LEVEL_SPECLOWERFLOORTOHIGHEST:
EV_DoFloor (DFloor::floorLowerToHighest, NULL, 666, 1., 0, -1, 0, false);
EV_DoFloor(Level, DFloor::floorLowerToHighest, NULL, 666, 1., 0, -1, 0, false);
return;
case LEVEL_SPECOPENDOOR:
EV_DoDoor (DDoor::doorOpen, NULL, NULL, 666, 8., 0, 0, 0);
EV_DoDoor(Level, DDoor::doorOpen, NULL, NULL, 666, 8., 0, 0, 0);
return;
}
}

50
src/p_floor.cpp
View file

@ -192,19 +192,19 @@ void DFloor::Tick ()
sector_t *sec = m_Sector;
sec->stairlock = -1; // thinker done, promote lock to -1
while (sec->prevsec != -1 && level.sectors[sec->prevsec].stairlock != -2)
sec = &level.sectors[sec->prevsec]; // search for a non-done thinker
while (sec->prevsec != -1 && Level->sectors[sec->prevsec].stairlock != -2)
sec = &Level->sectors[sec->prevsec]; // search for a non-done thinker
if (sec->prevsec == -1) // if all thinkers previous are done
{
sec = m_Sector; // search forward
while (sec->nextsec != -1 && level.sectors[sec->nextsec].stairlock != -2)
sec = &level.sectors[sec->nextsec];
while (sec->nextsec != -1 && Level->sectors[sec->nextsec].stairlock != -2)
sec = &Level->sectors[sec->nextsec];
if (sec->nextsec == -1) // if all thinkers ahead are done too
{
while (sec->prevsec != -1) // clear all locks
{
sec->stairlock = 0;
sec = &level.sectors[sec->prevsec];
sec = &Level->sectors[sec->prevsec];
}
sec->stairlock = 0;
}
@ -525,7 +525,7 @@ DEFINE_ACTION_FUNCTION(DFloor, CreateFloor)
//
//==========================================================================
bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag,
bool EV_DoFloor (FLevelLocals *Level, DFloor::EFloor floortype, line_t *line, int tag,
double speed, double height, int crush, int change, bool hexencrush, bool hereticlower)
{
int secnum;
@ -535,7 +535,7 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag,
FSectorTagIterator it(tag, line);
while ((secnum = it.Next()) >= 0)
{
rtn |= P_CreateFloor(&level.sectors[secnum], floortype, line, speed, height, crush, change, hexencrush, hereticlower);
rtn |= P_CreateFloor(&Level->sectors[secnum], floortype, line, speed, height, crush, change, hexencrush, hereticlower);
}
return rtn;
}
@ -548,13 +548,13 @@ bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag,
//
//==========================================================================
bool EV_FloorCrushStop (int tag, line_t *line)
bool EV_FloorCrushStop (FLevelLocals *Level, int tag, line_t *line)
{
int secnum;
FSectorTagIterator it(tag, line);
while ((secnum = it.Next()) >= 0)
{
sector_t *sec = &level.sectors[secnum];
sector_t *sec = &Level->sectors[secnum];
if (sec->floordata && sec->floordata->IsKindOf (RUNTIME_CLASS(DFloor)) &&
barrier_cast<DFloor *>(sec->floordata)->m_Type == DFloor::floorRaiseAndCrush)
@ -568,17 +568,17 @@ bool EV_FloorCrushStop (int tag, line_t *line)
}
// same as above but stops any floor mover that was active on the given sector.
bool EV_StopFloor(int tag, line_t *line)
bool EV_StopFloor(FLevelLocals *Level, int tag, line_t *line)
{
int sec;
FSectorTagIterator it(tag, line);
while ((sec = it.Next()) >= 0)
{
if (level.sectors[sec].floordata)
if (Level->sectors[sec].floordata)
{
SN_StopSequence(&level.sectors[sec], CHAN_FLOOR);
level.sectors[sec].floordata->Destroy();
level.sectors[sec].floordata = nullptr;
SN_StopSequence(&Level->sectors[sec], CHAN_FLOOR);
Level->sectors[sec].floordata->Destroy();
Level->sectors[sec].floordata = nullptr;
}
}
return true;
@ -593,7 +593,7 @@ bool EV_StopFloor(int tag, line_t *line)
//
//==========================================================================
bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line,
bool EV_BuildStairs (FLevelLocals *Level, int tag, DFloor::EStair type, line_t *line,
double stairsize, double speed, int delay, int reset, int igntxt,
int usespecials)
{
@ -625,7 +625,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line,
bool compatible = tag != 0 && (i_compatflags & COMPATF_STAIRINDEX);
while ((secnum = itr.NextCompat(compatible, secnum)) >= 0)
{
sec = &level.sectors[secnum];
sec = &Level->sectors[secnum];
// ALREADY MOVING? IF SO, KEEP GOING...
//jff 2/26/98 add special lockout condition to wait for entire
@ -770,7 +770,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line,
} while (ok);
// [RH] make sure the first sector doesn't point to a previous one, otherwise
// it can infinite loop when the first sector stops moving.
level.sectors[osecnum].prevsec = -1;
Level->sectors[osecnum].prevsec = -1;
}
return rtn;
}
@ -781,7 +781,7 @@ bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line,
//
//==========================================================================
bool EV_DoDonut (int tag, line_t *line, double pillarspeed, double slimespeed)
bool EV_DoDonut (FLevelLocals *Level, int tag, line_t *line, double pillarspeed, double slimespeed)
{
sector_t* s1;
sector_t* s2;
@ -797,7 +797,7 @@ bool EV_DoDonut (int tag, line_t *line, double pillarspeed, double slimespeed)
FSectorTagIterator itr(tag, line);
while ((secnum = itr.Next()) >= 0)
{
s1 = &level.sectors[secnum]; // s1 is pillar's sector
s1 = &Level->sectors[secnum]; // s1 is pillar's sector
// ALREADY MOVING? IF SO, KEEP GOING...
if (s1->PlaneMoving(sector_t::floor))
@ -994,7 +994,7 @@ void DElevator::StartFloorSound ()
//
//==========================================================================
bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype,
bool EV_DoElevator (FLevelLocals *Level, line_t *line, DElevator::EElevator elevtype,
double speed, double height, int tag)
{
int secnum;
@ -1016,7 +1016,7 @@ bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype,
// act on all sectors with the same tag as the triggering linedef
while ((secnum = itr.Next()) >= 0)
{
sec = &level.sectors[secnum];
sec = &Level->sectors[secnum];
// If either floor or ceiling is already activated, skip it
if (sec->PlaneMoving(sector_t::floor) || sec->ceilingdata) //jff 2/22/98
continue; // the loop used to break at the end if tag were 0, but would miss that step if "continue" occured [FDARI]
@ -1097,7 +1097,7 @@ bool EV_DoElevator (line_t *line, DElevator::EElevator elevtype,
//
//==========================================================================
bool EV_DoChange (line_t *line, EChange changetype, int tag)
bool EV_DoChange (FLevelLocals *Level, line_t *line, EChange changetype, int tag)
{
int secnum;
bool rtn;
@ -1109,7 +1109,7 @@ bool EV_DoChange (line_t *line, EChange changetype, int tag)
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sec = &level.sectors[secnum];
sec = &Level->sectors[secnum];
rtn = true;
@ -1310,7 +1310,7 @@ void DCeilingWaggle::Tick ()
//
//==========================================================================
bool EV_StartWaggle (int tag, line_t *line, int height, int speed, int offset,
bool EV_StartWaggle (FLevelLocals *Level, int tag, line_t *line, int height, int speed, int offset,
int timer, bool ceiling)
{
int sectorIndex;
@ -1324,7 +1324,7 @@ bool EV_StartWaggle (int tag, line_t *line, int height, int speed, int offset,
while ((sectorIndex = itr.Next()) >= 0)
{
sector = &level.sectors[sectorIndex];
sector = &Level->sectors[sectorIndex];
if ((!ceiling && sector->PlaneMoving(sector_t::floor)) ||
(ceiling && sector->PlaneMoving(sector_t::ceiling)))
{ // Already busy with another thinker

40
src/p_lights.cpp
View file

@ -323,13 +323,13 @@ DFlicker::DFlicker (sector_t *sector, int upper, int lower)
//
//-----------------------------------------------------------------------------
void EV_StartLightFlickering (int tag, int upper, int lower)
void EV_StartLightFlickering (FLevelLocals *Level, int tag, int upper, int lower)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
Create<DFlicker> (&level.sectors[secnum], upper, lower);
Create<DFlicker> (&Level->sectors[secnum], upper, lower);
}
}
@ -500,13 +500,13 @@ DStrobe::DStrobe (sector_t *sector, int utics, int ltics, bool inSync)
//
//-----------------------------------------------------------------------------
void EV_StartLightStrobing (int tag, int upper, int lower, int utics, int ltics)
void EV_StartLightStrobing (FLevelLocals *Level, int tag, int upper, int lower, int utics, int ltics)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *sec = &level.sectors[secnum];
sector_t *sec = &Level->sectors[secnum];
if (sec->lightingdata)
continue;
@ -514,13 +514,13 @@ void EV_StartLightStrobing (int tag, int upper, int lower, int utics, int ltics)
}
}
void EV_StartLightStrobing (int tag, int utics, int ltics)
void EV_StartLightStrobing (FLevelLocals *Level, int tag, int utics, int ltics)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *sec = &level.sectors[secnum];
sector_t *sec = &Level->sectors[secnum];
if (sec->lightingdata)
continue;
@ -536,13 +536,13 @@ void EV_StartLightStrobing (int tag, int utics, int ltics)
//
//-----------------------------------------------------------------------------
void EV_TurnTagLightsOff (int tag)
void EV_TurnTagLightsOff (FLevelLocals *Level, int tag)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *sector = &level.sectors[secnum];
sector_t *sector = &Level->sectors[secnum];
int min = sector->lightlevel;
for (auto ln : sector->Lines)
@ -565,13 +565,13 @@ void EV_TurnTagLightsOff (int tag)
//
//-----------------------------------------------------------------------------
void EV_LightTurnOn (int tag, int bright)
void EV_LightTurnOn (FLevelLocals *Level, int tag, int bright)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *sector = &level.sectors[secnum];
sector_t *sector = &Level->sectors[secnum];
int tbright = bright; //jff 5/17/98 search for maximum PER sector
// bright = -1 means to search ([RH] Not 0)
@ -615,7 +615,7 @@ void EV_LightTurnOn (int tag, int bright)
//
//-----------------------------------------------------------------------------
void EV_LightTurnOnPartway (int tag, double frac)
void EV_LightTurnOnPartway (FLevelLocals *Level, int tag, double frac)
{
frac = clamp(frac, 0., 1.);
@ -624,7 +624,7 @@ void EV_LightTurnOnPartway (int tag, double frac)
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *temp, *sector = &level.sectors[secnum];
sector_t *temp, *sector = &Level->sectors[secnum];
int bright = 0, min = sector->lightlevel;
for (auto ln : sector->Lines)
@ -650,17 +650,17 @@ void EV_LightTurnOnPartway (int tag, double frac)
//
// [RH] New function to adjust tagged sectors' light levels
// by a relative amount. Light levels are clipped to
// be within range for sector_t::lightlevel.
// be within range for sector_t::lightLevel->
//
//-----------------------------------------------------------------------------
void EV_LightChange (int tag, int value)
void EV_LightChange (FLevelLocals *Level, int tag, int value)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
level.sectors[secnum].SetLightLevel(level.sectors[secnum].lightlevel + value);
Level->sectors[secnum].SetLightLevel(Level->sectors[secnum].lightlevel + value);
}
}
@ -806,7 +806,7 @@ DGlow2::DGlow2 (sector_t *sector, int start, int end, int tics, bool oneshot)
//
//-----------------------------------------------------------------------------
void EV_StartLightGlowing (int tag, int upper, int lower, int tics)
void EV_StartLightGlowing (FLevelLocals *Level, int tag, int upper, int lower, int tics)
{
int secnum;
@ -826,7 +826,7 @@ void EV_StartLightGlowing (int tag, int upper, int lower, int tics)
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *sec = &level.sectors[secnum];
sector_t *sec = &Level->sectors[secnum];
if (sec->lightingdata)
continue;
@ -840,13 +840,13 @@ void EV_StartLightGlowing (int tag, int upper, int lower, int tics)
//
//-----------------------------------------------------------------------------
void EV_StartLightFading (int tag, int value, int tics)
void EV_StartLightFading (FLevelLocals *Level, int tag, int value, int tics)
{
int secnum;
FSectorTagIterator it(tag);
while ((secnum = it.Next()) >= 0)
{
sector_t *sec = &level.sectors[secnum];
sector_t *sec = &Level->sectors[secnum];
if (sec->lightingdata)
continue;
@ -982,7 +982,7 @@ DPhased::DPhased (sector_t *sector, int baselevel, int phase)
//
//============================================================================
void EV_StopLightEffect (int tag)
void EV_StopLightEffect (FLevelLocals *Level, int tag)
{
TThinkerIterator<DLighting> iterator;
DLighting *effect;

226
src/p_lnspec.cpp
View file

@ -237,19 +237,19 @@ FUNC(LS_Polyobj_Stop)
FUNC(LS_Door_Close)
// Door_Close (tag, speed, lighttag)
{
return EV_DoDoor (DDoor::doorClose, ln, it, arg0, SPEED(arg1), 0, 0, arg2);
return EV_DoDoor(Level, DDoor::doorClose, ln, it, arg0, SPEED(arg1), 0, 0, arg2);
}
FUNC(LS_Door_Open)
// Door_Open (tag, speed, lighttag)
{
return EV_DoDoor (DDoor::doorOpen, ln, it, arg0, SPEED(arg1), 0, 0, arg2);
return EV_DoDoor(Level, DDoor::doorOpen, ln, it, arg0, SPEED(arg1), 0, 0, arg2);
}
FUNC(LS_Door_Raise)
// Door_Raise (tag, speed, delay, lighttag)
{
return EV_DoDoor (DDoor::doorRaise, ln, it, arg0, SPEED(arg1), TICS(arg2), 0, arg3);
return EV_DoDoor(Level, DDoor::doorRaise, ln, it, arg0, SPEED(arg1), TICS(arg2), 0, arg3);
}
FUNC(LS_Door_LockedRaise)
@ -258,9 +258,9 @@ FUNC(LS_Door_LockedRaise)
#if 0
// In Hexen this originally created a thinker running for nearly 4 years.
// Let's not do this unless it becomes necessary because this can hang tagwait.
return EV_DoDoor (arg2 || (Level->flags2 & LEVEL2_HEXENHACK) ? DDoor::doorRaise : DDoor::doorOpen, ln, it,
return EV_DoDoor(Level, arg2 || (Level->flags2 & LEVEL2_HEXENHACK) ? DDoor::doorRaise : DDoor::doorOpen, ln, it,
#else
return EV_DoDoor (arg2 ? DDoor::doorRaise : DDoor::doorOpen, ln, it,
return EV_DoDoor(Level, arg2 ? DDoor::doorRaise : DDoor::doorOpen, ln, it,
#endif
arg0, SPEED(arg1), TICS(arg2), arg3, arg4);
}
@ -268,19 +268,19 @@ FUNC(LS_Door_LockedRaise)
FUNC(LS_Door_CloseWaitOpen)
// Door_CloseWaitOpen (tag, speed, delay, lighttag)
{
return EV_DoDoor (DDoor::doorCloseWaitOpen, ln, it, arg0, SPEED(arg1), OCTICS(arg2), 0, arg3);
return EV_DoDoor(Level, DDoor::doorCloseWaitOpen, ln, it, arg0, SPEED(arg1), OCTICS(arg2), 0, arg3);
}
FUNC(LS_Door_WaitRaise)
// Door_WaitRaise(tag, speed, delay, wait, lighttag)
{
return EV_DoDoor(DDoor::doorWaitRaise, ln, it, arg0, SPEED(arg1), TICS(arg2), 0, arg4, false, TICS(arg3));
return EV_DoDoor(Level, DDoor::doorWaitRaise, ln, it, arg0, SPEED(arg1), TICS(arg2), 0, arg4, false, TICS(arg3));
}
FUNC(LS_Door_WaitClose)
// Door_WaitRaise(tag, speed, wait, lighttag)
{
return EV_DoDoor(DDoor::doorWaitClose, ln, it, arg0, SPEED(arg1), 0, 0, arg3, false, TICS(arg2));
return EV_DoDoor(Level, DDoor::doorWaitClose, ln, it, arg0, SPEED(arg1), 0, 0, arg3, false, TICS(arg2));
}
FUNC(LS_Door_Animated)
@ -289,13 +289,13 @@ FUNC(LS_Door_Animated)
if (arg3 != 0 && !P_CheckKeys (it, arg3, arg0 != 0))
return false;
return EV_SlidingDoor (ln, it, arg0, arg1, arg2, DAnimatedDoor::adOpenClose);
return EV_SlidingDoor (Level, ln, it, arg0, arg1, arg2, DAnimatedDoor::adOpenClose);
}
FUNC(LS_Door_AnimatedClose)
// Door_AnimatedClose (tag, speed)
{
return EV_SlidingDoor(ln, it, arg0, arg1, -1, DAnimatedDoor::adClose);
return EV_SlidingDoor(Level, ln, it, arg0, arg1, -1, DAnimatedDoor::adClose);
}
FUNC(LS_Generic_Door)
@ -326,203 +326,203 @@ FUNC(LS_Generic_Door)
tag = arg0;
lightTag = 0;
}
return EV_DoDoor (type, ln, it, tag, SPEED(arg1), OCTICS(arg3), arg4, lightTag, boomgen);
return EV_DoDoor(Level, type, ln, it, tag, SPEED(arg1), OCTICS(arg3), arg4, lightTag, boomgen);
}
FUNC(LS_Floor_LowerByValue)
// Floor_LowerByValue (tag, speed, height, change)
{
return EV_DoFloor (DFloor::floorLowerByValue, ln, arg0, SPEED(arg1), arg2, -1, CHANGE(arg3), false);
return EV_DoFloor(Level, DFloor::floorLowerByValue, ln, arg0, SPEED(arg1), arg2, -1, CHANGE(arg3), false);
}
FUNC(LS_Floor_LowerToLowest)
// Floor_LowerToLowest (tag, speed, change)
{
return EV_DoFloor (DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
return EV_DoFloor(Level, DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
}
FUNC(LS_Floor_LowerToHighest)
// Floor_LowerToHighest (tag, speed, adjust, hereticlower)
{
return EV_DoFloor (DFloor::floorLowerToHighest, ln, arg0, SPEED(arg1), (arg2-128), -1, 0, false, arg3==1);
return EV_DoFloor(Level, DFloor::floorLowerToHighest, ln, arg0, SPEED(arg1), (arg2-128), -1, 0, false, arg3==1);
}
FUNC(LS_Floor_LowerToHighestEE)
// Floor_LowerToHighestEE (tag, speed, change)
{
return EV_DoFloor (DFloor::floorLowerToHighest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
return EV_DoFloor(Level, DFloor::floorLowerToHighest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
}
FUNC(LS_Floor_LowerToNearest)
// Floor_LowerToNearest (tag, speed, change)
{
return EV_DoFloor (DFloor::floorLowerToNearest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
return EV_DoFloor(Level, DFloor::floorLowerToNearest, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), false);
}
FUNC(LS_Floor_RaiseByValue)
// Floor_RaiseByValue (tag, speed, height, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseByValue, ln, arg0, SPEED(arg1), arg2, CRUSH(arg4), CHANGE(arg3), true);
return EV_DoFloor(Level, DFloor::floorRaiseByValue, ln, arg0, SPEED(arg1), arg2, CRUSH(arg4), CHANGE(arg3), true);
}
FUNC(LS_Floor_RaiseToHighest)
// Floor_RaiseToHighest (tag, speed, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseToHighest, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorRaiseToHighest, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}
FUNC(LS_Floor_RaiseToNearest)
// Floor_RaiseToNearest (tag, speed, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseToNearest, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorRaiseToNearest, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}
FUNC(LS_Floor_RaiseToLowest)
// Floor_RaiseToLowest (tag, change, crush)
{
// This is merely done for completeness as it's a rather pointless addition.
return EV_DoFloor (DFloor::floorRaiseToLowest, ln, arg0, 2., 0, CRUSH(arg3), CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorRaiseToLowest, ln, arg0, 2., 0, CRUSH(arg3), CHANGE(arg2), true);
}
FUNC(LS_Floor_RaiseAndCrush)
// Floor_RaiseAndCrush (tag, speed, crush, crushmode)
{
return EV_DoFloor (DFloor::floorRaiseAndCrush, ln, arg0, SPEED(arg1), 0, arg2, 0, CRUSHTYPE(arg3));
return EV_DoFloor(Level, DFloor::floorRaiseAndCrush, ln, arg0, SPEED(arg1), 0, arg2, 0, CRUSHTYPE(arg3));
}
FUNC(LS_Floor_RaiseAndCrushDoom)
// Floor_RaiseAndCrushDoom (tag, speed, crush, crushmode)
{
return EV_DoFloor (DFloor::floorRaiseAndCrushDoom, ln, arg0, SPEED(arg1), 0, arg2, 0, CRUSHTYPE(arg3));
return EV_DoFloor(Level, DFloor::floorRaiseAndCrushDoom, ln, arg0, SPEED(arg1), 0, arg2, 0, CRUSHTYPE(arg3));
}
FUNC(LS_Floor_RaiseByValueTimes8)
// FLoor_RaiseByValueTimes8 (tag, speed, height, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseByValue, ln, arg0, SPEED(arg1), arg2*8, CRUSH(arg4), CHANGE(arg3), true);
return EV_DoFloor(Level, DFloor::floorRaiseByValue, ln, arg0, SPEED(arg1), arg2*8, CRUSH(arg4), CHANGE(arg3), true);
}
FUNC(LS_Floor_LowerByValueTimes8)
// Floor_LowerByValueTimes8 (tag, speed, height, change)
{
return EV_DoFloor (DFloor::floorLowerByValue, ln, arg0, SPEED(arg1), arg2*8, -1, CHANGE(arg3), false);
return EV_DoFloor(Level, DFloor::floorLowerByValue, ln, arg0, SPEED(arg1), arg2*8, -1, CHANGE(arg3), false);
}
FUNC(LS_Floor_CrushStop)
// Floor_CrushStop (tag)
{
return EV_FloorCrushStop (arg0, ln);
return EV_FloorCrushStop (Level, arg0, ln);
}
FUNC(LS_Floor_LowerInstant)
// Floor_LowerInstant (tag, unused, height, change)
{
return EV_DoFloor (DFloor::floorLowerInstant, ln, arg0, 0., arg2*8, -1, CHANGE(arg3), false);
return EV_DoFloor(Level, DFloor::floorLowerInstant, ln, arg0, 0., arg2*8, -1, CHANGE(arg3), false);
}
FUNC(LS_Floor_RaiseInstant)
// Floor_RaiseInstant (tag, unused, height, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseInstant, ln, arg0, 0., arg2*8, CRUSH(arg4), CHANGE(arg3), true);
return EV_DoFloor(Level, DFloor::floorRaiseInstant, ln, arg0, 0., arg2*8, CRUSH(arg4), CHANGE(arg3), true);
}
FUNC(LS_Floor_ToCeilingInstant)
// Floor_ToCeilingInstant (tag, change, crush, gap)
{
return EV_DoFloor (DFloor::floorLowerToCeiling, ln, arg0, 0, arg3, CRUSH(arg2), CHANGE(arg1), true);
return EV_DoFloor(Level, DFloor::floorLowerToCeiling, ln, arg0, 0, arg3, CRUSH(arg2), CHANGE(arg1), true);
}
FUNC(LS_Floor_MoveToValueTimes8)
// Floor_MoveToValueTimes8 (tag, speed, height, negative, change)
{
return EV_DoFloor (DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
return EV_DoFloor(Level, DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
arg2*8*(arg3?-1:1), -1, CHANGE(arg4), false);
}
FUNC(LS_Floor_MoveToValue)
// Floor_MoveToValue (tag, speed, height, negative, change)
{
return EV_DoFloor (DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
return EV_DoFloor(Level, DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
arg2*(arg3?-1:1), -1, CHANGE(arg4), false);
}
FUNC(LS_Floor_MoveToValueAndCrush)
// Floor_MoveToValueAndCrush (tag, speed, height, crush, crushmode)
{
return EV_DoFloor(DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
return EV_DoFloor(Level, DFloor::floorMoveToValue, ln, arg0, SPEED(arg1),
arg2, CRUSH(arg3) -1, 0, CRUSHTYPE(arg4), false);
}
FUNC(LS_Floor_RaiseToLowestCeiling)
// Floor_RaiseToLowestCeiling (tag, speed, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseToLowestCeiling, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorRaiseToLowestCeiling, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}
FUNC(LS_Floor_LowerToLowestCeiling)
// Floor_LowerToLowestCeiling (tag, speed, change)
{
return EV_DoFloor (DFloor::floorLowerToLowestCeiling, ln, arg0, SPEED(arg1), arg4, -1, CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorLowerToLowestCeiling, ln, arg0, SPEED(arg1), arg4, -1, CHANGE(arg2), true);
}
FUNC(LS_Floor_RaiseByTexture)
// Floor_RaiseByTexture (tag, speed, change, crush)
{
return EV_DoFloor (DFloor::floorRaiseByTexture, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorRaiseByTexture, ln, arg0, SPEED(arg1), 0, CRUSH(arg3), CHANGE(arg2), true);
}
FUNC(LS_Floor_LowerByTexture)
// Floor_LowerByTexture (tag, speed, change, crush)
{
return EV_DoFloor (DFloor::floorLowerByTexture, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorLowerByTexture, ln, arg0, SPEED(arg1), 0, -1, CHANGE(arg2), true);
}
FUNC(LS_Floor_RaiseToCeiling)
// Floor_RaiseToCeiling (tag, speed, change, crush, gap)
{
return EV_DoFloor (DFloor::floorRaiseToCeiling, ln, arg0, SPEED(arg1), arg4, CRUSH(arg3), CHANGE(arg2), true);
return EV_DoFloor(Level, DFloor::floorRaiseToCeiling, ln, arg0, SPEED(arg1), arg4, CRUSH(arg3), CHANGE(arg2), true);
}
FUNC(LS_Floor_RaiseByValueTxTy)
// Floor_RaiseByValueTxTy (tag, speed, height)
{
return EV_DoFloor (DFloor::floorRaiseAndChange, ln, arg0, SPEED(arg1), arg2, -1, 0, false);
return EV_DoFloor(Level, DFloor::floorRaiseAndChange, ln, arg0, SPEED(arg1), arg2, -1, 0, false);
}
FUNC(LS_Floor_LowerToLowestTxTy)
// Floor_LowerToLowestTxTy (tag, speed)
{
return EV_DoFloor (DFloor::floorLowerAndChange, ln, arg0, SPEED(arg1), arg2, -1, 0, false);
return EV_DoFloor(Level, DFloor::floorLowerAndChange, ln, arg0, SPEED(arg1), arg2, -1, 0, false);
}
FUNC(LS_Floor_Waggle)
// Floor_Waggle (tag, amplitude, frequency, delay, time)
{
return EV_StartWaggle (arg0, ln, arg1, arg2, arg3, arg4, false);
return EV_StartWaggle (Level, arg0, ln, arg1, arg2, arg3, arg4, false);
}
FUNC(LS_Ceiling_Waggle)
// Ceiling_Waggle (tag, amplitude, frequency, delay, time)
{
return EV_StartWaggle (arg0, ln, arg1, arg2, arg3, arg4, true);
return EV_StartWaggle (Level, arg0, ln, arg1, arg2, arg3, arg4, true);
}
FUNC(LS_Floor_TransferTrigger)
// Floor_TransferTrigger (tag)
{
return EV_DoChange (ln, trigChangeOnly, arg0);
return EV_DoChange (Level, ln, trigChangeOnly, arg0);
}
FUNC(LS_Floor_TransferNumeric)
// Floor_TransferNumeric (tag)
{
return EV_DoChange (ln, numChangeOnly, arg0);
return EV_DoChange (Level, ln, numChangeOnly, arg0);
}
FUNC(LS_Floor_Donut)
// Floor_Donut (pillartag, pillarspeed, slimespeed)
{
return EV_DoDonut (arg0, ln, SPEED(arg1), SPEED(arg2));
return EV_DoDonut (Level, arg0, ln, SPEED(arg1), SPEED(arg2));
}
FUNC(LS_Generic_Floor)
@ -557,7 +557,7 @@ FUNC(LS_Generic_Floor)
}
}
return EV_DoFloor (type, ln, arg0, SPEED(arg1), arg2,
return EV_DoFloor(Level, type, ln, arg0, SPEED(arg1), arg2,
(arg4 & 16) ? 20 : -1, arg4 & 7, false);
}
@ -565,70 +565,70 @@ FUNC(LS_Generic_Floor)
FUNC(LS_Floor_Stop)
// Floor_Stop (tag)
{
return EV_StopFloor(arg0, ln);
return EV_StopFloor(Level, arg0, ln);
}
FUNC(LS_Stairs_BuildDown)
// Stair_BuildDown (tag, speed, height, delay, reset)
{
return EV_BuildStairs (arg0, DFloor::buildDown, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildDown, ln,
arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials);
}
FUNC(LS_Stairs_BuildUp)
// Stairs_BuildUp (tag, speed, height, delay, reset)
{
return EV_BuildStairs (arg0, DFloor::buildUp, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildUp, ln,
arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairUseSpecials);
}
FUNC(LS_Stairs_BuildDownSync)
// Stairs_BuildDownSync (tag, speed, height, reset)
{
return EV_BuildStairs (arg0, DFloor::buildDown, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildDown, ln,
arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync);
}
FUNC(LS_Stairs_BuildUpSync)
// Stairs_BuildUpSync (tag, speed, height, reset)
{
return EV_BuildStairs (arg0, DFloor::buildUp, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildUp, ln,
arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairUseSpecials|DFloor::stairSync);
}
FUNC(LS_Stairs_BuildUpDoom)
// Stairs_BuildUpDoom (tag, speed, height, delay, reset)
{
return EV_BuildStairs (arg0, DFloor::buildUp, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildUp, ln,
arg2, SPEED(arg1), TICS(arg3), arg4, 0, 0);
}
FUNC(LS_Stairs_BuildUpDoomCrush)
// Stairs_BuildUpDoom (tag, speed, height, delay, reset)
{
return EV_BuildStairs(arg0, DFloor::buildUp, ln,
return EV_BuildStairs(Level, arg0, DFloor::buildUp, ln,
arg2, SPEED(arg1), TICS(arg3), arg4, 0, DFloor::stairCrush);
}
FUNC(LS_Stairs_BuildDownDoom)
// Stair_BuildDownDoom (tag, speed, height, delay, reset)
{
return EV_BuildStairs (arg0, DFloor::buildDown, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildDown, ln,
arg2, SPEED(arg1), TICS(arg3), arg4, 0, 0);
}
FUNC(LS_Stairs_BuildDownDoomSync)
// Stairs_BuildDownDoomSync (tag, speed, height, reset)
{
return EV_BuildStairs (arg0, DFloor::buildDown, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildDown, ln,
arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairSync);
}
FUNC(LS_Stairs_BuildUpDoomSync)
// Stairs_BuildUpDoomSync (tag, speed, height, reset)
{
return EV_BuildStairs (arg0, DFloor::buildUp, ln,
return EV_BuildStairs (Level, arg0, DFloor::buildUp, ln,
arg2, SPEED(arg1), 0, arg3, 0, DFloor::stairSync);
}
@ -637,7 +637,7 @@ FUNC(LS_Generic_Stairs)
// Generic_Stairs (tag, speed, step, dir/igntxt, reset)
{
DFloor::EStair type = (arg3 & 1) ? DFloor::buildUp : DFloor::buildDown;
bool res = EV_BuildStairs (arg0, type, ln,
bool res = EV_BuildStairs (Level, arg0, type, ln,
arg2, SPEED(arg1), 0, arg4, arg3 & 2, 0);
if (res && ln && (ln->flags & ML_REPEAT_SPECIAL) && ln->special == Generic_Stairs)
@ -668,43 +668,43 @@ FUNC(LS_Pillar_Open)
FUNC(LS_Ceiling_LowerByValue)
// Ceiling_LowerByValue (tag, speed, height, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3));
return EV_DoCeiling(Level, DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3));
}
FUNC(LS_Ceiling_RaiseByValue)
// Ceiling_RaiseByValue (tag, speed, height, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3));
return EV_DoCeiling(Level, DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2, CRUSH(arg4), 0, CHANGE(arg3));
}
FUNC(LS_Ceiling_LowerByValueTimes8)
// Ceiling_LowerByValueTimes8 (tag, speed, height, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3));
return EV_DoCeiling(Level, DCeiling::ceilLowerByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3));
}
FUNC(LS_Ceiling_RaiseByValueTimes8)
// Ceiling_RaiseByValueTimes8 (tag, speed, height, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3));
return EV_DoCeiling(Level, DCeiling::ceilRaiseByValue, ln, arg0, SPEED(arg1), 0, arg2*8, -1, 0, CHANGE(arg3));
}
FUNC(LS_Ceiling_CrushAndRaise)
// Ceiling_CrushAndRaise (tag, speed, crush, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false));
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false));
}
FUNC(LS_Ceiling_LowerAndCrush)
// Ceiling_LowerAndCrush (tag, speed, crush, crushtype)
{
return EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), 8, arg2, 0, 0, CRUSHTYPE(arg3, arg1 == 8));
return EV_DoCeiling(Level, DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), 8, arg2, 0, 0, CRUSHTYPE(arg3, arg1 == 8));
}
FUNC(LS_Ceiling_LowerAndCrushDist)
// Ceiling_LowerAndCrush (tag, speed, crush, dist, crushtype)
{
return EV_DoCeiling (DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), arg3, arg2, 0, 0, CRUSHTYPE(arg4, arg1 == 8));
return EV_DoCeiling(Level, DCeiling::ceilLowerAndCrush, ln, arg0, SPEED(arg1), SPEED(arg1), arg3, arg2, 0, 0, CRUSHTYPE(arg4, arg1 == 8));
}
FUNC(LS_Ceiling_CrushStop)
@ -723,160 +723,160 @@ FUNC(LS_Ceiling_CrushStop)
remove = gameinfo.gametype == GAME_Hexen;
break;
}
return EV_CeilingCrushStop (arg0, remove);
return EV_CeilingCrushStop (Level, arg0, remove);
}
FUNC(LS_Ceiling_CrushRaiseAndStay)
// Ceiling_CrushRaiseAndStay (tag, speed, crush, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false));
return EV_DoCeiling(Level, DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg1)/2, 8, arg2, 0, 0, CRUSHTYPE(arg3, false));
}
FUNC(LS_Ceiling_MoveToValueTimes8)
// Ceiling_MoveToValueTimes8 (tag, speed, height, negative, change)
{
return EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
return EV_DoCeiling(Level, DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
arg2*8*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4));
}
FUNC(LS_Ceiling_MoveToValue)
// Ceiling_MoveToValue (tag, speed, height, negative, change)
{
return EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
return EV_DoCeiling(Level, DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
arg2*((arg3) ? -1 : 1), -1, 0, CHANGE(arg4));
}
FUNC(LS_Ceiling_MoveToValueAndCrush)
// Ceiling_MoveToValueAndCrush (tag, speed, height, crush, crushmode)
{
return EV_DoCeiling (DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
return EV_DoCeiling(Level, DCeiling::ceilMoveToValue, ln, arg0, SPEED(arg1), 0,
arg2, CRUSH(arg3), 0, 0, CRUSHTYPE(arg4, arg1 == 8));
}
FUNC(LS_Ceiling_LowerToHighestFloor)
// Ceiling_LowerToHighestFloor (tag, speed, change, crush, gap)
{
return EV_DoCeiling (DCeiling::ceilLowerToHighestFloor, ln, arg0, SPEED(arg1), 0, arg4, CRUSH(arg3), 0, CHANGE(arg2));
return EV_DoCeiling(Level, DCeiling::ceilLowerToHighestFloor, ln, arg0, SPEED(arg1), 0, arg4, CRUSH(arg3), 0, CHANGE(arg2));
}
FUNC(LS_Ceiling_LowerInstant)
// Ceiling_LowerInstant (tag, unused, height, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerInstant, ln, arg0, 0, 0, arg2*8, CRUSH(arg4), 0, CHANGE(arg3));
return EV_DoCeiling(Level, DCeiling::ceilLowerInstant, ln, arg0, 0, 0, arg2*8, CRUSH(arg4), 0, CHANGE(arg3));
}
FUNC(LS_Ceiling_RaiseInstant)
// Ceiling_RaiseInstant (tag, unused, height, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseInstant, ln, arg0, 0, 0, arg2*8, -1, 0, CHANGE(arg3));
return EV_DoCeiling(Level, DCeiling::ceilRaiseInstant, ln, arg0, 0, 0, arg2*8, -1, 0, CHANGE(arg3));
}
FUNC(LS_Ceiling_CrushRaiseAndStayA)
// Ceiling_CrushRaiseAndStayA (tag, dnspeed, upspeed, damage, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 0, 0, CRUSHTYPE(arg4, false));
return EV_DoCeiling(Level, DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 0, 0, CRUSHTYPE(arg4, false));
}
FUNC(LS_Ceiling_CrushRaiseAndStaySilA)
// Ceiling_CrushRaiseAndStaySilA (tag, dnspeed, upspeed, damage, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 1, 0, CRUSHTYPE(arg4, false));
return EV_DoCeiling(Level, DCeiling::ceilCrushRaiseAndStay, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 1, 0, CRUSHTYPE(arg4, false));
}
FUNC(LS_Ceiling_CrushAndRaiseA)
// Ceiling_CrushAndRaiseA (tag, dnspeed, upspeed, damage, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 0, 0, CRUSHTYPE(arg4, arg1 == 8 && arg2 == 8));
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 0, 0, CRUSHTYPE(arg4, arg1 == 8 && arg2 == 8));
}
FUNC(LS_Ceiling_CrushAndRaiseDist)
// Ceiling_CrushAndRaiseDist (tag, dist, speed, damage, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 0, 0, CRUSHTYPE(arg4, arg2 == 8));
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 0, 0, CRUSHTYPE(arg4, arg2 == 8));
}
FUNC(LS_Ceiling_CrushAndRaiseSilentA)
// Ceiling_CrushAndRaiseSilentA (tag, dnspeed, upspeed, damage, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 1, 0, CRUSHTYPE(arg4, arg1 == 8 && arg2 == 8));
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1), SPEED(arg2), 0, arg3, 1, 0, CRUSHTYPE(arg4, arg1 == 8 && arg2 == 8));
}
FUNC(LS_Ceiling_CrushAndRaiseSilentDist)
// Ceiling_CrushAndRaiseSilentDist (tag, dist, upspeed, damage, crushtype)
{
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 1, 0, CRUSHTYPE(arg4, arg2 == 8));
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg2), SPEED(arg2), arg1, arg3, 1, 0, CRUSHTYPE(arg4, arg2 == 8));
}
FUNC(LS_Ceiling_RaiseToNearest)
// Ceiling_RaiseToNearest (tag, speed, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseToNearest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
return EV_DoCeiling(Level, DCeiling::ceilRaiseToNearest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}
FUNC(LS_Ceiling_RaiseToHighest)
// Ceiling_RaiseToHighest (tag, speed, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseToHighest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
return EV_DoCeiling(Level, DCeiling::ceilRaiseToHighest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}
FUNC(LS_Ceiling_RaiseToLowest)
// Ceiling_RaiseToLowest (tag, speed, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseToLowest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
return EV_DoCeiling(Level, DCeiling::ceilRaiseToLowest, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}
FUNC(LS_Ceiling_RaiseToHighestFloor)
// Ceiling_RaiseToHighestFloor (tag, speed, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseToHighestFloor, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
return EV_DoCeiling(Level, DCeiling::ceilRaiseToHighestFloor, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}
FUNC(LS_Ceiling_RaiseByTexture)
// Ceiling_RaiseByTexture (tag, speed, change)
{
return EV_DoCeiling (DCeiling::ceilRaiseByTexture, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
return EV_DoCeiling(Level, DCeiling::ceilRaiseByTexture, ln, arg0, SPEED(arg1), 0, 0, -1, CHANGE(arg2), 0);
}
FUNC(LS_Ceiling_LowerToLowest)
// Ceiling_LowerToLowest (tag, speed, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerToLowest, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
return EV_DoCeiling(Level, DCeiling::ceilLowerToLowest, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
}
FUNC(LS_Ceiling_LowerToNearest)
// Ceiling_LowerToNearest (tag, speed, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerToNearest, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
return EV_DoCeiling(Level, DCeiling::ceilLowerToNearest, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
}
FUNC(LS_Ceiling_ToHighestInstant)
// Ceiling_ToHighestInstant (tag, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerToHighest, ln, arg0, 2, 0, 0, CRUSH(arg2), 0, CHANGE(arg1));
return EV_DoCeiling(Level, DCeiling::ceilLowerToHighest, ln, arg0, 2, 0, 0, CRUSH(arg2), 0, CHANGE(arg1));
}
FUNC(LS_Ceiling_ToFloorInstant)
// Ceiling_ToFloorInstant (tag, change, crush, gap)
{
return EV_DoCeiling (DCeiling::ceilRaiseToFloor, ln, arg0, 2, 0, arg3, CRUSH(arg2), 0, CHANGE(arg1));
return EV_DoCeiling(Level, DCeiling::ceilRaiseToFloor, ln, arg0, 2, 0, arg3, CRUSH(arg2), 0, CHANGE(arg1));
}
FUNC(LS_Ceiling_LowerToFloor)
// Ceiling_LowerToFloor (tag, speed, change, crush, gap)
{
return EV_DoCeiling (DCeiling::ceilLowerToFloor, ln, arg0, SPEED(arg1), 0, arg4, CRUSH(arg3), 0, CHANGE(arg2));
return EV_DoCeiling(Level, DCeiling::ceilLowerToFloor, ln, arg0, SPEED(arg1), 0, arg4, CRUSH(arg3), 0, CHANGE(arg2));
}
FUNC(LS_Ceiling_LowerByTexture)
// Ceiling_LowerByTexture (tag, speed, change, crush)
{
return EV_DoCeiling (DCeiling::ceilLowerByTexture, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
return EV_DoCeiling(Level, DCeiling::ceilLowerByTexture, ln, arg0, SPEED(arg1), 0, 0, CRUSH(arg3), 0, CHANGE(arg2));
}
FUNC(LS_Ceiling_Stop)
// Ceiling_Stop (tag)
{
return EV_StopCeiling(arg0, ln);
return EV_StopCeiling(Level, arg0, ln);
}
@ -907,14 +907,14 @@ FUNC(LS_Generic_Ceiling)
}
}
return EV_DoCeiling (type, ln, arg0, SPEED(arg1), SPEED(arg1), arg2,
return EV_DoCeiling(Level, type, ln, arg0, SPEED(arg1), SPEED(arg1), arg2,
(arg4 & 16) ? 20 : -1, 0, arg4 & 7);
}
FUNC(LS_Generic_Crusher)
// Generic_Crusher (tag, dnspeed, upspeed, silent, damage)
{
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
SPEED(arg2), 0, arg4, arg3 ? 2 : 0, 0, (arg1 <= 24 && arg2 <= 24)? DCeiling::ECrushMode::crushSlowdown : DCeiling::ECrushMode::crushDoom);
}
@ -922,7 +922,7 @@ FUNC(LS_Generic_Crusher2)
// Generic_Crusher2 (tag, dnspeed, upspeed, silent, damage)
{
// same as above but uses Hexen's crushing method.
return EV_DoCeiling (DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
return EV_DoCeiling(Level, DCeiling::ceilCrushAndRaise, ln, arg0, SPEED(arg1),
SPEED(arg2), 0, arg4, arg3 ? 2 : 0, 0, DCeiling::ECrushMode::crushHexen);
}
@ -2024,26 +2024,26 @@ FUNC(LS_FS_Execute)
FUNC(LS_FloorAndCeiling_LowerByValue)
// FloorAndCeiling_LowerByValue (tag, speed, height)
{
return EV_DoElevator (ln, DElevator::elevateLower, SPEED(arg1), arg2, arg0);
return EV_DoElevator (Level, ln, DElevator::elevateLower, SPEED(arg1), arg2, arg0);
}
FUNC(LS_FloorAndCeiling_RaiseByValue)
// FloorAndCeiling_RaiseByValue (tag, speed, height)
{
return EV_DoElevator (ln, DElevator::elevateRaise, SPEED(arg1), arg2, arg0);
return EV_DoElevator (Level, ln, DElevator::elevateRaise, SPEED(arg1), arg2, arg0);
}
FUNC(LS_FloorAndCeiling_LowerRaise)
// FloorAndCeiling_LowerRaise (tag, fspeed, cspeed, boomemu)
{
bool res = EV_DoCeiling (DCeiling::ceilRaiseToHighest, ln, arg0, SPEED(arg2), 0, 0, 0, 0, 0);
bool res = EV_DoCeiling(Level, DCeiling::ceilRaiseToHighest, ln, arg0, SPEED(arg2), 0, 0, 0, 0, 0);
// The switch based Boom equivalents of FloorandCeiling_LowerRaise do incorrect checks
// which cause the floor only to move when the ceiling fails to do so.
// To avoid problems with maps that have incorrect args this only uses a
// more or less unintuitive value for the fourth arg to trigger Boom's broken behavior
if (arg3 != 1998 || !res) // (1998 for the year in which Boom was released... :P)
{
res |= EV_DoFloor (DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, 0, false);
res |= EV_DoFloor(Level, DFloor::floorLowerToLowest, ln, arg0, SPEED(arg1), 0, -1, 0, false);
}
return res;
}
@ -2051,19 +2051,19 @@ FUNC(LS_FloorAndCeiling_LowerRaise)
FUNC(LS_Elevator_MoveToFloor)
// Elevator_MoveToFloor (tag, speed)
{
return EV_DoElevator (ln, DElevator::elevateCurrent, SPEED(arg1), 0, arg0);
return EV_DoElevator (Level, ln, DElevator::elevateCurrent, SPEED(arg1), 0, arg0);
}
FUNC(LS_Elevator_RaiseToNearest)
// Elevator_RaiseToNearest (tag, speed)
{
return EV_DoElevator (ln, DElevator::elevateUp, SPEED(arg1), 0, arg0);
return EV_DoElevator (Level, ln, DElevator::elevateUp, SPEED(arg1), 0, arg0);
}
FUNC(LS_Elevator_LowerToNearest)
// Elevator_LowerToNearest (tag, speed)
{
return EV_DoElevator (ln, DElevator::elevateDown, SPEED(arg1), 0, arg0);
return EV_DoElevator (Level, ln, DElevator::elevateDown, SPEED(arg1), 0, arg0);
}
FUNC(LS_Light_ForceLightning)
@ -2076,77 +2076,77 @@ FUNC(LS_Light_ForceLightning)
FUNC(LS_Light_RaiseByValue)
// Light_RaiseByValue (tag, value)
{
EV_LightChange (arg0, arg1);
EV_LightChange (Level, arg0, arg1);
return true;
}
FUNC(LS_Light_LowerByValue)
// Light_LowerByValue (tag, value)
{
EV_LightChange (arg0, -arg1);
EV_LightChange (Level, arg0, -arg1);
return true;
}
FUNC(LS_Light_ChangeToValue)
// Light_ChangeToValue (tag, value)
{
EV_LightTurnOn (arg0, arg1);
EV_LightTurnOn (Level, arg0, arg1);
return true;
}
FUNC(LS_Light_Fade)
// Light_Fade (tag, value, tics);
{
EV_StartLightFading (arg0, arg1, TICS(arg2));
EV_StartLightFading (Level, arg0, arg1, TICS(arg2));
return true;
}
FUNC(LS_Light_Glow)
// Light_Glow (tag, upper, lower, tics)
{
EV_StartLightGlowing (arg0, arg1, arg2, TICS(arg3));
EV_StartLightGlowing (Level, arg0, arg1, arg2, TICS(arg3));
return true;
}
FUNC(LS_Light_Flicker)
// Light_Flicker (tag, upper, lower)
{
EV_StartLightFlickering (arg0, arg1, arg2);
EV_StartLightFlickering (Level, arg0, arg1, arg2);
return true;
}
FUNC(LS_Light_Strobe)
// Light_Strobe (tag, upper, lower, u-tics, l-tics)
{
EV_StartLightStrobing (arg0, arg1, arg2, TICS(arg3), TICS(arg4));
EV_StartLightStrobing (Level, arg0, arg1, arg2, TICS(arg3), TICS(arg4));
return true;
}
FUNC(LS_Light_StrobeDoom)
// Light_StrobeDoom (tag, u-tics, l-tics)
{
EV_StartLightStrobing (arg0, TICS(arg1), TICS(arg2));
EV_StartLightStrobing (Level, arg0, TICS(arg1), TICS(arg2));
return true;
}
FUNC(LS_Light_MinNeighbor)
// Light_MinNeighbor (tag)
{
EV_TurnTagLightsOff (arg0);
EV_TurnTagLightsOff (Level, arg0);
return true;
}
FUNC(LS_Light_MaxNeighbor)
// Light_MaxNeighbor (tag)
{
EV_LightTurnOn (arg0, -1);
EV_LightTurnOn (Level, arg0, -1);
return true;
}
FUNC(LS_Light_Stop)
// Light_Stop (tag)
{
EV_StopLightEffect (arg0);
EV_StopLightEffect (Level, arg0);
return true;
}
@ -3492,7 +3492,7 @@ FUNC(LS_Line_SetHealth)
line_t* line = &Level->lines[l];
line->health = arg1;
if (line->healthgroup)
P_SetHealthGroupHealth(line->healthgroup, arg1);
P_SetHealthGroupHealth(Level, line->healthgroup, arg1);
}
return true;
}
@ -3513,19 +3513,19 @@ FUNC(LS_Sector_SetHealth)
{
sector->healthceiling = arg2;
if (sector->healthceilinggroup)
P_SetHealthGroupHealth(sector->healthceilinggroup, arg2);
P_SetHealthGroupHealth(Level, sector->healthceilinggroup, arg2);
}
else if (arg1 == SECPART_Floor)
{
sector->healthfloor = arg2;
if (sector->healthfloorgroup)
P_SetHealthGroupHealth(sector->healthfloorgroup, arg2);
P_SetHealthGroupHealth(Level, sector->healthfloorgroup, arg2);
}
else if (arg1 == SECPART_3D)
{
sector->health3d = arg2;
if (sector->health3dgroup)
P_SetHealthGroupHealth(sector->health3dgroup, arg2);
P_SetHealthGroupHealth(Level, sector->health3dgroup, arg2);
}
}
return true;

14
src/p_map.cpp
View file

@ -1082,7 +1082,7 @@ static bool PIT_CheckPortal(FMultiBlockLinesIterator &mit, FMultiBlockLinesItera
tm.thing->AddZ(zofs);
FBoundingBox pbox(cres.Position.X, cres.Position.Y, tm.thing->radius);
FBlockLinesIterator it(pbox);
FBlockLinesIterator it(tm.thing->Level, pbox);
bool ret = false;
line_t *ld;
@ -2930,7 +2930,7 @@ void FSlide::HitSlideLine(line_t* ld)
void FSlide::SlideTraverse(const DVector2 &start, const DVector2 &end)
{
FLineOpening open;
FPathTraverse it(start.X, start.Y, end.X, end.Y, PT_ADDLINES);
FPathTraverse it(slidemo->Level, start.X, start.Y, end.X, end.Y, PT_ADDLINES);
intercept_t *in;
while ((in = it.Next()))
@ -3287,7 +3287,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, DVector2 &move)
bool FSlide::BounceTraverse(const DVector2 &start, const DVector2 &end)
{
FLineOpening open;
FPathTraverse it(start.X, start.Y, end.X, end.Y, PT_ADDLINES);
FPathTraverse it(slidemo->Level, start.X, start.Y, end.X, end.Y, PT_ADDLINES);
intercept_t *in;
while ((in = it.Next()))
@ -3979,7 +3979,7 @@ struct aim_t
if (ceilingportalstate) EnterSectorPortal(sector_t::ceiling, 0, lastsector, toppitch, MIN<DAngle>(0., bottompitch));
if (floorportalstate) EnterSectorPortal(sector_t::floor, 0, lastsector, MAX<DAngle>(0., toppitch), bottompitch);
FPathTraverse it(startpos.X, startpos.Y, aimtrace.X, aimtrace.Y, PT_ADDLINES | PT_ADDTHINGS | PT_COMPATIBLE | PT_DELTA, startfrac);
FPathTraverse it(shootthing->Level, startpos.X, startpos.Y, aimtrace.X, aimtrace.Y, PT_ADDLINES | PT_ADDTHINGS | PT_COMPATIBLE | PT_DELTA, startfrac);
intercept_t *in;
if (aimdebug)
@ -5380,7 +5380,7 @@ bool P_TalkFacing(AActor *player)
bool P_UseTraverse(AActor *usething, const DVector2 &start, const DVector2 &end, bool &foundline)
{
FPathTraverse it(start.X, start.Y, end.X, end.Y, PT_ADDLINES | PT_ADDTHINGS);
FPathTraverse it(usething->Level, start.X, start.Y, end.X, end.Y, PT_ADDLINES | PT_ADDTHINGS);
intercept_t *in;
DVector3 xpos = { start.X, start.Y, usething->Z() };
@ -5523,7 +5523,7 @@ bool P_UseTraverse(AActor *usething, const DVector2 &start, const DVector2 &end,
bool P_NoWayTraverse(AActor *usething, const DVector2 &start, const DVector2 &end)
{
FPathTraverse it(start.X, start.Y, end.X, end.Y, PT_ADDLINES);
FPathTraverse it(usething->Level, start.X, start.Y, end.X, end.Y, PT_ADDLINES);
intercept_t *in;
while ((in = it.Next()))
@ -5600,7 +5600,7 @@ int P_UsePuzzleItem(AActor *PuzzleItemUser, int PuzzleItemType)
start = PuzzleItemUser->GetPortalTransition(PuzzleItemUser->Height / 2);
end = PuzzleItemUser->Angles.Yaw.ToVector(usedist);
FPathTraverse it(start.X, start.Y, end.X, end.Y, PT_DELTA | PT_ADDLINES | PT_ADDTHINGS);
FPathTraverse it(PuzzleItemUser->Level, start.X, start.Y, end.X, end.Y, PT_DELTA | PT_ADDLINES | PT_ADDTHINGS);
intercept_t *in;
while ((in = it.Next()))

74
src/p_maputl.cpp
View file

@ -582,7 +582,7 @@ void AActor::SetOrigin(double x, double y, double z, bool moving)
//
//===========================================================================
FBlockLinesIterator::FBlockLinesIterator(int _minx, int _miny, int _maxx, int _maxy, bool keepvalidcount)
FBlockLinesIterator::FBlockLinesIterator(FLevelLocals *l, int _minx, int _miny, int _maxx, int _maxy, bool keepvalidcount) : Level(l)
{
if (!keepvalidcount) validcount++;
minx = _minx;
@ -595,14 +595,14 @@ FBlockLinesIterator::FBlockLinesIterator(int _minx, int _miny, int _maxx, int _m
void FBlockLinesIterator::init(const FBoundingBox &box)
{
validcount++;
maxy = level.blockmap.GetBlockY(box.Top());
miny = level.blockmap.GetBlockY(box.Bottom());
maxx = level.blockmap.GetBlockX(box.Right());
minx = level.blockmap.GetBlockX(box.Left());
maxy = Level->blockmap.GetBlockY(box.Top());
miny = Level->blockmap.GetBlockY(box.Bottom());
maxx = Level->blockmap.GetBlockX(box.Right());
minx = Level->blockmap.GetBlockX(box.Left());
Reset();
}
FBlockLinesIterator::FBlockLinesIterator(const FBoundingBox &box)
FBlockLinesIterator::FBlockLinesIterator(FLevelLocals *l, const FBoundingBox &box) : Level(l)
{
init(box);
}
@ -617,13 +617,13 @@ void FBlockLinesIterator::StartBlock(int x, int y)
{
curx = x;
cury = y;
if (level.blockmap.isValidBlock(x, y))
if (Level->blockmap.isValidBlock(x, y))
{
unsigned offset = y*level.blockmap.bmapwidth + x;
polyLink = level.PolyBlockMap.Size() > offset? level.PolyBlockMap[offset] : nullptr;
unsigned offset = y*Level->blockmap.bmapwidth + x;
polyLink = Level->PolyBlockMap.Size() > offset? Level->PolyBlockMap[offset] : nullptr;
polyIndex = 0;
list = level.blockmap.GetLines(x, y);
list = Level->blockmap.GetLines(x, y);
}
else
{
@ -682,7 +682,7 @@ line_t *FBlockLinesIterator::Next()
{
while (*list != -1)
{
line_t *ld = &level.lines[*list];
line_t *ld = &Level->lines[*list];
list++;
if (ld->validcount != validcount)
@ -711,7 +711,7 @@ line_t *FBlockLinesIterator::Next()
//===========================================================================
FMultiBlockLinesIterator::FMultiBlockLinesIterator(FPortalGroupArray &check, AActor *origin, double checkradius)
: checklist(check)
: checklist(check), blockIterator(origin->Level)
{
checkpoint = origin->Pos();
if (!check.inited) P_CollectConnectedGroups(origin->Level, origin->Sector->PortalGroup, checkpoint, origin->Top(), checkradius, checklist);
@ -722,7 +722,7 @@ FMultiBlockLinesIterator::FMultiBlockLinesIterator(FPortalGroupArray &check, AAc
}
FMultiBlockLinesIterator::FMultiBlockLinesIterator(FPortalGroupArray &check, FLevelLocals *Level, double checkx, double checky, double checkz, double checkh, double checkradius, sector_t *newsec)
: checklist(check)
: checklist(check), blockIterator(Level)
{
checkpoint = { checkx, checky, checkz };
if (newsec == NULL) newsec = P_PointInSector(checkx, checky);
@ -848,7 +848,7 @@ bool FMultiBlockLinesIterator::Next(FMultiBlockLinesIterator::CheckResult *item)
bool FMultiBlockLinesIterator::startIteratorForGroup(int group)
{
offset = level.Displacements.getOffset(basegroup, group);
offset = blockIterator.Level->Displacements.getOffset(basegroup, group);
offset.X += checkpoint.X;
offset.Y += checkpoint.Y;
cursector = group == startsector->PortalGroup ? startsector : P_PointInSector(offset);
@ -881,8 +881,8 @@ void FMultiBlockLinesIterator::Reset()
//
//===========================================================================
FBlockThingsIterator::FBlockThingsIterator()
: DynHash(0)
FBlockThingsIterator::FBlockThingsIterator(FLevelLocals *l)
: Level(l), DynHash(0)
{
minx = maxx = 0;
miny = maxy = 0;
@ -890,8 +890,8 @@ FBlockThingsIterator::FBlockThingsIterator()
block = NULL;
}
FBlockThingsIterator::FBlockThingsIterator(int _minx, int _miny, int _maxx, int _maxy)
: DynHash(0)
FBlockThingsIterator::FBlockThingsIterator(FLevelLocals *L, int _minx, int _miny, int _maxx, int _maxy)
: Level(L), DynHash(0)
{
minx = _minx;
maxx = _maxx;
@ -903,10 +903,10 @@ FBlockThingsIterator::FBlockThingsIterator(int _minx, int _miny, int _maxx, int
void FBlockThingsIterator::init(const FBoundingBox &box)
{
maxy = level.blockmap.GetBlockY(box.Top());
miny = level.blockmap.GetBlockY(box.Bottom());
maxx = level.blockmap.GetBlockX(box.Right());
minx = level.blockmap.GetBlockX(box.Left());
maxy = Level->blockmap.GetBlockY(box.Top());
miny = Level->blockmap.GetBlockY(box.Bottom());
maxx = Level->blockmap.GetBlockX(box.Right());
minx = Level->blockmap.GetBlockX(box.Left());
ClearHash();
Reset();
}
@ -934,9 +934,9 @@ void FBlockThingsIterator::StartBlock(int x, int y)
{
curx = x;
cury = y;
if (level.blockmap.isValidBlock(x, y))
if (Level->blockmap.isValidBlock(x, y))
{
block = level.blockmap.blocklinks[y*level.blockmap.bmapwidth + x];
block = Level->blockmap.blocklinks[y*Level->blockmap.bmapwidth + x];
}
else
{
@ -984,9 +984,9 @@ AActor *FBlockThingsIterator::Next(bool centeronly)
if (centeronly)
{
// Block boundaries for compatibility mode
double blockleft = (curx * FBlockmap::MAPBLOCKUNITS) + level.blockmap.bmaporgx;
double blockleft = (curx * FBlockmap::MAPBLOCKUNITS) + Level->blockmap.bmaporgx;
double blockright = blockleft + FBlockmap::MAPBLOCKUNITS;
double blockbottom = (cury * FBlockmap::MAPBLOCKUNITS) + level.blockmap.bmaporgy;
double blockbottom = (cury * FBlockmap::MAPBLOCKUNITS) + Level->blockmap.bmaporgy;
double blocktop = blockbottom + FBlockmap::MAPBLOCKUNITS;
// only return actors with the center in this block
@ -1053,7 +1053,7 @@ AActor *FBlockThingsIterator::Next(bool centeronly)
//===========================================================================
FMultiBlockThingsIterator::FMultiBlockThingsIterator(FPortalGroupArray &check, AActor *origin, double checkradius, bool ignorerestricted)
: checklist(check)
: checklist(check), blockIterator(origin->Level)
{
checkpoint = origin->Pos();
if (!check.inited) P_CollectConnectedGroups(origin->Level, origin->Sector->PortalGroup, checkpoint, origin->Top(), checkradius, checklist);
@ -1063,7 +1063,7 @@ FMultiBlockThingsIterator::FMultiBlockThingsIterator(FPortalGroupArray &check, A
}
FMultiBlockThingsIterator::FMultiBlockThingsIterator(FPortalGroupArray &check, FLevelLocals *Level, double checkx, double checky, double checkz, double checkh, double checkradius, bool ignorerestricted, sector_t *newsec)
: checklist(check)
: checklist(check), blockIterator(Level)
{
checkpoint.X = checkx;
checkpoint.Y = checky;
@ -1087,7 +1087,7 @@ bool FMultiBlockThingsIterator::Next(FMultiBlockThingsIterator::CheckResult *ite
if (thing != NULL)
{
item->thing = thing;
item->Position = checkpoint + level.Displacements.getOffset(basegroup, thing->Sector->PortalGroup);
item->Position = checkpoint + blockIterator.Level->Displacements.getOffset(basegroup, thing->Sector->PortalGroup);
item->portalflags = portalflags;
return true;
}
@ -1126,7 +1126,7 @@ bool FMultiBlockThingsIterator::Next(FMultiBlockThingsIterator::CheckResult *ite
void FMultiBlockThingsIterator::startIteratorForGroup(int group)
{
DVector2 offset = level.Displacements.getOffset(basegroup, group);
DVector2 offset = blockIterator.Level->Displacements.getOffset(basegroup, group);
offset.X += checkpoint.X;
offset.Y += checkpoint.Y;
bbox.setBox(offset.X, offset.Y, checkpoint.Z);
@ -1169,7 +1169,7 @@ TArray<intercept_t> FPathTraverse::intercepts(128);
void FPathTraverse::AddLineIntercepts(int bx, int by)
{
FBlockLinesIterator it(bx, by, bx, by, true);
FBlockLinesIterator it(Level, bx, by, bx, by, true);
line_t *ld;
while ((ld = it.Next()))
@ -1459,13 +1459,13 @@ void FPathTraverse::init(double x1, double y1, double x2, double y2, int flags,
y2 += y1;
}
x1 -= level.blockmap.bmaporgx;
y1 -= level.blockmap.bmaporgy;
x1 -= Level->blockmap.bmaporgx;
y1 -= Level->blockmap.bmaporgy;
xt1 = x1 / FBlockmap::MAPBLOCKUNITS;
yt1 = y1 / FBlockmap::MAPBLOCKUNITS;
x2 -= level.blockmap.bmaporgx;
y2 -= level.blockmap.bmaporgy;
x2 -= Level->blockmap.bmaporgx;
y2 -= Level->blockmap.bmaporgy;
xt2 = x2 / FBlockmap::MAPBLOCKUNITS;
yt2 = y2 / FBlockmap::MAPBLOCKUNITS;
@ -1543,7 +1543,7 @@ void FPathTraverse::init(double x1, double y1, double x2, double y2, int flags,
bool compatible = (flags & PT_COMPATIBLE) && (i_compatflags & COMPATF_HITSCAN);
// we want to use one list of checked actors for the entire operation
FBlockThingsIterator btit;
FBlockThingsIterator btit(Level);
for (count = 0 ; count < 1000 ; count++)
{
if (flags & PT_ADDLINES)
@ -1789,7 +1789,7 @@ static AActor *RoughBlockCheck (AActor *mo, int index, void *param)
FBlockNode *link;
for (link = level.blockmap.blocklinks[index]; link != NULL; link = link->NextActor)
for (link = mo->Level->blockmap.blocklinks[index]; link != NULL; link = link->NextActor)
{
if (link->Me != mo)
{

28
src/p_maputl.h
View file

@ -117,7 +117,7 @@ struct FLineOpening
static const double LINEOPEN_MIN = -FLT_MAX;
static const double LINEOPEN_MAX = FLT_MAX;
void P_LineOpening(FLineOpening &open, AActor *thing, const line_t *linedef, const DVector2 &xy, const DVector2 *ref = NULL, int flags = 0);
void P_LineOpening(FLineOpening &open, AActor *thing, const line_t *linedef, const DVector2 &xy, const DVector2 *ref = nullptr, int flags = 0);
inline void P_LineOpening(FLineOpening &open, AActor *thing, const line_t *linedef, const DVector2 &xy, const DVector3 *ref, int flags = 0)
{
P_LineOpening(open, thing, linedef, xy, reinterpret_cast<const DVector2*>(ref), flags);
@ -206,6 +206,7 @@ private:
class FBlockLinesIterator
{
friend class FMultiBlockLinesIterator;
FLevelLocals *Level;
int minx, maxx;
int miny, maxy;
@ -216,11 +217,11 @@ class FBlockLinesIterator
void StartBlock(int x, int y);
FBlockLinesIterator() {}
FBlockLinesIterator(FLevelLocals *l) { Level = l; }
void init(const FBoundingBox &box);
public:
FBlockLinesIterator(int minx, int miny, int maxx, int maxy, bool keepvalidcount = false);
FBlockLinesIterator(const FBoundingBox &box);
FBlockLinesIterator(FLevelLocals *Level, int minx, int miny, int maxx, int maxy, bool keepvalidcount = false);
FBlockLinesIterator(FLevelLocals *Level, const FBoundingBox &box);
line_t *Next();
void Reset() { StartBlock(minx, miny); }
};
@ -276,6 +277,7 @@ public:
class FBlockThingsIterator
{
FLevelLocals *Level;
int minx, maxx;
int miny, maxy;
@ -302,14 +304,14 @@ class FBlockThingsIterator
// The following is only for use in the path traverser
// and therefore declared private.
FBlockThingsIterator();
FBlockThingsIterator(FLevelLocals *l);
friend class FPathTraverse;
friend class FMultiBlockThingsIterator;
public:
FBlockThingsIterator(int minx, int miny, int maxx, int maxy);
FBlockThingsIterator(const FBoundingBox &box)
FBlockThingsIterator(FLevelLocals *Level, int minx, int miny, int maxx, int maxy);
FBlockThingsIterator(FLevelLocals *Level, const FBoundingBox &box)
{
init(box);
}
@ -331,7 +333,7 @@ class FMultiBlockThingsIterator
void startIteratorForGroup(int group);
protected:
FMultiBlockThingsIterator(FPortalGroupArray &check) : checklist(check) {}
//FMultiBlockThingsIterator(FPortalGroupArray &check) : checklist(check) {}
public:
struct CheckResult
@ -358,6 +360,7 @@ class FPathTraverse
protected:
static TArray<intercept_t> intercepts;
FLevelLocals *Level;
divline_t trace;
double Startfrac;
unsigned int intercept_index;
@ -366,17 +369,18 @@ protected:
virtual void AddLineIntercepts(int bx, int by);
virtual void AddThingIntercepts(int bx, int by, FBlockThingsIterator &it, bool compatible);
FPathTraverse() {}
FPathTraverse(FLevelLocals *l) { Level = l; }
public:
intercept_t *Next();
FPathTraverse(double x1, double y1, double x2, double y2, int flags, double startfrac = 0)
FPathTraverse(FLevelLocals *l, double x1, double y1, double x2, double y2, int flags, double startfrac = 0)
{
Level = l;
init(x1, y1, x2, y2, flags, startfrac);
}
void init(double x1, double y1, double x2, double y2, int flags, double startfrac = 0);
int PortalRelocate(intercept_t *in, int flags, DVector3 *optpos = NULL);
int PortalRelocate(intercept_t *in, int flags, DVector3 *optpos = nullptr);
void PortalRelocate(const DVector2 &disp, int flags, double hitfrac);
virtual ~FPathTraverse();
const divline_t &Trace() const { return trace; }
@ -404,7 +408,7 @@ class FLinePortalTraverse : public FPathTraverse
void AddLineIntercepts(int bx, int by);
public:
FLinePortalTraverse()
FLinePortalTraverse(FLevelLocals *l) : FPathTraverse(l)
{
}
};

2
src/p_saveg.cpp
View file

@ -1007,7 +1007,7 @@ void G_SerializeLevel(FSerializer &arc, FLevelLocals *Level, bool hubload)
if (arc.isReading()) P_FinalizePortals(&level);
// [ZZ] serialize health groups
P_SerializeHealthGroups(arc);
P_SerializeHealthGroups(Level, arc);
// [ZZ] serialize events
E_SerializeEvents(arc);
DThinker::SerializeThinkers(arc, hubload);

2
src/p_secnodes.cpp
View file

@ -238,7 +238,7 @@ msecnode_t *P_CreateSecNodeList(AActor *thing, double radius, msecnode_t *sector
}
FBoundingBox box(thing->X(), thing->Y(), radius);
FBlockLinesIterator it(box);
FBlockLinesIterator it(thing->Level, box);
line_t *ld;
while ((ld = it.Next()))

68
src/p_spec.h
View file

@ -133,19 +133,19 @@ protected:
DLighting();
};
void EV_StartLightFlickering (int tag, int upper, int lower);
void EV_StartLightStrobing (int tag, int upper, int lower, int utics, int ltics);
void EV_StartLightStrobing (int tag, int utics, int ltics);
void EV_TurnTagLightsOff (int tag);
void EV_LightTurnOn (int tag, int bright);
void EV_LightTurnOnPartway (int tag, double frac); // killough 10/98
void EV_LightChange (int tag, int value);
void EV_StopLightEffect (int tag);
void EV_StartLightFlickering (FLevelLocals *Level, int tag, int upper, int lower);
void EV_StartLightStrobing (FLevelLocals *Level, int tag, int upper, int lower, int utics, int ltics);
void EV_StartLightStrobing (FLevelLocals *Level, int tag, int utics, int ltics);
void EV_TurnTagLightsOff (FLevelLocals *Level, int tag);
void EV_LightTurnOn (FLevelLocals *Level, int tag, int bright);
void EV_LightTurnOnPartway (FLevelLocals *Level, int tag, double frac); // killough 10/98
void EV_LightChange (FLevelLocals *Level, int tag, int value);
void EV_StopLightEffect (FLevelLocals *Level, int tag);
void P_SpawnGlowingLight (sector_t *sector);
void EV_StartLightGlowing (int tag, int upper, int lower, int tics);
void EV_StartLightFading (int tag, int value, int tics);
void EV_StartLightGlowing (FLevelLocals *Level, int tag, int upper, int lower, int tics);
void EV_StartLightFading (FLevelLocals *Level, int tag, int value, int tics);
//
@ -310,7 +310,7 @@ protected:
void DoorSound (bool raise, class DSeqNode *curseq=NULL) const;
friend bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing,
friend bool EV_DoDoor (FLevelLocals *Level, DDoor::EVlDoor type, line_t *line, AActor *thing,
int tag, double speed, int delay, int lock,
int lightTag, bool boomgen, int topcountdown);
private:
@ -318,7 +318,7 @@ private:
};
bool EV_DoDoor (DDoor::EVlDoor type, line_t *line, AActor *thing,
bool EV_DoDoor (FLevelLocals *Level, DDoor::EVlDoor type, line_t *line, AActor *thing,
int tag, double speed, int delay, int lock,
int lightTag, bool boomgen = false, int topcountdown = 0);
@ -360,12 +360,12 @@ protected:
int m_Delay;
bool m_SetBlocking1, m_SetBlocking2;
friend bool EV_SlidingDoor (line_t *line, AActor *thing, int tag, int speed, int delay, EADType type);
friend bool EV_SlidingDoor (FLevelLocals *Level, line_t *line, AActor *thing, int tag, int speed, int delay, EADType type);
private:
DAnimatedDoor ();
};
bool EV_SlidingDoor (line_t *line, AActor *thing, int tag, int speed, int delay, DAnimatedDoor::EADType type);
bool EV_SlidingDoor (FLevelLocals *Level, line_t *line, AActor *thing, int tag, int speed, int delay, DAnimatedDoor::EADType type);
//
// P_CEILNG
@ -447,16 +447,16 @@ private:
DCeiling ();
friend bool P_CreateCeiling(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag, double speed, double speed2, double height, int crush, int silent, int change, DCeiling::ECrushMode hexencrush);
friend bool EV_CeilingCrushStop (int tag, bool remove);
friend void P_ActivateInStasisCeiling (int tag);
friend bool EV_CeilingCrushStop (FLevelLocals *Level, int tag, bool remove);
friend void P_ActivateInStasisCeiling (FLevelLocals *Level, int tag);
};
bool P_CreateCeiling(sector_t *sec, DCeiling::ECeiling type, line_t *line, int tag, double speed, double speed2, double height, int crush, int silent, int change, DCeiling::ECrushMode hexencrush);
bool EV_DoCeiling (DCeiling::ECeiling type, line_t *line, int tag, double speed, double speed2, double height, int crush, int silent, int change, DCeiling::ECrushMode hexencrush = DCeiling::ECrushMode::crushDoom);
bool EV_DoCeiling (FLevelLocals *Level, DCeiling::ECeiling type, line_t *line, int tag, double speed, double speed2, double height, int crush, int silent, int change, DCeiling::ECrushMode hexencrush = DCeiling::ECrushMode::crushDoom);
bool EV_CeilingCrushStop (int tag, bool remove);
bool EV_StopCeiling(int tag, line_t *line);
void P_ActivateInStasisCeiling (int tag);
bool EV_CeilingCrushStop (FLevelLocals *Level, int tag, bool remove);
bool EV_StopCeiling(FLevelLocals *Level, int tag, line_t *line);
void P_ActivateInStasisCeiling (FLevelLocals *Level, int tag);
@ -548,12 +548,12 @@ public:
void StartFloorSound ();
void SetFloorChangeType (sector_t *sec, int change);
friend bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line,
friend bool EV_BuildStairs (FLevelLocals *Level, int tag, DFloor::EStair type, line_t *line,
double stairsize, double speed, int delay, int reset, int igntxt,
int usespecials);
friend bool EV_DoFloor (DFloor::EFloor floortype, line_t *line, int tag,
friend bool EV_DoFloor (FLevelLocals *Level, DFloor::EFloor floortype, line_t *line, int tag,
double speed, double height, int crush, int change, bool hexencrush, bool hereticlower);
friend bool EV_DoDonut (int tag, line_t *line, double pillarspeed, double slimespeed);
friend bool EV_DoDonut (FLevelLocals *Level, int tag, line_t *line, double pillarspeed, double slimespeed);
private:
DFloor ();
};
@ -561,15 +561,15 @@ private:
bool P_CreateFloor(sector_t *sec, DFloor::EFloor floortype, line_t *line,
double speed, double height, int crush, int change, bool hexencrush, bool hereticlower);
bool EV_BuildStairs (int tag, DFloor::EStair type, line_t *line,
bool EV_BuildStairs (FLevelLocals *Level, int tag, DFloor::EStair type, line_t *line,
double stairsize, double speed, int delay, int reset, int igntxt,
int usespecials);
bool EV_DoFloor(DFloor::EFloor floortype, line_t *line, int tag,
bool EV_DoFloor(FLevelLocals *Level, DFloor::EFloor floortype, line_t *line, int tag,
double speed, double height, int crush, int change, bool hexencrush, bool hereticlower = false);
bool EV_FloorCrushStop (int tag, line_t *line);
bool EV_StopFloor(int tag, line_t *line);
bool EV_DoDonut (int tag, line_t *line, double pillarspeed, double slimespeed);
bool EV_FloorCrushStop (FLevelLocals *Level, int tag, line_t *line);
bool EV_StopFloor(FLevelLocals *Level, int tag, line_t *line);
bool EV_DoDonut (FLevelLocals *Level, int tag, line_t *line, double pillarspeed, double slimespeed);
class DElevator : public DMover
{
@ -603,12 +603,12 @@ protected:
void StartFloorSound ();
friend bool EV_DoElevator (line_t *line, DElevator::EElevator type, double speed, double height, int tag);
friend bool EV_DoElevator (FLevelLocals *Level, line_t *line, DElevator::EElevator type, double speed, double height, int tag);
private:
DElevator ();
};
bool EV_DoElevator (line_t *line, DElevator::EElevator type, double speed, double height, int tag);
bool EV_DoElevator (FLevelLocals *Level, line_t *line, DElevator::EElevator type, double speed, double height, int tag);
class DWaggleBase : public DMover
{
@ -629,15 +629,13 @@ protected:
int m_Ticker;
int m_State;
friend bool EV_StartWaggle (int tag, line_t *line, int height, int speed,
int offset, int timer, bool ceiling);
friend bool EV_StartWaggle (FLevelLocals *Level, int tag, line_t *line, int height, int speed, int offset, int timer, bool ceiling);
void DoWaggle (bool ceiling);
DWaggleBase ();
};
bool EV_StartWaggle (int tag, line_t *line, int height, int speed,
int offset, int timer, bool ceiling);
bool EV_StartWaggle (FLevelLocals *Level, int tag, line_t *line, int height, int speed, int offset, int timer, bool ceiling);
class DFloorWaggle : public DWaggleBase
{
@ -666,7 +664,7 @@ enum EChange
numChangeOnly,
};
bool EV_DoChange (line_t *line, EChange changetype, int tag);
bool EV_DoChange (FLevelLocals *Level, line_t *line, EChange changetype, int tag);

4
src/p_trace.cpp
View file

@ -779,7 +779,7 @@ bool FTraceInfo::TraceTraverse (int ptflags)
// Do a 3D floor check in the starting sector
Setup3DFloors();
FPathTraverse it(Start.X, Start.Y, Vec.X * MaxDist, Vec.Y * MaxDist, ptflags | PT_DELTA, startfrac);
FPathTraverse it(CurSector->Level, Start.X, Start.Y, Vec.X * MaxDist, Vec.Y * MaxDist, ptflags | PT_DELTA, startfrac);
intercept_t *in;
int lastsplashsector = -1;
@ -1022,7 +1022,7 @@ DEFINE_ACTION_FUNCTION(DLineTracer, Trace)
PARAM_FLOAT(start_x);
PARAM_FLOAT(start_y);
PARAM_FLOAT(start_z);
PARAM_POINTER(sector, sector_t);
PARAM_POINTER_NOT_NULL(sector, sector_t);
PARAM_FLOAT(direction_x);
PARAM_FLOAT(direction_y);
PARAM_FLOAT(direction_z);

2
src/po_man.cpp
View file

@ -1279,7 +1279,7 @@ void FPolyObj::LinkPolyobj ()
void FPolyObj::RecalcActorFloorCeil(FBoundingBox bounds) const
{
FBlockThingsIterator it(bounds);
FBlockThingsIterator it(GetLevel(), bounds);
AActor *actor;
while ((actor = it.Next()) != nullptr)

2
src/polyrenderer/scene/poly_wall.cpp
View file

@ -637,7 +637,7 @@ PolyWallTextureCoordsU::PolyWallTextureCoordsU(FSoftwareTexture *tex, const seg_
PolyWallTextureCoordsV::PolyWallTextureCoordsV(FSoftwareTexture *tex, const line_t *line, const side_t *side, side_t::ETexpart wallpart, double topz, double bottomz, double unpeggedceil, double topTexZ, double bottomTexZ)
{
double yoffset = side->GetTextureYOffset(wallpart);
if (tex->useWorldPanning())
if (tex->useWorldPanning(line->GetLevel()))
yoffset *= side->GetTextureYScale(wallpart) * tex->GetScale().Y;
switch (wallpart)

4
src/portal.cpp
View file

@ -744,7 +744,7 @@ DVector2 P_GetOffsetPosition(FLevelLocals *Level, double x, double y, double dx,
bool repeat;
do
{
FLinePortalTraverse it;
FLinePortalTraverse it(Level);
it.init(actx, acty, dx, dy, PT_ADDLINES|PT_DELTA);
intercept_t *in;
@ -1261,7 +1261,7 @@ bool P_CollectConnectedGroups(FLevelLocals *Level, int startgroup, const DVector
{
DVector2 disp = Level->Displacements.getOffset(startgroup, thisgroup & ~FPortalGroupArray::FLAT);
FBoundingBox box(position.X + disp.X, position.Y + disp.Y, checkradius);
FBlockLinesIterator it(box);
FBlockLinesIterator it(Level, box);
line_t *ld;
while ((ld = it.Next()))
{

14
src/swrenderer/line/r_line.cpp
View file

@ -444,7 +444,7 @@ namespace swrenderer
double yscale = (pic ? pic->GetScale().Y : 1.0) * sidedef->GetTextureYScale(side_t::mid);
fixed_t xoffset = FLOAT2FIXED(sidedef->GetTextureXOffset(side_t::mid));
if (pic && pic->useWorldPanning())
if (pic && pic->useWorldPanning(sidedef->sector->Level))
{
xoffset = xs_RoundToInt(xoffset * lwallscale);
}
@ -822,7 +822,7 @@ namespace swrenderer
mTopPart.TextureMid = (mBackSector->GetPlaneTexZ(sector_t::ceiling) - Thread->Viewport->viewpoint.Pos.Z) * yrepeat;
}
}
if (mTopPart.Texture->useWorldPanning())
if (mTopPart.Texture->useWorldPanning(mLineSegment->frontsector->Level))
{
mTopPart.TextureMid += rowoffset * yrepeat;
}
@ -880,7 +880,7 @@ namespace swrenderer
mMiddlePart.TextureMid = (mFrontSector->GetPlaneTexZ(sector_t::ceiling) - Thread->Viewport->viewpoint.Pos.Z) * yrepeat + mMiddlePart.Texture->GetHeight();
}
}
if (mMiddlePart.Texture->useWorldPanning())
if (mMiddlePart.Texture->useWorldPanning(mLineSegment->frontsector->Level))
{
mMiddlePart.TextureMid += rowoffset * yrepeat;
}
@ -947,7 +947,7 @@ namespace swrenderer
mBottomPart.TextureMid = (mBackSector->GetPlaneTexZ(sector_t::floor) - Thread->Viewport->viewpoint.Pos.Z) * yrepeat + mBottomPart.Texture->GetHeight();
}
}
if (mBottomPart.Texture->useWorldPanning())
if (mBottomPart.Texture->useWorldPanning(mLineSegment->frontsector->Level))
{
mBottomPart.TextureMid += rowoffset * yrepeat;
}
@ -1122,7 +1122,7 @@ namespace swrenderer
lwallscale = xscale;
}
fixed_t offset;
if (mTopPart.Texture->useWorldPanning())
if (mTopPart.Texture->useWorldPanning(mLineSegment->frontsector->Level))
{
offset = xs_RoundToInt(mTopPart.TextureOffsetU * xscale);
}
@ -1153,7 +1153,7 @@ namespace swrenderer
lwallscale = xscale;
}
fixed_t offset;
if (mMiddlePart.Texture->useWorldPanning())
if (mMiddlePart.Texture->useWorldPanning(mLineSegment->frontsector->Level))
{
offset = xs_RoundToInt(mMiddlePart.TextureOffsetU * xscale);
}
@ -1185,7 +1185,7 @@ namespace swrenderer
lwallscale = xscale;
}
fixed_t offset;
if (mBottomPart.Texture->useWorldPanning())
if (mBottomPart.Texture->useWorldPanning(mLineSegment->frontsector->Level))
{
offset = xs_RoundToInt(mBottomPart.TextureOffsetU * xscale);
}

6
src/swrenderer/line/r_renderdrawsegment.cpp
View file

@ -197,7 +197,7 @@ namespace swrenderer
MaskedScaleY = -MaskedScaleY;
sprflipvert = true;
}
if (tex->useWorldPanning())
if (tex->useWorldPanning(curline->frontsector->Level))
{
// rowoffset is added before the multiply so that the masked texture will
// still be positioned in world units rather than texels.
@ -332,7 +332,7 @@ namespace swrenderer
}
else
{ // Texture does wrap vertically.
if (tex->useWorldPanning())
if (tex->useWorldPanning(curline->frontsector->Level))
{
// rowoffset is added before the multiply so that the masked texture will
// still be positioned in world units rather than texels.
@ -447,7 +447,7 @@ namespace swrenderer
rowoffset += rw_pic->GetHeight();
}
double texturemid = (planez - Thread->Viewport->viewpoint.Pos.Z) * yscale;
if (rw_pic->useWorldPanning())
if (rw_pic->useWorldPanning(curline->frontsector->Level))
{
// rowoffset is added before the multiply so that the masked texture will
// still be positioned in world units rather than texels.

4
src/swrenderer/textures/r_swtexture.h
View file

@ -45,9 +45,9 @@ public:
}
// The feature from hell... :(
bool useWorldPanning() const
bool useWorldPanning(FLevelLocals *Level) const
{
return mTexture->bWorldPanning || (level.flags3 & LEVEL3_FORCEWORLDPANNING);
return mTexture->bWorldPanning || (Level->flags3 & LEVEL3_FORCEWORLDPANNING);
}
bool isMasked()

3
wadsrc/static/zscript/base.txt
View file

@ -707,7 +707,8 @@ struct LevelLocals native
native SpotState GetSpotState(bool create = true);
native void ReplaceTextures(String from, String to, int flags);
native Actor Spawn(class<Actor> type, vector3 pos = (0,0,0), int replace = NO_REPLACE);
clearscope native HealthGroup FindHealthGroup(int id);
native clearscope bool IsPointInMap(vector3 p);
native clearscope vector2 Vec2Diff(vector2 v1, vector2 v2);

5
wadsrc/static/zscript/destructible.txt
View file

@ -1,6 +1,9 @@
struct HealthGroup native play
{
static clearscope native HealthGroup Find(int id);
deprecated("3.8") static clearscope HealthGroup Find(int id)
{
return level.FindHealthGroup(id);
}
readonly int id;
readonly int health;