//----------------------------------------------------------------------------- // // Copyright 1993-1996 id Software // Copyright 1994-1996 Raven Software // Copyright 1998-1998 Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman // Copyright 1999-2016 Randy Heit // Copyright 2002-2017 Christoph Oelckers // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see http://www.gnu.org/licenses/ // //----------------------------------------------------------------------------- // // DESCRIPTION: // Movement/collision utility functions, // as used by function in p_map.c. // BLOCKMAP Iterator functions, // and some PIT_* functions to use for iteration. // //----------------------------------------------------------------------------- /* For code that originates from ZDoom the following applies: ** **--------------------------------------------------------------------------- ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions ** are met: ** ** 1. Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** 2. Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in the ** documentation and/or other materials provided with the distribution. ** 3. The name of the author may not be used to endorse or promote products ** derived from this software without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. **--------------------------------------------------------------------------- ** */ #include #include "m_bbox.h" #include "doomdef.h" #include "doomdata.h" #include "doomstat.h" #include "p_local.h" #include "p_maputl.h" #include "p_3dmidtex.h" #include "p_blockmap.h" #include "r_utility.h" #include "actor.h" #include "actorinlines.h" // State. #include "r_state.h" #include "templates.h" #include "po_man.h" #include "g_levellocals.h" #include "vm.h" sector_t *P_PointInSectorBuggy(double x, double y); int P_VanillaPointOnDivlineSide(double x, double y, const divline_t* line); //========================================================================== // // P_AproxDistance // // Gives an estimation of distance (not exact) // //========================================================================== int P_AproxDistance (int dx, int dy) { dx = abs(dx); dy = abs(dy); return (dx < dy) ? dx+dy-(dx>>1) : dx+dy-(dy>>1); } //========================================================================== // // P_InterceptVector // // Returns the fractional intercept point along the first divline. // //========================================================================== double P_InterceptVector(const divline_t *v2, const divline_t *v1) { double num; double den; double v1x = v1->x; double v1y = v1->y; double v1dx = v1->dx; double v1dy = v1->dy; double v2x = v2->x; double v2y = v2->y; double v2dx = v2->dx; double v2dy = v2->dy; den = v1dy*v2dx - v1dx*v2dy; if (den == 0) return 0; // parallel num = (v1x - v2x)*v1dy + (v2y - v1y)*v1dx; return num / den; } //========================================================================== // // P_LineOpening // // Sets opentop and openbottom to the window // through a two sided line. // //========================================================================== void P_LineOpening (FLineOpening &open, AActor *actor, const line_t *linedef, const DVector2 &pos, const DVector2 *ref, int flags) { if (!(flags & FFCF_ONLY3DFLOORS)) { sector_t *front, *back; double fc = 0, ff = 0, bc = 0, bf = 0; if (linedef->backsector == NULL) { // single sided line open.range = 0; return; } front = linedef->frontsector; back = linedef->backsector; if (!(flags & FFCF_NOPORTALS) && (linedef->flags & ML_PORTALCONNECT)) { if (!linedef->frontsector->PortalBlocksMovement(sector_t::ceiling)) fc = LINEOPEN_MAX; if (!linedef->backsector->PortalBlocksMovement(sector_t::ceiling)) bc = LINEOPEN_MAX; if (!linedef->frontsector->PortalBlocksMovement(sector_t::floor)) ff = LINEOPEN_MIN; if (!linedef->backsector->PortalBlocksMovement(sector_t::floor)) bf = LINEOPEN_MIN; } if (fc == 0) fc = front->ceilingplane.ZatPoint(pos); if (bc == 0) bc = back->ceilingplane.ZatPoint(pos); if (ff == 0) ff = front->floorplane.ZatPoint(pos); if (bf == 0) bf = back->floorplane.ZatPoint(pos); /*Printf ("]]]]]] %d %d\n", ff, bf);*/ open.topsec = fc < bc? front : back; open.ceilingpic = open.topsec->GetTexture(sector_t::ceiling); open.top = fc < bc ? fc : bc; bool usefront; // [RH] fudge a bit for actors that are moving across lines // bordering a slope/non-slope that meet on the floor. Note // that imprecisions in the plane equation mean there is a // good chance that even if a slope and non-slope look like // they line up, they won't be perfectly aligned. if (ff == -FLT_MIN || bf == -FLT_MIN || ref == NULL || fabs (ff-bf) > 1./256) { usefront = (ff > bf); } else { if (!front->floorplane.isSlope()) usefront = true; else if (!back->floorplane.isSlope()) usefront = false; else usefront = !P_PointOnLineSide (*ref, linedef); } if (usefront) { open.bottom = ff; open.bottomsec = front; open.floorpic = front->GetTexture(sector_t::floor); open.floorterrain = front->GetTerrain(sector_t::floor); if (bf != -FLT_MIN) open.lowfloor = bf; else if (!(flags & FFCF_NODROPOFF)) { // We must check through the portal for the actual dropoff. // If there's no lines in the lower sections we'd never get a usable value otherwise. open.lowfloor = back->NextLowestFloorAt(pos.X, pos.Y, back->GetPortalPlaneZ(sector_t::floor) - EQUAL_EPSILON); } } else { open.bottom = bf; open.bottomsec = back; open.floorpic = back->GetTexture(sector_t::floor); open.floorterrain = back->GetTerrain(sector_t::floor); if (ff != -FLT_MIN) open.lowfloor = ff; else if (!(flags & FFCF_NODROPOFF)) { // We must check through the portal for the actual dropoff. // If there's no lines in the lower sections we'd never get a usable value otherwise. open.lowfloor = front->NextLowestFloorAt(pos.X, pos.Y, front->GetPortalPlaneZ(sector_t::floor) - EQUAL_EPSILON); } } open.frontfloorplane = front->floorplane; open.backfloorplane = back->floorplane; } else { // Dummy stuff to have some sort of opening for the 3D checks to modify open.topsec = NULL; open.ceilingpic.SetInvalid(); open.top = LINEOPEN_MAX; open.bottomsec = NULL; open.floorpic.SetInvalid(); open.floorterrain = -1; open.bottom = LINEOPEN_MIN; open.lowfloor = LINEOPEN_MAX; open.frontfloorplane.SetAtHeight(LINEOPEN_MIN, sector_t::floor); open.backfloorplane.SetAtHeight(LINEOPEN_MIN, sector_t::floor); } // Check 3D floors if (actor != NULL) { P_LineOpening_XFloors(open, actor, linedef, pos.X, pos.Y, !!(flags & FFCF_3DRESTRICT)); } if (actor != NULL && linedef->frontsector != NULL && linedef->backsector != NULL && linedef->flags & ML_3DMIDTEX) { open.touchmidtex = P_LineOpening_3dMidtex(actor, linedef, open, !!(flags & FFCF_3DRESTRICT)); } else { open.abovemidtex = open.touchmidtex = false; } // avoid overflows in the opening. open.range = clamp(open.top - open.bottom, LINEOPEN_MIN, LINEOPEN_MAX); } // // THING POSITION SETTING // //========================================================================== // // P_UnsetThingPosition // Unlinks a thing from block map and sectors. // On each position change, BLOCKMAP and other // lookups maintaining lists of things inside // these structures need to be updated. // //========================================================================== void AActor::UnlinkFromWorld (FLinkContext *ctx) { if (ctx != nullptr) ctx->sector_list = nullptr; if (!(flags & MF_NOSECTOR)) { // invisible things don't need to be in sector list // unlink from subsector // killough 8/11/98: simpler scheme using pointers-to-pointers for prev // pointers, allows head node pointers to be treated like everything else AActor **prev = sprev; AActor *next = snext; if (prev != NULL) // prev will be NULL if this actor gets deleted due to cleaning up from a broken savegame { if ((*prev = next)) // unlink from sector list next->sprev = prev; snext = NULL; sprev = (AActor **)(size_t)0xBeefCafe; // Woo! Bug-catching value! // phares 3/14/98 // // Save the sector list pointed to by touching_sectorlist. // In P_SetThingPosition, we'll keep any nodes that represent // sectors the Thing still touches. We'll add new ones then, and // delete any nodes for sectors the Thing has vacated. Then we'll // put it back into touching_sectorlist. It's done this way to // avoid a lot of deleting/creating for nodes, when most of the // time you just get back what you deleted anyway. if (ctx != nullptr) { ctx->sector_list = touching_sectorlist; ctx->render_list = touching_rendersectors; } else { P_DelSeclist(touching_sectorlist, §or_t::touching_thinglist); P_DelSeclist(touching_rendersectors, §or_t::touching_renderthings); } touching_sectorlist = nullptr; //to be restored by P_SetThingPosition touching_rendersectors = nullptr; } } if (!(flags & MF_NOBLOCKMAP)) { // [RH] Unlink from all blocks this actor uses FBlockNode *block = this->BlockNode; while (block != NULL) { if (block->NextActor != NULL) { block->NextActor->PrevActor = block->PrevActor; } *(block->PrevActor) = block->NextActor; FBlockNode *next = block->NextBlock; block->Release (); block = next; } BlockNode = NULL; } ClearRenderSectorList(); ClearRenderLineList(); } DEFINE_ACTION_FUNCTION(AActor, UnlinkFromWorld) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER_DEF(ctx, FLinkContext); self->UnlinkFromWorld(ctx); // fixme return 0; } //========================================================================== // // If the thing is exactly on a line, move it into the sector // slightly in order to resolve clipping issues in the renderer. // //========================================================================== bool AActor::FixMapthingPos() { sector_t *secstart = P_PointInSectorBuggy(X(), Y()); int blockx = level.blockmap.GetBlockX(X()); int blocky = level.blockmap.GetBlockY(Y()); bool success = false; if (level.blockmap.isValidBlock(blockx, blocky)) { int *list; for (list = level.blockmap.GetLines(blockx, blocky); *list != -1; ++list) { line_t *ldef = &level.lines[*list]; if (ldef->frontsector == ldef->backsector) { // Skip two-sided lines inside a single sector continue; } if (ldef->backsector != NULL) { if (ldef->frontsector->floorplane == ldef->backsector->floorplane && ldef->frontsector->ceilingplane == ldef->backsector->ceilingplane) { // Skip two-sided lines without any height difference on either side continue; } } // Not inside the line's bounding box if (X() + radius <= ldef->bbox[BOXLEFT] || X() - radius >= ldef->bbox[BOXRIGHT] || Y() + radius <= ldef->bbox[BOXBOTTOM] || Y() - radius >= ldef->bbox[BOXTOP]) continue; // Get the exact distance to the line divline_t dll, dlv; double linelen = ldef->Delta().Length(); P_MakeDivline(ldef, &dll); dlv.x = X(); dlv.y = Y(); dlv.dx = dll.dy / linelen; dlv.dy = -dll.dx / linelen; double distance = fabs(P_InterceptVector(&dlv, &dll)); if (distance < radius) { DPrintf(DMSG_NOTIFY, "%s at (%f,%f) lies on %s line %d, distance = %f\n", this->GetClass()->TypeName.GetChars(), X(), Y(), ldef->Delta().X == 0 ? "vertical" : ldef->Delta().Y == 0 ? "horizontal" : "diagonal", ldef->Index(), distance); DAngle ang = ldef->Delta().Angle(); if (ldef->backsector != NULL && ldef->backsector == secstart) { ang += 90.; } else { ang -= 90.; } // Get the distance we have to move the object away from the wall distance = radius - distance; SetXY(Pos().XY() + ang.ToVector(distance)); ClearInterpolation(); success = true; } } } return success; } //========================================================================== // // P_SetThingPosition // Links a thing into both a block and a subsector based on its x y. // Sets thing->sector properly // //========================================================================== void AActor::LinkToWorld(FLinkContext *ctx, bool spawningmapthing, sector_t *sector) { bool spawning = spawningmapthing; if (spawning) { if ((flags4 & MF4_FIXMAPTHINGPOS) && sector == NULL) { if (FixMapthingPos()) spawning = false; } } if (sector == NULL) { if (!spawning) { sector = P_PointInSector(Pos()); } else { sector = P_PointInSectorBuggy(X(), Y()); } } Sector = sector; subsector = R_PointInSubsector(Pos()); // this is from the rendering nodes, not the gameplay nodes! if (!(flags & MF_NOSECTOR)) { // invisible things don't go into the sector links // killough 8/11/98: simpler scheme using pointer-to-pointer prev // pointers, allows head nodes to be treated like everything else AActor **link = §or->thinglist; AActor *next = *link; if ((snext = next)) next->sprev = &snext; sprev = link; *link = this; // phares 3/16/98 // // If sector_list isn't NULL, it has a collection of sector // nodes that were just removed from this Thing. // Collect the sectors the object will live in by looking at // the existing sector_list and adding new nodes and deleting // obsolete ones. // When a node is deleted, its sector links (the links starting // at sector_t->touching_thinglist) are broken. When a node is // added, new sector links are created. touching_sectorlist = P_CreateSecNodeList(this, radius, ctx != nullptr? ctx->sector_list : nullptr, §or_t::touching_thinglist); // Attach to thing if (renderradius >= 0) touching_rendersectors = P_CreateSecNodeList(this, MAX(radius, renderradius), ctx != nullptr ? ctx->render_list : nullptr, §or_t::touching_renderthings); else { touching_rendersectors = nullptr; if (ctx != nullptr) P_DelSeclist(ctx->render_list, §or_t::touching_renderthings); } } // link into blockmap (inert things don't need to be in the blockmap) if (!(flags & MF_NOBLOCKMAP)) { FPortalGroupArray check; P_CollectConnectedGroups(Sector->PortalGroup, Pos(), Top(), radius, check); BlockNode = NULL; FBlockNode **alink = &this->BlockNode; for (int i = -1; i < (int)check.Size(); i++) { DVector3 pos = i==-1? Pos() : PosRelative(check[i] & ~FPortalGroupArray::FLAT); int x1 = level.blockmap.GetBlockX(pos.X - radius); int x2 = level.blockmap.GetBlockX(pos.X + radius); int y1 = level.blockmap.GetBlockY(pos.Y - radius); int y2 = level.blockmap.GetBlockY(pos.Y + radius); if (x1 >= level.blockmap.bmapwidth || x2 < 0 || y1 >= level.blockmap.bmapheight || y2 < 0) { // thing is off the map } else { // [RH] Link into every block this actor touches, not just the center one x1 = MAX(0, x1); y1 = MAX(0, y1); x2 = MIN(level.blockmap.bmapwidth - 1, x2); y2 = MIN(level.blockmap.bmapheight - 1, y2); for (int y = y1; y <= y2; ++y) { for (int x = x1; x <= x2; ++x) { FBlockNode **link = &level.blockmap.blocklinks[y*level.blockmap.bmapwidth + x]; FBlockNode *node = FBlockNode::Create(this, x, y, this->Sector->PortalGroup); // Link in to block if ((node->NextActor = *link) != NULL) { (*link)->PrevActor = &node->NextActor; } node->PrevActor = link; *link = node; // Link in to actor node->PrevBlock = alink; node->NextBlock = NULL; (*alink) = node; alink = &node->NextBlock; } } } } } // Portal links cannot be done unless the level is fully initialized. if (!spawningmapthing) UpdateRenderSectorList(); } DEFINE_ACTION_FUNCTION(AActor, LinkToWorld) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER_DEF(ctx, FLinkContext); self->LinkToWorld(ctx); return 0; } void AActor::SetOrigin(double x, double y, double z, bool moving) { FLinkContext ctx; UnlinkFromWorld (&ctx); SetXYZ(x, y, z); LinkToWorld (&ctx); P_FindFloorCeiling(this, FFCF_ONLYSPAWNPOS); if (!moving) ClearInterpolation(); } DEFINE_ACTION_FUNCTION(AActor, SetOrigin) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_BOOL(moving); self->SetOrigin(x, y, z, moving); return 0; } //=========================================================================== // // FBlockNode - allows to link actors into multiple blocks in the blockmap // //=========================================================================== FBlockNode *FBlockNode::FreeBlocks = NULL; FBlockNode *FBlockNode::Create (AActor *who, int x, int y, int group) { FBlockNode *block; if (FreeBlocks != NULL) { block = FreeBlocks; FreeBlocks = block->NextBlock; } else { block = new FBlockNode; } block->BlockIndex = x + y*level.blockmap.bmapwidth; block->Me = who; block->NextActor = NULL; block->PrevActor = NULL; block->PrevBlock = NULL; block->NextBlock = NULL; return block; } void FBlockNode::Release () { NextBlock = FreeBlocks; FreeBlocks = this; } // // BLOCK MAP ITERATORS // For each line/thing in the given mapblock, // call the passed PIT_* function. // If the function returns false, // exit with false without checking anything else. // //=========================================================================== // // FBlockLinesIterator // //=========================================================================== extern polyblock_t **PolyBlockMap; FBlockLinesIterator::FBlockLinesIterator(int _minx, int _miny, int _maxx, int _maxy, bool keepvalidcount) { if (!keepvalidcount) validcount++; minx = _minx; maxx = _maxx; miny = _miny; maxy = _maxy; Reset(); } 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()); Reset(); } FBlockLinesIterator::FBlockLinesIterator(const FBoundingBox &box) { init(box); } //=========================================================================== // // FBlockLinesIterator :: StartBlock // //=========================================================================== void FBlockLinesIterator::StartBlock(int x, int y) { curx = x; cury = y; if (level.blockmap.isValidBlock(x, y)) { int offset = y*level.blockmap.bmapwidth + x; polyLink = PolyBlockMap? PolyBlockMap[offset] : NULL; polyIndex = 0; list = level.blockmap.GetLines(x, y); } else { // invalid block list = NULL; polyLink = NULL; } } //=========================================================================== // // FBlockLinesIterator :: Next // //=========================================================================== line_t *FBlockLinesIterator::Next() { while (true) { while (polyLink != NULL) { if (polyLink->polyobj) { if (polyIndex == 0) { if (polyLink->polyobj->validcount == validcount) { polyLink = polyLink->next; continue; } polyLink->polyobj->validcount = validcount; } line_t *ld = polyLink->polyobj->Linedefs[polyIndex]; if (++polyIndex >= (int)polyLink->polyobj->Linedefs.Size()) { polyLink = polyLink->next; polyIndex = 0; } if (ld->validcount == validcount) { continue; } else { ld->validcount = validcount; return ld; } } else polyLink = polyLink->next; } if (list != NULL) { while (*list != -1) { line_t *ld = &level.lines[*list]; list++; if (ld->validcount != validcount) { ld->validcount = validcount; return ld; } } } if (++curx > maxx) { curx = minx; if (++cury > maxy) return NULL; } StartBlock(curx, cury); } } //=========================================================================== // // FMultiBlockLinesIterator :: FMultiBlockLinesIterator // // An iterator that can check multiple portal groups. // //=========================================================================== FMultiBlockLinesIterator::FMultiBlockLinesIterator(FPortalGroupArray &check, AActor *origin, double checkradius) : checklist(check) { checkpoint = origin->Pos(); if (!check.inited) P_CollectConnectedGroups(origin->Sector->PortalGroup, checkpoint, origin->Top(), checkradius, checklist); checkpoint.Z = checkradius == -1? origin->radius : checkradius; basegroup = origin->Sector->PortalGroup; startsector = origin->Sector; Reset(); } FMultiBlockLinesIterator::FMultiBlockLinesIterator(FPortalGroupArray &check, double checkx, double checky, double checkz, double checkh, double checkradius, sector_t *newsec) : checklist(check) { checkpoint = { checkx, checky, checkz }; if (newsec == NULL) newsec = P_PointInSector(checkx, checky); startsector = newsec; basegroup = newsec->PortalGroup; if (!check.inited) P_CollectConnectedGroups(basegroup, checkpoint, checkz + checkh, checkradius, checklist); checkpoint.Z = checkradius; Reset(); } //=========================================================================== // // Go up a ceiling portal // //=========================================================================== bool FMultiBlockLinesIterator::GoUp(double x, double y) { if (continueup) { if (!cursector->PortalBlocksMovement(sector_t::ceiling)) { if (startIteratorForGroup(cursector->GetOppositePortalGroup(sector_t::ceiling))) { portalflags = FFCF_NOFLOOR; return true; } } continueup = false; } return false; } //=========================================================================== // // Go down a floor portal // //=========================================================================== bool FMultiBlockLinesIterator::GoDown(double x, double y) { if (continuedown) { if (!cursector->PortalBlocksMovement(sector_t::floor)) { if (startIteratorForGroup(cursector->GetOppositePortalGroup(sector_t::floor))) { portalflags = FFCF_NOCEILING; return true; } } continuedown = false; } return false; } //=========================================================================== // // Gets the next line - also manages switching between portal groups // //=========================================================================== bool FMultiBlockLinesIterator::Next(FMultiBlockLinesIterator::CheckResult *item) { line_t *line = blockIterator.Next(); if (line != NULL) { item->line = line; item->Position.X = offset.X; item->Position.Y = offset.Y; item->portalflags = portalflags; return true; } bool onlast = unsigned(index + 1) >= checklist.Size(); int nextflags = onlast ? 0 : checklist[index + 1] & FPortalGroupArray::FLAT; if (portalflags == FFCF_NOFLOOR && nextflags != FPortalGroupArray::UPPER) { // if this is the last upper portal in the list, check if we need to go further up to find the real ceiling. if (GoUp(offset.X, offset.Y)) return Next(item); } else if (portalflags == FFCF_NOCEILING && nextflags != FPortalGroupArray::LOWER) { // if this is the last lower portal in the list, check if we need to go further down to find the real floor. if (GoDown(offset.X, offset.Y)) return Next(item); } if (onlast) { cursector = startsector; // We reached the end of the list. Check if we still need to check up- and downwards. if (GoUp(checkpoint.X, checkpoint.Y) || GoDown(checkpoint.X, checkpoint.Y)) { return Next(item); } return false; } index++; startIteratorForGroup(checklist[index] & ~FPortalGroupArray::FLAT); switch (nextflags) { case FPortalGroupArray::UPPER: portalflags = FFCF_NOFLOOR; break; case FPortalGroupArray::LOWER: portalflags = FFCF_NOCEILING; break; default: portalflags = 0; } return Next(item); } //=========================================================================== // // start iterating a new group // //=========================================================================== bool FMultiBlockLinesIterator::startIteratorForGroup(int group) { offset = Displacements.getOffset(basegroup, group); offset.X += checkpoint.X; offset.Y += checkpoint.Y; cursector = group == startsector->PortalGroup ? startsector : P_PointInSector(offset); // If we ended up in a different group, // presumably because the spot to be checked is too far outside the actual portal group, // the search needs to abort. if (cursector->PortalGroup != group) return false; bbox.setBox(offset.X, offset.Y, checkpoint.Z); blockIterator.init(bbox); return true; } //=========================================================================== // // Resets the iterator // //=========================================================================== void FMultiBlockLinesIterator::Reset() { continueup = continuedown = true; index = -1; portalflags = 0; startIteratorForGroup(basegroup); } //=========================================================================== // // and the scriptable version // //=========================================================================== class DBlockLinesIterator : public DObject, public FMultiBlockLinesIterator { DECLARE_ABSTRACT_CLASS(DBlockLinesIterator, DObject); FPortalGroupArray check; public: FMultiBlockLinesIterator::CheckResult cres; bool Next() { return FMultiBlockLinesIterator::Next(&cres); } DBlockLinesIterator(AActor *actor, double checkradius) : FMultiBlockLinesIterator(check, actor, checkradius) { cres.line = nullptr; cres.Position.Zero(); cres.portalflags = 0; } DBlockLinesIterator(double x, double y, double z, double height, double radius, sector_t *sec) :FMultiBlockLinesIterator(check, x, y, z, height, radius, sec) { cres.line = nullptr; cres.Position.Zero(); cres.portalflags = 0; } }; IMPLEMENT_CLASS(DBlockLinesIterator, true, false); DEFINE_ACTION_FUNCTION(DBlockLinesIterator, Create) { PARAM_PROLOGUE; PARAM_OBJECT_NOT_NULL(origin, AActor); PARAM_FLOAT_DEF(radius); ACTION_RETURN_OBJECT(Create(origin, radius)); } DEFINE_ACTION_FUNCTION(DBlockLinesIterator, CreateFromPos) { PARAM_PROLOGUE; PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_FLOAT(h); PARAM_FLOAT(radius); PARAM_POINTER_DEF(sec, sector_t); ACTION_RETURN_OBJECT(Create(x, y, z, h, radius, sec)); } DEFINE_ACTION_FUNCTION(DBlockLinesIterator, Next) { PARAM_SELF_PROLOGUE(DBlockLinesIterator); ACTION_RETURN_BOOL(self->Next()); } DEFINE_FIELD_NAMED(DBlockLinesIterator, cres.line, curline); DEFINE_FIELD_NAMED(DBlockLinesIterator, cres.Position, position); DEFINE_FIELD_NAMED(DBlockLinesIterator, cres.portalflags, portalflags); //=========================================================================== // // FBlockThingsIterator :: FBlockThingsIterator // //=========================================================================== FBlockThingsIterator::FBlockThingsIterator() : DynHash(0) { minx = maxx = 0; miny = maxy = 0; ClearHash(); block = NULL; } FBlockThingsIterator::FBlockThingsIterator(int _minx, int _miny, int _maxx, int _maxy) : DynHash(0) { minx = _minx; maxx = _maxx; miny = _miny; maxy = _maxy; ClearHash(); Reset(); } 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()); ClearHash(); Reset(); } //=========================================================================== // // FBlockThingsIterator :: ClearHash // //=========================================================================== void FBlockThingsIterator::ClearHash() { memset(Buckets, -1, sizeof(Buckets)); NumFixedHash = 0; DynHash.Clear(); } //=========================================================================== // // FBlockThingsIterator :: StartBlock // //=========================================================================== void FBlockThingsIterator::StartBlock(int x, int y) { curx = x; cury = y; if (level.blockmap.isValidBlock(x, y)) { block = level.blockmap.blocklinks[y*level.blockmap.bmapwidth + x]; } else { // invalid block block = NULL; } } //=========================================================================== // // FBlockThingsIterator :: SwitchBlock // //=========================================================================== void FBlockThingsIterator::SwitchBlock(int x, int y) { minx = maxx = x; miny = maxy = y; StartBlock(x, y); } //=========================================================================== // // FBlockThingsIterator :: Next // //=========================================================================== AActor *FBlockThingsIterator::Next(bool centeronly) { for (;;) { while (block != NULL) { AActor *me = block->Me; FBlockNode *mynode = block; HashEntry *entry; int i; block = block->NextActor; // Don't recheck things that were already checked if (mynode->NextBlock == NULL && mynode->PrevBlock == &me->BlockNode) { // This actor doesn't span blocks, so we know it can only ever be checked once. return me; } if (centeronly) { // Block boundaries for compatibility mode double blockleft = (curx * FBlockmap::MAPBLOCKUNITS) + level.blockmap.bmaporgx; double blockright = blockleft + FBlockmap::MAPBLOCKUNITS; double blockbottom = (cury * FBlockmap::MAPBLOCKUNITS) + level.blockmap.bmaporgy; double blocktop = blockbottom + FBlockmap::MAPBLOCKUNITS; // only return actors with the center in this block if (me->X() >= blockleft && me->X() < blockright && me->Y() >= blockbottom && me->Y() < blocktop) { return me; } } else { size_t hash = ((size_t)me >> 3) % countof(Buckets); for (i = Buckets[hash]; i >= 0; ) { entry = GetHashEntry(i); if (entry->Actor == me) { // I've already been checked. Skip to the next actor. break; } i = entry->Next; } if (i < 0) { // Add me to the hash table and return me. if (NumFixedHash < (int)countof(FixedHash)) { entry = &FixedHash[NumFixedHash]; entry->Next = Buckets[hash]; Buckets[hash] = NumFixedHash++; } else { if (DynHash.Size() == 0) { DynHash.Grow(50); } i = DynHash.Reserve(1); entry = &DynHash[i]; entry->Next = Buckets[hash]; Buckets[hash] = i + countof(FixedHash); } entry->Actor = me; return me; } } } if (++curx > maxx) { curx = minx; if (++cury > maxy) return NULL; } StartBlock(curx, cury); } } //=========================================================================== // // FMultiBlockThingsIterator :: FMultiBlockThingsIterator // // An iterator that can check multiple portal groups. // //=========================================================================== FMultiBlockThingsIterator::FMultiBlockThingsIterator(FPortalGroupArray &check, AActor *origin, double checkradius, bool ignorerestricted) : checklist(check) { checkpoint = origin->Pos(); if (!check.inited) P_CollectConnectedGroups(origin->Sector->PortalGroup, checkpoint, origin->Top(), checkradius, checklist); checkpoint.Z = checkradius == -1? origin->radius : checkradius; basegroup = origin->Sector->PortalGroup; Reset(); } FMultiBlockThingsIterator::FMultiBlockThingsIterator(FPortalGroupArray &check, double checkx, double checky, double checkz, double checkh, double checkradius, bool ignorerestricted, sector_t *newsec) : checklist(check) { checkpoint.X = checkx; checkpoint.Y = checky; checkpoint.Z = checkz; if (newsec == NULL) newsec = P_PointInSector(checkx, checky); basegroup = newsec->PortalGroup; if (!check.inited) P_CollectConnectedGroups(basegroup, checkpoint, checkz + checkh, checkradius, checklist); checkpoint.Z = checkradius; Reset(); } //=========================================================================== // // Gets the next line - also manages switching between portal groups // //=========================================================================== bool FMultiBlockThingsIterator::Next(FMultiBlockThingsIterator::CheckResult *item) { AActor *thing = blockIterator.Next(); if (thing != NULL) { item->thing = thing; item->Position = checkpoint + Displacements.getOffset(basegroup, thing->Sector->PortalGroup); item->portalflags = portalflags; return true; } bool onlast = unsigned(index + 1) >= checklist.Size(); int nextflags = onlast ? 0 : checklist[index + 1] & FPortalGroupArray::FLAT; if (onlast) { return false; } index++; startIteratorForGroup(checklist[index] & ~FPortalGroupArray::FLAT); switch (nextflags) { case FPortalGroupArray::UPPER: portalflags = FFCF_NOFLOOR; break; case FPortalGroupArray::LOWER: portalflags = FFCF_NOCEILING; break; default: portalflags = 0; } return Next(item); } //=========================================================================== // // start iterating a new group // //=========================================================================== void FMultiBlockThingsIterator::startIteratorForGroup(int group) { DVector2 offset = Displacements.getOffset(basegroup, group); offset.X += checkpoint.X; offset.Y += checkpoint.Y; bbox.setBox(offset.X, offset.Y, checkpoint.Z); blockIterator.init(bbox); } //=========================================================================== // // Resets the iterator // //=========================================================================== void FMultiBlockThingsIterator::Reset() { index = -1; portalflags = 0; startIteratorForGroup(basegroup); } //=========================================================================== // // and the scriptable version // //=========================================================================== class DBlockThingsIterator : public DObject { DECLARE_ABSTRACT_CLASS(DBlockThingsIterator, DObject); FPortalGroupArray check; FMultiBlockThingsIterator iterator; public: FMultiBlockThingsIterator::CheckResult cres; bool Next() { return iterator.Next(&cres); } DBlockThingsIterator(AActor *origin, double checkradius = -1, bool ignorerestricted = false) : iterator(check, origin, checkradius, ignorerestricted) { cres.thing = nullptr; cres.Position.Zero(); cres.portalflags = 0; } DBlockThingsIterator(double checkx, double checky, double checkz, double checkh, double checkradius, bool ignorerestricted, sector_t *newsec) : iterator(check, checkx, checky, checkz, checkh, checkradius, ignorerestricted, newsec) { cres.thing = nullptr; cres.Position.Zero(); cres.portalflags = 0; } }; IMPLEMENT_CLASS(DBlockThingsIterator, true, false); DEFINE_ACTION_FUNCTION(DBlockThingsIterator, Create) { PARAM_PROLOGUE; PARAM_OBJECT_NOT_NULL(origin, AActor); PARAM_FLOAT_DEF(radius); PARAM_BOOL_DEF(ignore); ACTION_RETURN_OBJECT(Create(origin, radius, ignore)); } DEFINE_ACTION_FUNCTION(DBlockThingsIterator, CreateFromPos) { PARAM_PROLOGUE; PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_FLOAT(h); PARAM_FLOAT(radius); PARAM_BOOL(ignore); ACTION_RETURN_OBJECT(Create(x, y, z, h, radius, ignore, nullptr)); } DEFINE_ACTION_FUNCTION(DBlockThingsIterator, Next) { PARAM_SELF_PROLOGUE(DBlockThingsIterator); ACTION_RETURN_BOOL(self->Next()); } DEFINE_FIELD_NAMED(DBlockThingsIterator, cres.thing, thing); DEFINE_FIELD_NAMED(DBlockThingsIterator, cres.Position, position); DEFINE_FIELD_NAMED(DBlockThingsIterator, cres.portalflags, portalflags); //=========================================================================== // // FPathTraverse :: Intercepts // //=========================================================================== TArray FPathTraverse::intercepts(128); //=========================================================================== // // FPathTraverse :: AddLineIntercepts. // Looks for lines in the given block // that intercept the given trace // to add to the intercepts list. // // A line is crossed if its endpoints // are on opposite sides of the trace. // //=========================================================================== void FPathTraverse::AddLineIntercepts(int bx, int by) { FBlockLinesIterator it(bx, by, bx, by, true); line_t *ld; while ((ld = it.Next())) { int s1; int s2; double frac; divline_t dl; s1 = P_PointOnDivlineSide (ld->v1->fX(), ld->v1->fY(), &trace); s2 = P_PointOnDivlineSide (ld->v2->fX(), ld->v2->fY(), &trace); if (s1 == s2) continue; // line isn't crossed // hit the line P_MakeDivline (ld, &dl); frac = P_InterceptVector (&trace, &dl); if (frac < Startfrac || frac > 1.) continue; // behind source or beyond end point intercept_t newintercept; newintercept.frac = frac; newintercept.isaline = true; newintercept.done = false; newintercept.d.line = ld; intercepts.Push (newintercept); } } //=========================================================================== // // FPathTraverse :: AddThingIntercepts // //=========================================================================== void FPathTraverse::AddThingIntercepts (int bx, int by, FBlockThingsIterator &it, bool compatible) { AActor *thing; it.SwitchBlock(bx, by); while ((thing = it.Next(compatible))) { int numfronts = 0; divline_t line; int i; if (!compatible) { // [RH] Don't check a corner to corner crossection for hit. // Instead, check against the actual bounding box (but not if compatibility optioned.) // There's probably a smarter way to determine which two sides // of the thing face the trace than by trying all four sides... for (i = 0; i < 4; ++i) { switch (i) { case 0: // Top edge line.y = thing->Y() + thing->radius; if (trace.y < line.y) continue; line.x = thing->X() + thing->radius; line.dx = -thing->radius * 2; line.dy = 0; break; case 1: // Right edge line.x = thing->X() + thing->radius; if (trace.x < line.x) continue; line.y = thing->Y() - thing->radius; line.dx = 0; line.dy = thing->radius * 2; break; case 2: // Bottom edge line.y = thing->Y() - thing->radius; if (trace.y > line.y) continue; line.x = thing->X() - thing->radius; line.dx = thing->radius * 2; line.dy = 0; break; case 3: // Left edge line.x = thing->X() - thing->radius; if (trace.x > line.x) continue; line.y = thing->Y() + thing->radius; line.dx = 0; line.dy = thing->radius * -2; break; } // Check if this side is facing the trace origin numfronts++; // If it is, see if the trace crosses it if (P_PointOnDivlineSide (line.x, line.y, &trace) != P_PointOnDivlineSide (line.x + line.dx, line.y + line.dy, &trace)) { // It's a hit double frac = P_InterceptVector (&trace, &line); if (frac < Startfrac) { // behind source if (Startfrac > 0) { // check if the trace starts within this actor switch (i) { case 0: line.y -= 2 * thing->radius; break; case 1: line.x -= 2 * thing->radius; break; case 2: line.y += 2 * thing->radius; break; case 3: line.x += 2 * thing->radius; break; } double frac2 = P_InterceptVector(&trace, &line); if (frac2 >= Startfrac) goto addit; } continue; } addit: intercept_t newintercept; newintercept.frac = frac; newintercept.isaline = false; newintercept.done = false; newintercept.d.thing = thing; intercepts.Push (newintercept); break; } } // If none of the sides was facing the trace, then the trace // must have started inside the box, so add it as an intercept. if (numfronts == 0) { intercept_t newintercept; newintercept.frac = 0; newintercept.isaline = false; newintercept.done = false; newintercept.d.thing = thing; intercepts.Push (newintercept); } } else { // Old code for compatibility purposes double x1, y1, x2, y2; int s1, s2; divline_t dl; double frac; bool tracepositive = (trace.dx * trace.dy)>0; // check a corner to corner crossection for hit if (tracepositive) { x1 = thing->X() - thing->radius; y1 = thing->Y() + thing->radius; x2 = thing->X() + thing->radius; y2 = thing->Y() - thing->radius; } else { x1 = thing->X() - thing->radius; y1 = thing->Y() - thing->radius; x2 = thing->X() + thing->radius; y2 = thing->Y() + thing->radius; } s1 = P_PointOnDivlineSide (x1, y1, &trace); s2 = P_PointOnDivlineSide (x2, y2, &trace); if (s1 != s2) { dl.x = x1; dl.y = y1; dl.dx = x2-x1; dl.dy = y2-y1; frac = P_InterceptVector (&trace, &dl); if (frac >= Startfrac) { intercept_t newintercept; newintercept.frac = frac; newintercept.isaline = false; newintercept.done = false; newintercept.d.thing = thing; intercepts.Push (newintercept); } } } } } //=========================================================================== // // FPathTraverse :: Next // //=========================================================================== intercept_t *FPathTraverse::Next() { intercept_t *in = NULL; double dist = FLT_MAX; for (unsigned scanpos = intercept_index; scanpos < intercepts.Size (); scanpos++) { intercept_t *scan = &intercepts[scanpos]; if (scan->frac < dist && !scan->done) { dist = scan->frac; in = scan; } } if (dist > 1. || in == NULL) return NULL; // checked everything in range in->done = true; return in; } //=========================================================================== // // FPathTraverse // Traces a line from x1,y1 to x2,y2, // //=========================================================================== void FPathTraverse::init(double x1, double y1, double x2, double y2, int flags, double startfrac) { double xt1, yt1, xt2, yt2; double xstep, ystep; double partialx, partialy; double xintercept, yintercept; int mapx; int mapy; int mapxstep; int mapystep; int count; trace.x = x1; trace.y = y1; if (flags & PT_DELTA) { trace.dx = x2; trace.dy = y2; } else { trace.dx = x2 - x1; trace.dy = y2 - y1; } if (startfrac > 0) { double startdx = trace.dx * startfrac; double startdy = trace.dy * startfrac; x1 += startdx; y1 += startdy; x2 = trace.dx - startdx; y2 = trace.dy - startdy; flags |= PT_DELTA; } validcount++; intercept_index = intercepts.Size(); Startfrac = startfrac; if (flags & PT_DELTA) { x2 += x1; y2 += y1; } x1 -= level.blockmap.bmaporgx; y1 -= level.blockmap.bmaporgy; xt1 = x1 / FBlockmap::MAPBLOCKUNITS; yt1 = y1 / FBlockmap::MAPBLOCKUNITS; x2 -= level.blockmap.bmaporgx; y2 -= level.blockmap.bmaporgy; xt2 = x2 / FBlockmap::MAPBLOCKUNITS; yt2 = y2 / FBlockmap::MAPBLOCKUNITS; mapx = xs_FloorToInt(xt1); mapy = xs_FloorToInt(yt1); int mapex = xs_FloorToInt(xt2); int mapey = xs_FloorToInt(yt2); if (mapex > mapx) { mapxstep = 1; partialx = 1. - xt1 + xs_FloorToInt(xt1); ystep = (y2 - y1) / fabs(x2 - x1); } else if (mapex < mapx) { mapxstep = -1; partialx = xt1 - xs_FloorToInt(xt1); ystep = (y2 - y1) / fabs(x2 - x1); } else { mapxstep = 0; partialx = 1.; ystep = 256; } yintercept = yt1 + partialx * ystep; if (mapey > mapy) { mapystep = 1; partialy = 1. - yt1 + xs_FloorToInt(yt1); xstep = (x2 - x1) / fabs(y2 - y1); } else if (mapey < mapy) { mapystep = -1; partialy = yt1 - xs_FloorToInt(yt1); xstep = (x2 - x1) / fabs(y2 - y1); } else { mapystep = 0; partialy = 1; xstep = 256; } xintercept = xt1 + partialy * xstep; // [RH] Fix for traces that pass only through blockmap corners. In that case, // xintercept and yintercept can both be set ahead of mapx and mapy, so the // for loop would never advance anywhere. if (fabs(xstep) == 1. && fabs(ystep) == 1.) { if (ystep < 0) { partialx = 1. - partialx; } if (xstep < 0) { partialy = 1. - partialy; } if (partialx == partialy) { xintercept = xt1; yintercept = yt1; } } // Step through map blocks. // Count is present to prevent a round off error // from skipping the break statement. bool compatible = (flags & PT_COMPATIBLE) && (i_compatflags & COMPATF_HITSCAN); // we want to use one list of checked actors for the entire operation FBlockThingsIterator btit; for (count = 0 ; count < 1000 ; count++) { if (flags & PT_ADDLINES) { AddLineIntercepts(mapx, mapy); } if (flags & PT_ADDTHINGS) { AddThingIntercepts(mapx, mapy, btit, compatible); } // both coordinates reached the end, so end the traversing. if ((mapxstep | mapystep) == 0) break; // [RH] Handle corner cases properly instead of pretending they don't exist. switch (((xs_FloorToInt(yintercept) == mapy) << 1) | (xs_FloorToInt(xintercept) == mapx)) { case 0: // neither xintercept nor yintercept match! count = 1000; // Stop traversing, because somebody screwed up. break; case 1: // xintercept matches xintercept += xstep; mapy += mapystep; if (mapy == mapey) mapystep = 0; break; case 2: // yintercept matches yintercept += ystep; mapx += mapxstep; if (mapx == mapex) mapxstep = 0; break; case 3: // xintercept and yintercept both match // The trace is exiting a block through its corner. Not only does the block // being entered need to be checked (which will happen when this loop // continues), but the other two blocks adjacent to the corner also need to // be checked. // Since Doom.exe did not do this, this code won't either if run in compatibility mode. if (!compatible) { if (flags & PT_ADDLINES) { AddLineIntercepts(mapx + mapxstep, mapy); AddLineIntercepts(mapx, mapy + mapystep); } if (flags & PT_ADDTHINGS) { AddThingIntercepts(mapx + mapxstep, mapy, btit, false); AddThingIntercepts(mapx, mapy + mapystep, btit, false); } xintercept += xstep; yintercept += ystep; mapx += mapxstep; mapy += mapystep; if (mapx == mapex) mapxstep = 0; if (mapy == mapey) mapystep = 0; } else { count = 1000; // Doom originally did not handle this case so do the same in compatibility mode. } break; } } } //=========================================================================== // // Relocates the trace when going through a line portal // //=========================================================================== int FPathTraverse::PortalRelocate(intercept_t *in, int flags, DVector3 *optpos) { if (!in->isaline || !in->d.line->isLinePortal()) return false; if (P_PointOnLineSidePrecise(trace.x, trace.y, in->d.line) == 1) return false; double hitx = trace.x; double hity = trace.y; double endx = trace.x + trace.dx; double endy = trace.y + trace.dy; P_TranslatePortalXY(in->d.line, hitx, hity); P_TranslatePortalXY(in->d.line, endx, endy); if (optpos != NULL) { P_TranslatePortalXY(in->d.line, optpos->X, optpos->Y); P_TranslatePortalZ(in->d.line, optpos->Z); } line_t *saved = in->d.line; // this gets overwritten by the init call. intercepts.Resize(intercept_index); init(hitx, hity, endx, endy, flags, in->frac + EQUAL_EPSILON); return saved->getPortal()->mType == PORTT_LINKED? 1:-1; } void FPathTraverse::PortalRelocate(const DVector2 &displacement, int flags, double hitfrac) { double hitx = trace.x + displacement.X; double hity = trace.y + displacement.Y; double endx = hitx + trace.dx; double endy = hity + trace.dy; intercepts.Resize(intercept_index); init(hitx, hity, endx, endy, flags, hitfrac); } //=========================================================================== // // // //=========================================================================== FPathTraverse::~FPathTraverse() { intercepts.Resize(intercept_index); } //=========================================================================== // // P_RoughMonsterSearch // // Searches though the surrounding mapblocks for monsters/players // distance is in FBlockmap::MAPBLOCKUNITS //=========================================================================== AActor *P_BlockmapSearch (AActor *mo, int distance, AActor *(*check)(AActor*, int, void *), void *params) { int blockX; int blockY; int startX, startY; int blockIndex; int firstStop; int secondStop; int thirdStop; int finalStop; int count; AActor *target; int bmapwidth = level.blockmap.bmapwidth; int bmapheight = level.blockmap.bmapheight; startX = level.blockmap.GetBlockX(mo->X()); startY = level.blockmap.GetBlockY(mo->Y()); validcount++; if (level.blockmap.isValidBlock(startX, startY)) { if ( (target = check (mo, startY*bmapwidth+startX, params)) ) { // found a target right away return target; } } for (count = 1; count <= distance; count++) { blockX = clamp (startX-count, 0, bmapwidth-1); blockY = clamp (startY-count, 0, bmapheight-1); blockIndex = blockY*bmapwidth+blockX; firstStop = startX+count; if (firstStop < 0) { continue; } if (firstStop >= bmapwidth) { firstStop = bmapwidth-1; } secondStop = startY+count; if (secondStop < 0) { continue; } if (secondStop >= bmapheight) { secondStop = bmapheight-1; } thirdStop = secondStop*bmapwidth+blockX; secondStop = secondStop*bmapwidth+firstStop; firstStop += blockY*bmapwidth; finalStop = blockIndex; // Trace the first block section (along the top) for (; blockIndex <= firstStop; blockIndex++) { if ( (target = check (mo, blockIndex, params)) ) { return target; } } // Trace the second block section (right edge) for (blockIndex--; blockIndex <= secondStop; blockIndex += bmapwidth) { if ( (target = check (mo, blockIndex, params)) ) { return target; } } // Trace the third block section (bottom edge) for (blockIndex -= bmapwidth; blockIndex >= thirdStop; blockIndex--) { if ( (target = check (mo, blockIndex, params)) ) { return target; } } // Trace the final block section (left edge) for (blockIndex++; blockIndex > finalStop; blockIndex -= bmapwidth) { if ( (target = check (mo, blockIndex, params)) ) { return target; } } } return NULL; } struct BlockCheckInfo { bool onlyseekable; bool frontonly; divline_t frontline; }; //=========================================================================== // // RoughBlockCheck // //=========================================================================== static AActor *RoughBlockCheck (AActor *mo, int index, void *param) { BlockCheckInfo *info = (BlockCheckInfo *)param; FBlockNode *link; for (link = level.blockmap.blocklinks[index]; link != NULL; link = link->NextActor) { if (link->Me != mo) { if (info->onlyseekable && !mo->CanSeek(link->Me)) { continue; } if (info->frontonly && P_PointOnDivlineSide(link->Me->X(), link->Me->Y(), &info->frontline) != 0) { continue; } if (mo->IsOkayToAttack (link->Me)) { return link->Me; } } } return NULL; } AActor *P_RoughMonsterSearch(AActor *mo, int distance, bool onlyseekable, bool frontonly) { BlockCheckInfo info; info.onlyseekable = onlyseekable; if ((info.frontonly = frontonly)) { info.frontline.x = mo->X(); info.frontline.y = mo->Y(); info.frontline.dx = -mo->Angles.Yaw.Sin(); info.frontline.dy = -mo->Angles.Yaw.Cos(); } return P_BlockmapSearch(mo, distance, RoughBlockCheck, (void *)&info); } DEFINE_ACTION_FUNCTION(AActor, RoughMonsterSearch) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(distance); PARAM_BOOL_DEF(onlyseekable); PARAM_BOOL_DEF(frontonly); ACTION_RETURN_OBJECT(P_RoughMonsterSearch(self, distance, onlyseekable, frontonly)); } //========================================================================== // // [RH] LinkToWorldForMapThing // // Emulate buggy PointOnLineSide and fix actors that lie on // lines to compensate for some IWAD maps. // //========================================================================== static int R_PointOnSideSlow(double xx, double yy, node_t *node) { // [RH] This might have been faster than two multiplies and an // add on a 386/486, but it certainly isn't on anything newer than that. auto x = FloatToFixed(xx); auto y = FloatToFixed(yy); double left; double right; if (!node->dx) { if (x <= node->x) return node->dy > 0; return node->dy < 0; } if (!node->dy) { if (y <= node->y) return node->dx < 0; return node->dx > 0; } auto dx = (x - node->x); auto dy = (y - node->y); // Try to quickly decide by looking at sign bits. if ((node->dy ^ node->dx ^ dx ^ dy) & 0x80000000) { if ((node->dy ^ dx) & 0x80000000) { // (left is negative) return 1; } return 0; } // we must use doubles here because the fixed point code will produce errors due to loss of precision for extremely short linedefs. // Note that this function is used for all map spawned actors and not just a compatibility fallback! left = (double)node->dy * (double)dx; right = (double)dy * (double)node->dx; if (right < left) { // front side return 0; } // back side return 1; } //=========================================================================== // // P_VanillaPointOnLineSide // P_PointOnLineSide() from the initial Doom source code release // //=========================================================================== int P_VanillaPointOnLineSide(double x, double y, const line_t* line) { DVector2 delta = line->Delta(); if (delta.X == 0) { if (x <= line->v1->fX()) return delta.Y > 0; return delta.Y < 0; } if (delta.Y == 0) { if (y <= line->v1->fY()) return delta.X < 0; return delta.X > 0; } // Note: This cannot really be converted to floating point // without breaking the intended use of this function // (i.e. to emulate the horrible imprecision of the entire method) auto dx = FloatToFixed(x - line->v1->fX()); auto dy = FloatToFixed(y - line->v1->fY()); auto left = FixedMul( int(delta.Y * 256) , dx ); auto right = FixedMul( dy , int(delta.X * 256) ); if (right < left) return 0; // front side return 1; // back side } //========================================================================== // // P_PointInSubsector // //========================================================================== subsector_t *P_PointInSubsector(double x, double y) { int side; auto node = level.HeadGamenode(); if (node == nullptr) return &level.subsectors[0]; fixed_t xx = FLOAT2FIXED(x); fixed_t yy = FLOAT2FIXED(y); do { side = R_PointOnSide(xx, yy, node); node = (node_t *)node->children[side]; } while (!((size_t)node & 1)); return (subsector_t *)((uint8_t *)node - 1); } //========================================================================== // // Use buggy PointOnSide and fix actors that lie on // lines to compensate for some IWAD maps. // //========================================================================== sector_t *P_PointInSectorBuggy(double x, double y) { // single subsector is a special case auto node = level.HeadGamenode(); if (node == nullptr) return level.subsectors[0].sector; do { // Use original buggy point-on-side test when spawning // things at level load so that the map spots in the // emerald key room of Hexen MAP01 are spawned on the // window ledge instead of the blocking floor in front // of it. Why do I consider it buggy? Because a point // that lies directly on a line should always be // considered as "in front" of the line. The orientation // of the line should be irrelevant. node = (node_t *)node->children[R_PointOnSideSlow(x, y, node)]; } while (!((size_t)node & 1)); subsector_t *ssec = (subsector_t *)((uint8_t *)node - 1); return ssec->sector; }