gzdoom/src/po_man.cpp

2289 lines
53 KiB
C++
Raw Normal View History

//**************************************************************************
//**
//** PO_MAN.C : Heretic 2 : Raven Software, Corp.
//**
//** $RCSfile: po_man.c,v $
//** $Revision: 1.22 $
//** $Date: 95/09/28 18:20:56 $
//** $Author: cjr $
//**
//**************************************************************************
// HEADER FILES ------------------------------------------------------------
#include "doomdef.h"
#include "p_local.h"
#include "r_local.h"
#include "i_system.h"
#include "w_wad.h"
#include "m_swap.h"
#include "m_bbox.h"
#include "tables.h"
#include "s_sndseq.h"
#include "a_sharedglobal.h"
#include "r_main.h"
#include "p_lnspec.h"
#include "r_interpolate.h"
#include "g_level.h"
#include "po_man.h"
#include "p_setup.h"
#include "vectors.h"
// MACROS ------------------------------------------------------------------
#define PO_MAXPOLYSEGS 64
// TYPES -------------------------------------------------------------------
inline vertex_t *side_t::V1() const
{
return this == linedef->sidedef[0]? linedef->v1 : linedef->v2;
}
inline vertex_t *side_t::V2() const
{
return this == linedef->sidedef[0]? linedef->v2 : linedef->v1;
}
inline FArchive &operator<< (FArchive &arc, podoortype_t &type)
{
BYTE val = (BYTE)type;
arc << val;
type = (podoortype_t)val;
return arc;
}
class DPolyAction : public DThinker
{
DECLARE_CLASS (DPolyAction, DThinker)
HAS_OBJECT_POINTERS
public:
DPolyAction (int polyNum);
void Serialize (FArchive &arc);
void Destroy();
void Stop();
int GetSpeed() const { return m_Speed; }
void StopInterpolation ();
protected:
DPolyAction ();
int m_PolyObj;
int m_Speed;
int m_Dist;
TObjPtr<DInterpolation> m_Interpolation;
void SetInterpolation ();
};
class DRotatePoly : public DPolyAction
{
DECLARE_CLASS (DRotatePoly, DPolyAction)
public:
DRotatePoly (int polyNum);
void Tick ();
private:
DRotatePoly ();
friend bool EV_RotatePoly (line_t *line, int polyNum, int speed, int byteAngle, int direction, bool overRide);
};
class DMovePoly : public DPolyAction
{
DECLARE_CLASS (DMovePoly, DPolyAction)
public:
DMovePoly (int polyNum);
void Serialize (FArchive &arc);
void Tick ();
protected:
DMovePoly ();
int m_Angle;
fixed_t m_xSpeed; // for sliding walls
fixed_t m_ySpeed;
friend bool EV_MovePoly (line_t *line, int polyNum, int speed, angle_t angle, fixed_t dist, bool overRide);
};
class DMovePolyTo : public DPolyAction
{
DECLARE_CLASS(DMovePolyTo, DPolyAction)
public:
DMovePolyTo(int polyNum);
void Serialize(FArchive &arc);
void Tick();
protected:
DMovePolyTo();
fixed_t m_xSpeed;
fixed_t m_ySpeed;
fixed_t m_xTarget;
fixed_t m_yTarget;
friend bool EV_MovePolyTo(line_t *line, int polyNum, int speed, fixed_t x, fixed_t y, bool overRide);
};
class DPolyDoor : public DMovePoly
{
DECLARE_CLASS (DPolyDoor, DMovePoly)
public:
DPolyDoor (int polyNum, podoortype_t type);
void Serialize (FArchive &arc);
void Tick ();
protected:
int m_Direction;
int m_TotalDist;
int m_Tics;
int m_WaitTics;
podoortype_t m_Type;
bool m_Close;
friend bool EV_OpenPolyDoor (line_t *line, int polyNum, int speed, angle_t angle, int delay, int distance, podoortype_t type);
private:
DPolyDoor ();
};
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
void PO_Init (void);
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
static void RotatePt (int an, fixed_t *x, fixed_t *y, fixed_t startSpotX,
fixed_t startSpotY);
static void UnLinkPolyobj (FPolyObj *po);
static void LinkPolyobj (FPolyObj *po);
static bool CheckMobjBlocking (side_t *seg, FPolyObj *po);
static void InitBlockMap (void);
static void IterFindPolySides (FPolyObj *po, side_t *side);
static void SpawnPolyobj (int index, int tag, int type);
static void TranslateToStartSpot (int tag, int originX, int originY);
static void DoMovePolyobj (FPolyObj *po, int x, int y);
static void InitSegLists ();
static void KillSegLists ();
static FPolyNode *NewPolyNode();
static void FreePolyNode();
static void ReleaseAllPolyNodes();
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
extern seg_t *segs;
// PUBLIC DATA DEFINITIONS -------------------------------------------------
polyblock_t **PolyBlockMap;
FPolyObj *polyobjs; // list of all poly-objects on the level
int po_NumPolyobjs;
polyspawns_t *polyspawns; // [RH] Let P_SpawnMapThings() find our thingies for us
// PRIVATE DATA DEFINITIONS ------------------------------------------------
static TArray<SDWORD> KnownPolySides;
static FPolyNode *FreePolyNodes;
// CODE --------------------------------------------------------------------
//==========================================================================
//
//
//
//==========================================================================
IMPLEMENT_POINTY_CLASS (DPolyAction)
DECLARE_POINTER(m_Interpolation)
END_POINTERS
DPolyAction::DPolyAction ()
{
}
void DPolyAction::Serialize (FArchive &arc)
{
Super::Serialize (arc);
arc << m_PolyObj << m_Speed << m_Dist << m_Interpolation;
}
DPolyAction::DPolyAction (int polyNum)
{
m_PolyObj = polyNum;
m_Speed = 0;
m_Dist = 0;
SetInterpolation ();
}
void DPolyAction::Destroy()
{
FPolyObj *poly = PO_GetPolyobj (m_PolyObj);
if (poly->specialdata == this)
{
poly->specialdata = NULL;
}
StopInterpolation();
Super::Destroy();
}
void DPolyAction::Stop()
{
FPolyObj *poly = PO_GetPolyobj(m_PolyObj);
SN_StopSequence(poly);
Destroy();
}
void DPolyAction::SetInterpolation ()
{
FPolyObj *poly = PO_GetPolyobj (m_PolyObj);
m_Interpolation = poly->SetInterpolation();
}
void DPolyAction::StopInterpolation ()
{
if (m_Interpolation != NULL)
{
m_Interpolation->DelRef();
m_Interpolation = NULL;
}
}
//==========================================================================
//
//
//
//==========================================================================
IMPLEMENT_CLASS (DRotatePoly)
DRotatePoly::DRotatePoly ()
{
}
DRotatePoly::DRotatePoly (int polyNum)
: Super (polyNum)
{
}
//==========================================================================
//
//
//
//==========================================================================
IMPLEMENT_CLASS (DMovePoly)
DMovePoly::DMovePoly ()
{
}
void DMovePoly::Serialize (FArchive &arc)
{
Super::Serialize (arc);
arc << m_Angle << m_xSpeed << m_ySpeed;
}
DMovePoly::DMovePoly (int polyNum)
: Super (polyNum)
{
m_Angle = 0;
m_xSpeed = 0;
m_ySpeed = 0;
}
//==========================================================================
//
//
//
//
//==========================================================================
IMPLEMENT_CLASS(DMovePolyTo)
DMovePolyTo::DMovePolyTo()
{
}
void DMovePolyTo::Serialize(FArchive &arc)
{
Super::Serialize(arc);
arc << m_xSpeed << m_ySpeed << m_xTarget << m_yTarget;
}
DMovePolyTo::DMovePolyTo(int polyNum)
: Super(polyNum)
{
m_xSpeed = 0;
m_ySpeed = 0;
m_xTarget = 0;
m_yTarget = 0;
}
//==========================================================================
//
//
//
//==========================================================================
IMPLEMENT_CLASS (DPolyDoor)
DPolyDoor::DPolyDoor ()
{
}
void DPolyDoor::Serialize (FArchive &arc)
{
Super::Serialize (arc);
arc << m_Direction << m_TotalDist << m_Tics << m_WaitTics << m_Type << m_Close;
}
DPolyDoor::DPolyDoor (int polyNum, podoortype_t type)
: Super (polyNum), m_Type (type)
{
m_Direction = 0;
m_TotalDist = 0;
m_Tics = 0;
m_WaitTics = 0;
m_Close = false;
}
// ===== Polyobj Event Code =====
//==========================================================================
//
// T_RotatePoly
//
//==========================================================================
void DRotatePoly::Tick ()
{
FPolyObj *poly = PO_GetPolyobj (m_PolyObj);
if (poly == NULL) return;
if (poly->RotatePolyobj (m_Speed))
{
unsigned int absSpeed = abs (m_Speed);
2006-04-11 16:27:41 +00:00
if (m_Dist == -1)
{ // perpetual polyobj
return;
}
m_Dist -= absSpeed;
May 6, 2006 (Changes by Graf Zahl) - Converted a_zombie.cpp and most of a_strifestuff.cpp to DECORATE. - Converted a_strifekeys.cpp to DECORATE and moved the pickup messages to the string table. - Removed the WIF_HITS_GHOSTS weapon flag and replaced it with MF2_THRUGHOST. There is no need to keep two flags around with virtually the same meaning. - Changed the ShadowArmor to use the VISIBILITYPULSE flag to change its translucency. It looks much better now than the cheap code pointer based blinking it used before. - Converted most of a_strifeitems.cpp to DECORATE and moved the pickup messages to the string table. - Converted a_strifearmor.cpp to DECORATE and moved the pickup messages to the string table. - Moved the messages for killing spectres to the string table. - Converted the quest items to DECORATE. Also changed A_GiveQuestItem to get the messages it prints from the string table instead of the quest item's tag string. May 5, 2006 (Changes by Graf Zahl) - Removed the hopelessly outdated thingdef_doc.txt file from the repository. - Converted a_peasant.cpp and a_ratbuddy.cpp to DECORATE. - Fixed: C_DoKey didn't treat an empty string as 'no binding' when checking for valid double bindings. - Converted a_merchants.cpp to DECORATE. - Added MF5_NODAMAGE flag to generalize the behavior of Strife's merchants which can be shot but take no damage from getting hurt. - Converted a_beggars.cpp to DECORATE. - Added an Inventory.GiveQuest property. This makes it possible to define all of Strife's original items that also give a quest item in DECORATE but it is also useful to define items like the ones in Day of the Acolyte without ugly workarounds. - Added a Tag property and Strife teaser conversation IDs to DECORATE so now it is possible to define many of Strife's items. - Added a FastSpeed property to DECORATE so that projectiles can finally be assigned a higher speed for fast mode. - Added a ACS_LockedExecuteDoor special. It is basically the same as the existing ACS_LockedExecute but it uses the 'door' message instead of 'remote'. This cannot be integrated into ACS_LockedExecute because all its arguments are already in use. - Added a fully customizable A_CustomMeleeAttack function for DECORATE. SVN r83 (trunk)
2006-05-07 00:27:22 +00:00
if (m_Dist == 0)
{
SN_StopSequence (poly);
Destroy ();
}
else if ((unsigned int)m_Dist < absSpeed)
{
m_Speed = m_Dist * (m_Speed < 0 ? -1 : 1);
}
}
}
//==========================================================================
//
// EV_RotatePoly
//
//==========================================================================
bool EV_RotatePoly (line_t *line, int polyNum, int speed, int byteAngle,
int direction, bool overRide)
{
int mirror;
DRotatePoly *pe;
FPolyObj *poly;
if ( (poly = PO_GetPolyobj(polyNum)) )
{
if (poly->specialdata && !overRide)
{ // poly is already moving
return false;
}
}
else
{
Printf("EV_RotatePoly: Invalid polyobj num: %d\n", polyNum);
return false;
}
pe = new DRotatePoly (polyNum);
if (byteAngle)
{
if (byteAngle == 255)
{
pe->m_Dist = ~0;
}
else
{
pe->m_Dist = byteAngle*(ANGLE_90/64); // Angle
}
}
else
{
pe->m_Dist = ANGLE_MAX-1;
}
pe->m_Speed = (speed*direction*(ANGLE_90/64))>>3;
poly->specialdata = pe;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
while ( (mirror = poly->GetMirror()) )
{
poly = PO_GetPolyobj(mirror);
if (poly == NULL)
{
Printf ("EV_RotatePoly: Invalid polyobj num: %d\n", polyNum);
break;
}
if (poly && poly->specialdata && !overRide)
{ // mirroring poly is already in motion
break;
}
pe = new DRotatePoly (mirror);
poly->specialdata = pe;
if (byteAngle)
{
if (byteAngle == 255)
{
pe->m_Dist = ~0;
}
else
{
pe->m_Dist = byteAngle*(ANGLE_90/64); // Angle
}
}
else
{
pe->m_Dist = ANGLE_MAX-1;
}
direction = -direction;
pe->m_Speed = (speed*direction*(ANGLE_90/64))>>3;
polyNum = mirror;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
return true;
}
//==========================================================================
//
// T_MovePoly
//
//==========================================================================
void DMovePoly::Tick ()
{
FPolyObj *poly = PO_GetPolyobj (m_PolyObj);
if (poly != NULL)
{
if (poly->MovePolyobj (m_xSpeed, m_ySpeed))
{
int absSpeed = abs (m_Speed);
m_Dist -= absSpeed;
if (m_Dist <= 0)
{
SN_StopSequence (poly);
Destroy ();
}
else if (m_Dist < absSpeed)
{
m_Speed = m_Dist * (m_Speed < 0 ? -1 : 1);
m_xSpeed = FixedMul (m_Speed, finecosine[m_Angle]);
m_ySpeed = FixedMul (m_Speed, finesine[m_Angle]);
}
}
}
}
//==========================================================================
//
// EV_MovePoly
//
//==========================================================================
bool EV_MovePoly (line_t *line, int polyNum, int speed, angle_t angle,
fixed_t dist, bool overRide)
{
int mirror;
DMovePoly *pe;
FPolyObj *poly;
angle_t an;
if ( (poly = PO_GetPolyobj(polyNum)) )
{
if (poly->specialdata && !overRide)
{ // poly is already moving
return false;
}
}
else
{
Printf("EV_MovePoly: Invalid polyobj num: %d\n", polyNum);
return false;
}
pe = new DMovePoly (polyNum);
pe->m_Dist = dist; // Distance
pe->m_Speed = speed;
poly->specialdata = pe;
an = angle;
pe->m_Angle = an>>ANGLETOFINESHIFT;
pe->m_xSpeed = FixedMul (pe->m_Speed, finecosine[pe->m_Angle]);
pe->m_ySpeed = FixedMul (pe->m_Speed, finesine[pe->m_Angle]);
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
// Do not interpolate very fast moving polyobjects. The minimum tic count is
// 3 instead of 2, because the moving crate effect in Massmouth 2, Hostitality
// that this fixes isn't quite fast enough to move the crate back to its start
// in just 1 tic.
if (dist/speed <= 2)
{
pe->StopInterpolation ();
}
while ( (mirror = poly->GetMirror()) )
{
poly = PO_GetPolyobj(mirror);
if (poly && poly->specialdata && !overRide)
{ // mirroring poly is already in motion
break;
}
pe = new DMovePoly (mirror);
poly->specialdata = pe;
pe->m_Dist = dist; // Distance
pe->m_Speed = speed;
an = an+ANGLE_180; // reverse the angle
pe->m_Angle = an>>ANGLETOFINESHIFT;
pe->m_xSpeed = FixedMul (pe->m_Speed, finecosine[pe->m_Angle]);
pe->m_ySpeed = FixedMul (pe->m_Speed, finesine[pe->m_Angle]);
polyNum = mirror;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
if (dist/speed <= 2)
{
pe->StopInterpolation ();
}
}
return true;
}
//==========================================================================
//
// DMovePolyTo :: Tick
//
//==========================================================================
void DMovePolyTo::Tick ()
{
FPolyObj *poly = PO_GetPolyobj (m_PolyObj);
if (poly != NULL)
{
if (poly->MovePolyobj (m_xSpeed, m_ySpeed))
{
int absSpeed = abs (m_Speed);
m_Dist -= absSpeed;
if (m_Dist <= 0)
{
SN_StopSequence (poly);
Destroy ();
}
else if (m_Dist < absSpeed)
{
m_Speed = m_Dist * (m_Speed < 0 ? -1 : 1);
m_xSpeed = m_xTarget - poly->StartSpot.x;
m_ySpeed = m_yTarget - poly->StartSpot.y;
}
}
}
}
//==========================================================================
//
// EV_MovePolyTo
//
//==========================================================================
bool EV_MovePolyTo(line_t *line, int polyNum, int speed, fixed_t targx, fixed_t targy, bool overRide)
{
int mirror;
DMovePolyTo *pe;
FPolyObj *poly;
TVector2<double> dist;
double distlen;
bool nointerp;
if ( (poly = PO_GetPolyobj(polyNum)) )
{
if (poly->specialdata && !overRide)
{ // poly is already moving
return false;
}
}
else
{
Printf("EV_MovePolyTo: Invalid polyobj num: %d\n", polyNum);
return false;
}
dist.X = targx - poly->StartSpot.x;
dist.Y = targy - poly->StartSpot.y;
pe = new DMovePolyTo(polyNum);
poly->specialdata = pe;
pe->m_Dist = xs_RoundToInt(distlen = dist.MakeUnit());
pe->m_Speed = speed;
pe->m_xSpeed = xs_RoundToInt(speed * dist.X);
pe->m_ySpeed = xs_RoundToInt(speed * dist.Y);
pe->m_xTarget = targx;
pe->m_yTarget = targy;
nointerp = (pe->m_Dist / pe->m_Speed) <= 2;
if (nointerp)
{
pe->StopInterpolation();
}
while ( (mirror = poly->GetMirror()) )
{
poly = PO_GetPolyobj(mirror);
if (poly && poly->specialdata && !overRide)
{ // mirroring poly is already in motion
break;
}
// reverse the direction
dist.X = -dist.X;
dist.Y = -dist.Y;
pe = new DMovePolyTo(mirror);
poly->specialdata = pe;
pe->m_Dist = xs_RoundToInt(distlen);
pe->m_Speed = speed;
pe->m_xSpeed = xs_RoundToInt(speed * dist.X);
pe->m_ySpeed = xs_RoundToInt(speed * dist.Y);
pe->m_xTarget = xs_RoundToInt(poly->StartSpot.x + distlen * dist.X);
pe->m_yTarget = xs_RoundToInt(poly->StartSpot.y + distlen * dist.Y);
polyNum = mirror;
SN_StartSequence(poly, poly->seqType, SEQ_DOOR, 0);
if (nointerp)
{
pe->StopInterpolation();
}
}
return true;
}
//==========================================================================
//
// T_PolyDoor
//
//==========================================================================
void DPolyDoor::Tick ()
{
int absSpeed;
FPolyObj *poly = PO_GetPolyobj (m_PolyObj);
if (poly == NULL) return;
if (m_Tics)
{
if (!--m_Tics)
{
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, m_Close);
}
return;
}
switch (m_Type)
{
case PODOOR_SLIDE:
if (m_Dist <= 0 || poly->MovePolyobj (m_xSpeed, m_ySpeed))
{
absSpeed = abs (m_Speed);
m_Dist -= absSpeed;
if (m_Dist <= 0)
{
SN_StopSequence (poly);
if (!m_Close)
{
m_Dist = m_TotalDist;
m_Close = true;
m_Tics = m_WaitTics;
m_Direction = (ANGLE_MAX>>ANGLETOFINESHIFT) - m_Direction;
m_xSpeed = -m_xSpeed;
m_ySpeed = -m_ySpeed;
}
else
{
Destroy ();
}
}
}
else
{
if (poly->crush || !m_Close)
{ // continue moving if the poly is a crusher, or is opening
return;
}
else
{ // open back up
m_Dist = m_TotalDist - m_Dist;
m_Direction = (ANGLE_MAX>>ANGLETOFINESHIFT)-
m_Direction;
m_xSpeed = -m_xSpeed;
m_ySpeed = -m_ySpeed;
m_Close = false;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
}
break;
case PODOOR_SWING:
if (poly->RotatePolyobj (m_Speed))
{
absSpeed = abs (m_Speed);
2006-04-11 16:27:41 +00:00
if (m_Dist == -1)
{ // perpetual polyobj
return;
}
m_Dist -= absSpeed;
if (m_Dist <= 0)
{
SN_StopSequence (poly);
if (!m_Close)
{
m_Dist = m_TotalDist;
m_Close = true;
m_Tics = m_WaitTics;
m_Speed = -m_Speed;
}
else
{
Destroy ();
}
}
}
else
{
if(poly->crush || !m_Close)
{ // continue moving if the poly is a crusher, or is opening
return;
}
else
{ // open back up and rewait
m_Dist = m_TotalDist - m_Dist;
m_Speed = -m_Speed;
m_Close = false;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
}
break;
default:
break;
}
}
//==========================================================================
//
// EV_OpenPolyDoor
//
//==========================================================================
bool EV_OpenPolyDoor (line_t *line, int polyNum, int speed, angle_t angle,
int delay, int distance, podoortype_t type)
{
int mirror;
DPolyDoor *pd;
FPolyObj *poly;
if( (poly = PO_GetPolyobj(polyNum)) )
{
if (poly->specialdata)
{ // poly is already moving
return false;
}
}
else
{
Printf("EV_OpenPolyDoor: Invalid polyobj num: %d\n", polyNum);
return false;
}
pd = new DPolyDoor (polyNum, type);
if (type == PODOOR_SLIDE)
{
pd->m_WaitTics = delay;
pd->m_Speed = speed;
pd->m_Dist = pd->m_TotalDist = distance; // Distance
pd->m_Direction = angle >> ANGLETOFINESHIFT;
pd->m_xSpeed = FixedMul (pd->m_Speed, finecosine[pd->m_Direction]);
pd->m_ySpeed = FixedMul (pd->m_Speed, finesine[pd->m_Direction]);
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
else if (type == PODOOR_SWING)
{
pd->m_WaitTics = delay;
pd->m_Direction = 1; // ADD: PODOOR_SWINGL, PODOOR_SWINGR
pd->m_Speed = (speed*pd->m_Direction*(ANGLE_90/64))>>3;
pd->m_Dist = pd->m_TotalDist = angle;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
poly->specialdata = pd;
while ( (mirror = poly->GetMirror()) )
{
poly = PO_GetPolyobj (mirror);
if (poly && poly->specialdata)
{ // mirroring poly is already in motion
break;
}
pd = new DPolyDoor (mirror, type);
poly->specialdata = pd;
if (type == PODOOR_SLIDE)
{
pd->m_WaitTics = delay;
pd->m_Speed = speed;
pd->m_Dist = pd->m_TotalDist = distance; // Distance
pd->m_Direction = (angle + ANGLE_180) >> ANGLETOFINESHIFT; // reverse the angle
pd->m_xSpeed = FixedMul (pd->m_Speed, finecosine[pd->m_Direction]);
pd->m_ySpeed = FixedMul (pd->m_Speed, finesine[pd->m_Direction]);
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
else if (type == PODOOR_SWING)
{
pd->m_WaitTics = delay;
pd->m_Direction = -1; // ADD: same as above
pd->m_Speed = (speed*pd->m_Direction*(ANGLE_90/64))>>3;
pd->m_Dist = pd->m_TotalDist = angle;
- Fixed compilation with mingw again. - Added multiple-choice sound sequences. These overcome one of the major deficiences of the Hexen-inherited SNDSEQ system while still being Hexen compatible: Custom door sounds can now use different opening and closing sequences, for both normal and blazing speeds. - Added a serializer for TArray. - Added a countof macro to doomtype.h. See the1's blog to find out why it's implemented the way it is. <http://blogs.msdn.com/the1/articles/210011.aspx> - Added a new method to FRandom for getting random numbers larger than 255, which lets me: - Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics. - Fixed: If you're going to have sector_t.SoundTarget, then they need to be included in the pointer cleanup scans. - Ported back newer name code from 2.1. - Fixed: Using -warp with only one parameter in Doom and Heretic to select a map on episode 1 no longer worked. - New: Loading a multiplayer save now restores the players based on their names rather than on their connection order. Using connection order was sensible when -net was the only way to start a network game, but with -host/-join, it's not so nice. Also, if there aren't enough players in the save, then the extra players will be spawned normally, so you can continue a saved game with more players than you started it with. - Added some new SNDSEQ commands to make it possible to define Heretic's ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence, delayonce, and restart. With these, it is basically possible to obsolete all of the $ambient SNDINFO commands. - Fixed: Sound sequences would only execute one command each time they were ticked. - Fixed: No bounds checking was done on the volume sound sequences played at. - Fixed: The tic parameter to playloop was useless and caused it to act like a redundant playrepeat. I have removed all the logic that caused playloop to play repeating sounds, and now it acts like an infinite sequence of play/delay commands until the sequence is stopped. - Fixed: Sound sequences were ticked every frame, not every tic, so all the delay commands were timed incorrectly and varied depending on your framerate. Since this is useful for restarting looping sounds that got cut off, I have not changed this. Instead, the delay commands now record the tic when execution should resume, not the number of tics left to delay. SVN r57 (trunk)
2006-04-21 01:22:55 +00:00
SN_StartSequence (poly, poly->seqType, SEQ_DOOR, 0);
}
polyNum = mirror;
}
return true;
}
//==========================================================================
//
// EV_StopPoly
//
//==========================================================================
bool EV_StopPoly(int polynum)
{
FPolyObj *poly;
if (NULL != (poly = PO_GetPolyobj(polynum)))
{
if (poly->specialdata != NULL)
{
poly->specialdata->Stop();
}
return true;
}
return false;
}
// ===== Higher Level Poly Interface code =====
//==========================================================================
//
// PO_GetPolyobj
//
//==========================================================================
FPolyObj *PO_GetPolyobj (int polyNum)
{
int i;
for (i = 0; i < po_NumPolyobjs; i++)
{
if (polyobjs[i].tag == polyNum)
{
return &polyobjs[i];
}
}
return NULL;
}
//==========================================================================
//
//
//
//==========================================================================
FPolyObj::FPolyObj()
{
StartSpot.x = StartSpot.y = 0;
angle = 0;
tag = 0;
memset(bbox, 0, sizeof(bbox));
validcount = 0;
crush = 0;
bHurtOnTouch = false;
seqType = 0;
size = 0;
subsectorlinks = NULL;
specialdata = NULL;
interpolation = NULL;
}
//==========================================================================
//
// GetPolyobjMirror
//
//==========================================================================
int FPolyObj::GetMirror()
{
return Linedefs[0]->args[1];
}
//==========================================================================
//
// ThrustMobj
//
//==========================================================================
void FPolyObj::ThrustMobj (AActor *actor, side_t *side)
{
int thrustAngle;
int thrustX;
int thrustY;
DPolyAction *pe;
int force;
if (!(actor->flags&MF_SHOOTABLE) && !actor->player)
{
return;
}
vertex_t *v1 = side->V1();
vertex_t *v2 = side->V2();
thrustAngle = (R_PointToAngle2 (v1->x, v1->y, v2->x, v2->y) - ANGLE_90) >> ANGLETOFINESHIFT;
pe = static_cast<DPolyAction *>(specialdata);
if (pe)
{
if (pe->IsKindOf (RUNTIME_CLASS (DRotatePoly)))
{
force = pe->GetSpeed() >> 8;
}
else
{
force = pe->GetSpeed() >> 3;
}
if (force < FRACUNIT)
{
force = FRACUNIT;
}
else if (force > 4*FRACUNIT)
{
force = 4*FRACUNIT;
}
}
else
{
force = FRACUNIT;
}
thrustX = FixedMul (force, finecosine[thrustAngle]);
thrustY = FixedMul (force, finesine[thrustAngle]);
actor->velx += thrustX;
actor->vely += thrustY;
if (crush)
{
if (bHurtOnTouch || !P_CheckMove (actor, actor->x + thrustX, actor->y + thrustY))
{
P_DamageMobj (actor, NULL, NULL, crush, NAME_Crush);
P_TraceBleed (crush, actor);
}
}
if (level.flags2 & LEVEL2_POLYGRIND) actor->Grind(false); // crush corpses that get caught in a polyobject's way
}
//==========================================================================
//
// UpdateSegBBox
//
//==========================================================================
void FPolyObj::UpdateBBox ()
{
for(unsigned i=0;i<Linedefs.Size(); i++)
{
line_t *line = Linedefs[i];
if (line->v1->x < line->v2->x)
{
line->bbox[BOXLEFT] = line->v1->x;
line->bbox[BOXRIGHT] = line->v2->x;
}
else
{
line->bbox[BOXLEFT] = line->v2->x;
line->bbox[BOXRIGHT] = line->v1->x;
}
if (line->v1->y < line->v2->y)
{
line->bbox[BOXBOTTOM] = line->v1->y;
line->bbox[BOXTOP] = line->v2->y;
}
else
{
line->bbox[BOXBOTTOM] = line->v2->y;
line->bbox[BOXTOP] = line->v1->y;
}
// Update the line's slopetype
line->dx = line->v2->x - line->v1->x;
line->dy = line->v2->y - line->v1->y;
if (!line->dx)
{
line->slopetype = ST_VERTICAL;
}
else if (!line->dy)
{
line->slopetype = ST_HORIZONTAL;
}
else
{
line->slopetype = ((line->dy ^ line->dx) >= 0) ? ST_POSITIVE : ST_NEGATIVE;
}
}
CalcCenter();
}
void FPolyObj::CalcCenter()
{
SQWORD cx = 0, cy = 0;
for(unsigned i=0;i<Vertices.Size(); i++)
{
cx += Vertices[i]->x;
cy += Vertices[i]->y;
}
CenterSpot.x = (fixed_t)(cx / Vertices.Size());
CenterSpot.y = (fixed_t)(cy / Vertices.Size());
}
//==========================================================================
//
// PO_MovePolyobj
//
//==========================================================================
bool FPolyObj::MovePolyobj (int x, int y, bool force)
{
UnLinkPolyobj ();
DoMovePolyobj (x, y);
if (!force)
{
bool blocked = false;
for(unsigned i=0;i < Sidedefs.Size(); i++)
{
if (CheckMobjBlocking(Sidedefs[i]))
{
blocked = true;
}
}
if (blocked)
{
DoMovePolyobj (-x, -y);
LinkPolyobj();
return false;
}
}
StartSpot.x += x;
StartSpot.y += y;
CenterSpot.x += x;
CenterSpot.y += y;
LinkPolyobj ();
ClearSubsectorLinks();
return true;
}
//==========================================================================
//
// DoMovePolyobj
//
//==========================================================================
void FPolyObj::DoMovePolyobj (int x, int y)
{
for(unsigned i=0;i < Vertices.Size(); i++)
{
Vertices[i]->x += x;
Vertices[i]->y += y;
PrevPts[i].x += x;
PrevPts[i].y += y;
}
for (unsigned i = 0; i < Linedefs.Size(); i++)
{
Linedefs[i]->bbox[BOXTOP] += y;
Linedefs[i]->bbox[BOXBOTTOM] += y;
Linedefs[i]->bbox[BOXLEFT] += x;
Linedefs[i]->bbox[BOXRIGHT] += x;
}
}
//==========================================================================
//
// RotatePt
//
//==========================================================================
static void RotatePt (int an, fixed_t *x, fixed_t *y, fixed_t startSpotX, fixed_t startSpotY)
{
fixed_t tr_x = *x;
fixed_t tr_y = *y;
*x = DMulScale16 (tr_x, finecosine[an], -tr_y, finesine[an])+startSpotX;
*y = DMulScale16 (tr_x, finesine[an], tr_y, finecosine[an])+startSpotY;
}
//==========================================================================
//
// PO_RotatePolyobj
//
//==========================================================================
bool FPolyObj::RotatePolyobj (angle_t angle)
{
int an;
bool blocked;
an = (this->angle+angle)>>ANGLETOFINESHIFT;
UnLinkPolyobj();
for(unsigned i=0;i < Vertices.Size(); i++)
{
PrevPts[i].x = Vertices[i]->x;
PrevPts[i].y = Vertices[i]->y;
Vertices[i]->x = OriginalPts[i].x;
Vertices[i]->y = OriginalPts[i].y;
RotatePt(an, &Vertices[i]->x, &Vertices[i]->y, StartSpot.x, StartSpot.y);
}
blocked = false;
validcount++;
UpdateBBox();
for(unsigned i=0;i < Sidedefs.Size(); i++)
{
if (CheckMobjBlocking(Sidedefs[i]))
{
blocked = true;
}
}
if (blocked)
{
for(unsigned i=0;i < Vertices.Size(); i++)
{
Vertices[i]->x = PrevPts[i].x;
Vertices[i]->y = PrevPts[i].y;
}
UpdateBBox();
LinkPolyobj();
return false;
}
this->angle += angle;
LinkPolyobj();
ClearSubsectorLinks();
return true;
}
//==========================================================================
//
// UnLinkPolyobj
//
//==========================================================================
void FPolyObj::UnLinkPolyobj ()
{
polyblock_t *link;
int i, j;
int index;
// remove the polyobj from each blockmap section
for(j = bbox[BOXBOTTOM]; j <= bbox[BOXTOP]; j++)
{
index = j*bmapwidth;
for(i = bbox[BOXLEFT]; i <= bbox[BOXRIGHT]; i++)
{
if(i >= 0 && i < bmapwidth && j >= 0 && j < bmapheight)
{
link = PolyBlockMap[index+i];
while(link != NULL && link->polyobj != this)
{
link = link->next;
}
if(link == NULL)
{ // polyobj not located in the link cell
continue;
}
link->polyobj = NULL;
}
}
}
}
//==========================================================================
//
// CheckMobjBlocking
//
//==========================================================================
bool FPolyObj::CheckMobjBlocking (side_t *sd)
{
static TArray<AActor *> checker;
FBlockNode *block;
AActor *mobj;
int i, j, k;
int left, right, top, bottom;
line_t *ld;
bool blocked;
ld = sd->linedef;
top = (ld->bbox[BOXTOP]-bmaporgy) >> MAPBLOCKSHIFT;
bottom = (ld->bbox[BOXBOTTOM]-bmaporgy) >> MAPBLOCKSHIFT;
left = (ld->bbox[BOXLEFT]-bmaporgx) >> MAPBLOCKSHIFT;
right = (ld->bbox[BOXRIGHT]-bmaporgx) >> MAPBLOCKSHIFT;
blocked = false;
checker.Clear();
bottom = bottom < 0 ? 0 : bottom;
bottom = bottom >= bmapheight ? bmapheight-1 : bottom;
top = top < 0 ? 0 : top;
top = top >= bmapheight ? bmapheight-1 : top;
left = left < 0 ? 0 : left;
left = left >= bmapwidth ? bmapwidth-1 : left;
right = right < 0 ? 0 : right;
right = right >= bmapwidth ? bmapwidth-1 : right;
for (j = bottom*bmapwidth; j <= top*bmapwidth; j += bmapwidth)
{
for (i = left; i <= right; i++)
{
for (block = blocklinks[j+i]; block != NULL; block = block->NextActor)
{
mobj = block->Me;
for (k = (int)checker.Size()-1; k >= 0; --k)
{
if (checker[k] == mobj)
{
break;
}
}
if (k < 0)
{
checker.Push (mobj);
if ((mobj->flags&MF_SOLID) && !(mobj->flags&MF_NOCLIP))
{
FBoundingBox box(mobj->x, mobj->y, mobj->radius);
if (box.Right() <= ld->bbox[BOXLEFT]
|| box.Left() >= ld->bbox[BOXRIGHT]
|| box.Top() <= ld->bbox[BOXBOTTOM]
|| box.Bottom() >= ld->bbox[BOXTOP])
{
continue;
}
if (box.BoxOnLineSide(ld) != -1)
{
continue;
}
ThrustMobj (mobj, sd);
blocked = true;
}
}
}
}
}
return blocked;
}
//==========================================================================
//
// LinkPolyobj
//
//==========================================================================
void FPolyObj::LinkPolyobj ()
{
polyblock_t **link;
polyblock_t *tempLink;
// calculate the polyobj bbox
Bounds.ClearBox();
for(unsigned i = 0; i < Sidedefs.Size(); i++)
{
vertex_t *vt;
vt = Sidedefs[i]->linedef->v1;
Bounds.AddToBox(vt->x, vt->y);
vt = Sidedefs[i]->linedef->v2;
Bounds.AddToBox(vt->x, vt->y);
}
bbox[BOXRIGHT] = (Bounds.Right() - bmaporgx) >> MAPBLOCKSHIFT;
bbox[BOXLEFT] = (Bounds.Left() - bmaporgx) >> MAPBLOCKSHIFT;
bbox[BOXTOP] = (Bounds.Top() - bmaporgy) >> MAPBLOCKSHIFT;
bbox[BOXBOTTOM] = (Bounds.Bottom() - bmaporgy) >> MAPBLOCKSHIFT;
// add the polyobj to each blockmap section
for(int j = bbox[BOXBOTTOM]*bmapwidth; j <= bbox[BOXTOP]*bmapwidth;
j += bmapwidth)
{
for(int i = bbox[BOXLEFT]; i <= bbox[BOXRIGHT]; i++)
{
if(i >= 0 && i < bmapwidth && j >= 0 && j < bmapheight*bmapwidth)
{
link = &PolyBlockMap[j+i];
if(!(*link))
{ // Create a new link at the current block cell
*link = new polyblock_t;
(*link)->next = NULL;
(*link)->prev = NULL;
(*link)->polyobj = this;
continue;
}
else
{
tempLink = *link;
while(tempLink->next != NULL && tempLink->polyobj != NULL)
{
tempLink = tempLink->next;
}
}
if(tempLink->polyobj == NULL)
{
tempLink->polyobj = this;
continue;
}
else
{
tempLink->next = new polyblock_t;
tempLink->next->next = NULL;
tempLink->next->prev = tempLink;
tempLink->next->polyobj = this;
}
}
// else, don't link the polyobj, since it's off the map
}
}
}
//===========================================================================
//
// PO_ClosestPoint
//
// Given a point (x,y), returns the point (ox,oy) on the polyobject's walls
// that is nearest to (x,y). Also returns the seg this point came from.
//
//===========================================================================
void FPolyObj::ClosestPoint(fixed_t fx, fixed_t fy, fixed_t &ox, fixed_t &oy, side_t **side) const
{
unsigned int i;
double x = fx, y = fy;
double bestdist = HUGE_VAL;
double bestx = 0, besty = 0;
side_t *bestline = NULL;
for (i = 0; i < Sidedefs.Size(); ++i)
{
vertex_t *v1 = Sidedefs[i]->V1();
vertex_t *v2 = Sidedefs[i]->V2();
double a = v2->x - v1->x;
double b = v2->y - v1->y;
double den = a*a + b*b;
double ix, iy, dist;
if (den == 0)
{ // Line is actually a point!
ix = v1->x;
iy = v1->y;
}
else
{
double num = (x - v1->x) * a + (y - v1->y) * b;
double u = num / den;
if (u <= 0)
{
ix = v1->x;
iy = v1->y;
}
else if (u >= 1)
{
ix = v2->x;
iy = v2->y;
}
else
{
ix = v1->x + u * a;
iy = v1->y + u * b;
}
}
a = (ix - x);
b = (iy - y);
dist = a*a + b*b;
if (dist < bestdist)
{
bestdist = dist;
bestx = ix;
besty = iy;
bestline = Sidedefs[i];
}
}
ox = fixed_t(bestx);
oy = fixed_t(besty);
if (side != NULL)
{
*side = bestline;
}
}
//==========================================================================
//
// InitBlockMap
//
//==========================================================================
static void InitBlockMap (void)
{
int i;
PolyBlockMap = new polyblock_t *[bmapwidth*bmapheight];
memset (PolyBlockMap, 0, bmapwidth*bmapheight*sizeof(polyblock_t *));
for (i = 0; i < po_NumPolyobjs; i++)
{
polyobjs[i].LinkPolyobj();
}
}
//==========================================================================
//
// InitSideLists [RH]
//
// Group sides by vertex and collect side that are known to belong to a
// polyobject so that they can be initialized fast.
//==========================================================================
static void InitSideLists ()
{
for (int i = 0; i < numsides; ++i)
{
if (sides[i].linedef != NULL &&
(sides[i].linedef->special == Polyobj_StartLine ||
sides[i].linedef->special == Polyobj_ExplicitLine))
{
KnownPolySides.Push (i);
}
}
}
//==========================================================================
//
// KillSideLists [RH]
//
//==========================================================================
static void KillSideLists ()
{
KnownPolySides.Clear ();
KnownPolySides.ShrinkToFit ();
}
//==========================================================================
//
// AddPolyVert
//
// Helper function for IterFindPolySides()
//
//==========================================================================
static void AddPolyVert(TArray<DWORD> &vnum, DWORD vert)
{
for (unsigned int i = vnum.Size() - 1; i-- != 0; )
{
if (vnum[i] == vert)
{ // Already in the set. No need to add it.
return;
}
}
vnum.Push(vert);
}
//==========================================================================
//
// IterFindPolySides
//
// Beginning with the first vertex of the starting side, for each vertex
// in vnum, add all the sides that use it as a first vertex to the polyobj,
// and add all their second vertices to vnum. This continues until there
// are no new vertices in vnum.
//
//==========================================================================
static void IterFindPolySides (FPolyObj *po, side_t *side)
{
static TArray<DWORD> vnum;
unsigned int vnumat;
assert(sidetemp != NULL);
vnum.Clear();
vnum.Push(DWORD(side->V1() - vertexes));
vnumat = 0;
while (vnum.Size() != vnumat)
{
DWORD sidenum = sidetemp[vnum[vnumat++]].b.first;
while (sidenum != NO_SIDE)
{
po->Sidedefs.Push(&sides[sidenum]);
AddPolyVert(vnum, DWORD(sides[sidenum].V2() - vertexes));
sidenum = sidetemp[sidenum].b.next;
}
}
}
//==========================================================================
//
// SpawnPolyobj
//
//==========================================================================
static void SpawnPolyobj (int index, int tag, int type)
{
unsigned int ii;
int i;
int j;
FPolyObj *po = &polyobjs[index];
for (ii = 0; ii < KnownPolySides.Size(); ++ii)
{
i = KnownPolySides[ii];
if (i < 0)
{
continue;
}
side_t *sd = &sides[i];
if (sd->linedef->special == Polyobj_StartLine &&
sd->linedef->args[0] == tag)
{
if (po->Sidedefs.Size() > 0)
{
I_Error ("SpawnPolyobj: Polyobj %d already spawned.\n", tag);
}
sd->linedef->special = 0;
sd->linedef->args[0] = 0;
IterFindPolySides(&polyobjs[index], sd);
po->crush = (type != PO_SPAWN_TYPE) ? 3 : 0;
po->bHurtOnTouch = (type == PO_SPAWNHURT_TYPE);
po->tag = tag;
po->seqType = sd->linedef->args[2];
if (po->seqType < 0 || po->seqType > 63)
{
po->seqType = 0;
}
break;
}
}
if (po->Sidedefs.Size() == 0)
{
// didn't find a polyobj through PO_LINE_START
TArray<side_t *> polySideList;
unsigned int psIndexOld;
for (j = 1; j < PO_MAXPOLYSEGS; j++)
{
psIndexOld = po->Sidedefs.Size();
for (ii = 0; ii < KnownPolySides.Size(); ++ii)
{
i = KnownPolySides[ii];
if (i >= 0 &&
sides[i].linedef->special == Polyobj_ExplicitLine &&
sides[i].linedef->args[0] == tag)
{
if (!sides[i].linedef->args[1])
{
I_Error ("SpawnPolyobj: Explicit line missing order number (probably %d) in poly %d.\n",
j+1, tag);
}
if (sides[i].linedef->args[1] == j)
{
po->Sidedefs.Push (&sides[i]);
}
}
}
// Clear out any specials for these segs...we cannot clear them out
// in the above loop, since we aren't guaranteed one seg per linedef.
for (ii = 0; ii < KnownPolySides.Size(); ++ii)
{
i = KnownPolySides[ii];
if (i >= 0 &&
sides[i].linedef->special == Polyobj_ExplicitLine &&
sides[i].linedef->args[0] == tag && sides[i].linedef->args[1] == j)
{
sides[i].linedef->special = 0;
sides[i].linedef->args[0] = 0;
KnownPolySides[ii] = -1;
}
}
if (po->Sidedefs.Size() == psIndexOld)
{ // Check if an explicit line order has been skipped.
// A line has been skipped if there are any more explicit
// lines with the current tag value. [RH] Can this actually happen?
for (ii = 0; ii < KnownPolySides.Size(); ++ii)
{
i = KnownPolySides[ii];
if (i >= 0 &&
sides[i].linedef->special == Polyobj_ExplicitLine &&
sides[i].linedef->args[0] == tag)
{
I_Error ("SpawnPolyobj: Missing explicit line %d for poly %d\n",
j, tag);
}
}
}
}
if (po->Sidedefs.Size() > 0)
{
po->crush = (type != PO_SPAWN_TYPE) ? 3 : 0;
po->bHurtOnTouch = (type == PO_SPAWNHURT_TYPE);
po->tag = tag;
po->seqType = po->Sidedefs[0]->linedef->args[3];
// Next, change the polyobj's first line to point to a mirror
// if it exists
po->Sidedefs[0]->linedef->args[1] =
po->Sidedefs[0]->linedef->args[2];
}
else
I_Error ("SpawnPolyobj: Poly %d does not exist\n", tag);
}
validcount++;
for(unsigned int i=0; i<po->Sidedefs.Size(); i++)
{
line_t *l = po->Sidedefs[i]->linedef;
if (l->validcount != validcount)
{
l->validcount = validcount;
po->Linedefs.Push(l);
vertex_t *v = l->v1;
int j;
for(j = po->Vertices.Size() - 1; j >= 0; j--)
{
if (po->Vertices[j] == v) break;
}
if (j < 0) po->Vertices.Push(v);
v = l->v2;
for(j = po->Vertices.Size() - 1; j >= 0; j--)
{
if (po->Vertices[j] == v) break;
}
if (j < 0) po->Vertices.Push(v);
}
}
po->Sidedefs.ShrinkToFit();
po->Linedefs.ShrinkToFit();
po->Vertices.ShrinkToFit();
}
//==========================================================================
//
// TranslateToStartSpot
//
//==========================================================================
static void TranslateToStartSpot (int tag, int originX, int originY)
{
FPolyObj *po;
int deltaX;
int deltaY;
po = NULL;
for (int i = 0; i < po_NumPolyobjs; i++)
{
if (polyobjs[i].tag == tag)
{
po = &polyobjs[i];
break;
}
}
if (po == NULL)
{ // didn't match the tag with a polyobj tag
I_Error("TranslateToStartSpot: Unable to match polyobj tag: %d\n", tag);
}
if (po->Sidedefs.Size() == 0)
{
I_Error ("TranslateToStartSpot: Anchor point located without a StartSpot point: %d\n", tag);
}
po->OriginalPts.Resize(po->Sidedefs.Size());
po->PrevPts.Resize(po->Sidedefs.Size());
deltaX = originX - po->StartSpot.x;
deltaY = originY - po->StartSpot.y;
for (unsigned i = 0; i < po->Sidedefs.Size(); i++)
{
po->Sidedefs[i]->Flags |= WALLF_POLYOBJ;
}
for (unsigned i = 0; i < po->Linedefs.Size(); i++)
{
po->Linedefs[i]->bbox[BOXTOP] -= deltaY;
po->Linedefs[i]->bbox[BOXBOTTOM] -= deltaY;
po->Linedefs[i]->bbox[BOXLEFT] -= deltaX;
po->Linedefs[i]->bbox[BOXRIGHT] -= deltaX;
}
for (unsigned i = 0; i < po->Vertices.Size(); i++)
{
po->Vertices[i]->x -= deltaX;
po->Vertices[i]->y -= deltaY;
po->OriginalPts[i].x = po->Vertices[i]->x - po->StartSpot.x;
po->OriginalPts[i].y = po->Vertices[i]->y - po->StartSpot.y;
}
po->CalcCenter();
// For compatibility purposes
po->CenterSubsector = R_PointInSubsector(po->CenterSpot.x, po->CenterSpot.y);
}
//==========================================================================
//
// PO_Init
//
//==========================================================================
void PO_Init (void)
{
// [RH] Hexen found the polyobject-related things by reloading the map's
// THINGS lump here and scanning through it. I have P_SpawnMapThing()
// record those things instead, so that in here we simply need to
// look at the polyspawns list.
polyspawns_t *polyspawn, **prev;
int polyIndex;
// [RH] Make this faster
InitSideLists ();
polyobjs = new FPolyObj[po_NumPolyobjs];
polyIndex = 0; // index polyobj number
// Find the startSpot points, and spawn each polyobj
for (polyspawn = polyspawns, prev = &polyspawns; polyspawn;)
{
// 9301 (3001) = no crush, 9302 (3002) = crushing, 9303 = hurting touch
if (polyspawn->type == PO_SPAWN_TYPE ||
polyspawn->type == PO_SPAWNCRUSH_TYPE ||
polyspawn->type == PO_SPAWNHURT_TYPE)
{
// Polyobj StartSpot Pt.
polyobjs[polyIndex].StartSpot.x = polyspawn->x;
polyobjs[polyIndex].StartSpot.y = polyspawn->y;
SpawnPolyobj(polyIndex, polyspawn->angle, polyspawn->type);
polyIndex++;
*prev = polyspawn->next;
delete polyspawn;
polyspawn = *prev;
}
else
{
prev = &polyspawn->next;
polyspawn = polyspawn->next;
}
}
for (polyspawn = polyspawns; polyspawn;)
{
polyspawns_t *next = polyspawn->next;
if (polyspawn->type == PO_ANCHOR_TYPE)
{
// Polyobj Anchor Pt.
TranslateToStartSpot (polyspawn->angle, polyspawn->x, polyspawn->y);
}
delete polyspawn;
polyspawn = next;
}
polyspawns = NULL;
// check for a startspot without an anchor point
for (polyIndex = 0; polyIndex < po_NumPolyobjs; polyIndex++)
{
if (polyobjs[polyIndex].OriginalPts.Size() == 0)
{
I_Error ("PO_Init: StartSpot located without an Anchor point: %d\n",
polyobjs[polyIndex].tag);
}
}
InitBlockMap();
// [RH] Don't need the seg lists anymore
KillSideLists ();
for(int i=0;i<numnodes;i++)
{
node_t *no = &nodes[i];
double fdx = (double)no->dx;
double fdy = (double)no->dy;
no->len = (float)sqrt(fdx * fdx + fdy * fdy);
}
}
//==========================================================================
//
// PO_Busy
//
//==========================================================================
bool PO_Busy (int polyobj)
{
FPolyObj *poly;
poly = PO_GetPolyobj (polyobj);
return (poly != NULL && poly->specialdata != NULL);
}
//==========================================================================
//
//
//
//==========================================================================
void FPolyObj::ClearSubsectorLinks()
{
while (subsectorlinks != NULL)
{
assert(subsectorlinks->state == 1337);
FPolyNode *next = subsectorlinks->snext;
if (subsectorlinks->pnext != NULL)
{
assert(subsectorlinks->pnext->state == 1337);
subsectorlinks->pnext->pprev = subsectorlinks->pprev;
}
if (subsectorlinks->pprev != NULL)
{
assert(subsectorlinks->pprev->state == 1337);
subsectorlinks->pprev->pnext = subsectorlinks->pnext;
}
else
{
subsectorlinks->subsector->polys = subsectorlinks->pnext;
}
if (subsectorlinks->subsector->BSP != NULL)
{
subsectorlinks->subsector->BSP->bDirty = true;
}
subsectorlinks->state = -1;
delete subsectorlinks;
subsectorlinks = next;
}
subsectorlinks = NULL;
}
void FPolyObj::ClearAllSubsectorLinks()
{
for (int i = 0; i < po_NumPolyobjs; i++)
{
polyobjs[i].ClearSubsectorLinks();
}
ReleaseAllPolyNodes();
}
//==========================================================================
//
// GetIntersection
//
// adapted from P_InterceptVector
//
//==========================================================================
static bool GetIntersection(FPolySeg *seg, node_t *bsp, FPolyVertex *v)
{
double frac;
double num;
double den;
double v2x = (double)seg->v1.x;
double v2y = (double)seg->v1.y;
double v2dx = (double)(seg->v2.x - seg->v1.x);
double v2dy = (double)(seg->v2.y - seg->v1.y);
double v1x = (double)bsp->x;
double v1y = (double)bsp->y;
double v1dx = (double)bsp->dx;
double v1dy = (double)bsp->dy;
den = v1dy*v2dx - v1dx*v2dy;
if (den == 0)
return false; // parallel
num = (v1x - v2x)*v1dy + (v2y - v1y)*v1dx;
frac = num / den;
if (frac < 0. || frac > 1.) return false;
v->x = xs_RoundToInt(v2x + frac * v2dx);
v->y = xs_RoundToInt(v2y + frac * v2dy);
return true;
}
//==========================================================================
//
// PartitionDistance
//
// Determine the distance of a vertex to a node's partition line.
//
//==========================================================================
static double PartitionDistance(FPolyVertex *vt, node_t *node)
{
return fabs(double(-node->dy) * (vt->x - node->x) + double(node->dx) * (vt->y - node->y)) / node->len;
}
//==========================================================================
//
// AddToBBox
//
//==========================================================================
static void AddToBBox(fixed_t child[4], fixed_t parent[4])
{
if (child[BOXTOP] > parent[BOXTOP])
{
parent[BOXTOP] = child[BOXTOP];
}
if (child[BOXBOTTOM] < parent[BOXBOTTOM])
{
parent[BOXBOTTOM] = child[BOXBOTTOM];
}
if (child[BOXLEFT] < parent[BOXLEFT])
{
parent[BOXLEFT] = child[BOXLEFT];
}
if (child[BOXRIGHT] > parent[BOXRIGHT])
{
parent[BOXRIGHT] = child[BOXRIGHT];
}
}
//==========================================================================
//
// AddToBBox
//
//==========================================================================
static void AddToBBox(FPolyVertex *v, fixed_t bbox[4])
{
if (v->x < bbox[BOXLEFT])
{
bbox[BOXLEFT] = v->x;
}
if (v->x > bbox[BOXRIGHT])
{
bbox[BOXRIGHT] = v->x;
}
if (v->y < bbox[BOXBOTTOM])
{
bbox[BOXBOTTOM] = v->y;
}
if (v->y > bbox[BOXTOP])
{
bbox[BOXTOP] = v->y;
}
}
//==========================================================================
//
// SplitPoly
//
//==========================================================================
static void SplitPoly(FPolyNode *pnode, void *node, fixed_t bbox[4])
{
static TArray<FPolySeg> lists[2];
static const double POLY_EPSILON = 0.3125;
if (!((size_t)node & 1)) // Keep going until found a subsector
{
node_t *bsp = (node_t *)node;
int centerside = R_PointOnSide(pnode->poly->CenterSpot.x, pnode->poly->CenterSpot.y, bsp);
lists[0].Clear();
lists[1].Clear();
for(unsigned i=0;i<pnode->segs.Size(); i++)
{
FPolySeg *seg = &pnode->segs[i];
// Parts of the following code were taken from Eternity and are
// being used with permission.
// get distance of vertices from partition line
// If the distance is too small, we may decide to
// change our idea of sidedness.
double dist_v1 = PartitionDistance(&seg->v1, bsp);
double dist_v2 = PartitionDistance(&seg->v2, bsp);
// If the distances are less than epsilon, consider the points as being
// on the same side as the polyobj origin. Why? People like to build
// polyobject doors flush with their door tracks. This breaks using the
// usual assumptions.
// Addition to Eternity code: We must also check any seg with only one
// vertex inside the epsilon threshold. If not, these lines will get split but
// adjoining ones with both vertices inside the threshold won't thus messing up
// the order in which they get drawn.
if(dist_v1 <= POLY_EPSILON)
{
if (dist_v2 <= POLY_EPSILON)
{
lists[centerside].Push(*seg);
}
else
{
int side = R_PointOnSide(seg->v2.x, seg->v2.y, bsp);
lists[side].Push(*seg);
}
}
else if (dist_v2 <= POLY_EPSILON)
{
int side = R_PointOnSide(seg->v1.x, seg->v1.y, bsp);
lists[side].Push(*seg);
}
else
{
int side1 = R_PointOnSide(seg->v1.x, seg->v1.y, bsp);
int side2 = R_PointOnSide(seg->v2.x, seg->v2.y, bsp);
if(side1 != side2)
{
// if the partition line crosses this seg, we must split it.
FPolyVertex vert;
if (GetIntersection(seg, bsp, &vert))
{
lists[0].Push(*seg);
lists[1].Push(*seg);
lists[side1].Last().v2 = vert;
lists[side2].Last().v1 = vert;
}
else
{
// should never happen
lists[side1].Push(*seg);
}
}
else
{
// both points on the same side.
lists[side1].Push(*seg);
}
}
}
if (lists[1].Size() == 0)
{
SplitPoly(pnode, bsp->children[0], bsp->bbox[0]);
AddToBBox(bsp->bbox[0], bbox);
}
else if (lists[0].Size() == 0)
{
SplitPoly(pnode, bsp->children[1], bsp->bbox[1]);
AddToBBox(bsp->bbox[1], bbox);
}
else
{
// create the new node
FPolyNode *newnode = NewPolyNode();
newnode->poly = pnode->poly;
newnode->segs = lists[1];
// set segs for original node
pnode->segs = lists[0];
// recurse back side
SplitPoly(newnode, bsp->children[1], bsp->bbox[1]);
// recurse front side
SplitPoly(pnode, bsp->children[0], bsp->bbox[0]);
AddToBBox(bsp->bbox[0], bbox);
AddToBBox(bsp->bbox[1], bbox);
}
}
else
{
// we reached a subsector so we can link the node with this subsector
subsector_t *sub = (subsector_t *)((BYTE *)node - 1);
// Link node to subsector
pnode->pnext = sub->polys;
if (pnode->pnext != NULL)
{
assert(pnode->pnext->state == 1337);
pnode->pnext->pprev = pnode;
}
pnode->pprev = NULL;
sub->polys = pnode;
// link node to polyobject
pnode->snext = pnode->poly->subsectorlinks;
pnode->poly->subsectorlinks = pnode;
pnode->subsector = sub;
// calculate bounding box for this polynode
assert(pnode->segs.Size() != 0);
fixed_t subbbox[4] = { FIXED_MIN, FIXED_MAX, FIXED_MAX, FIXED_MIN };
for (unsigned i = 0; i < pnode->segs.Size(); ++i)
{
AddToBBox(&pnode->segs[i].v1, subbbox);
AddToBBox(&pnode->segs[i].v2, subbbox);
}
// Potentially expand the parent node's bounding box to contain these bits of polyobject.
AddToBBox(subbbox, bbox);
}
}
//==========================================================================
//
//
//
//==========================================================================
void FPolyObj::CreateSubsectorLinks()
{
FPolyNode *node = NewPolyNode();
// Even though we don't care about it, we need to initialize this
// bounding box to something so that Valgrind won't complain about it
// when SplitPoly modifies it.
fixed_t dummybbox[4] = { 0 };
node->poly = this;
node->segs.Resize(Sidedefs.Size());
for(unsigned i=0; i<Sidedefs.Size(); i++)
{
FPolySeg *seg = &node->segs[i];
side_t *side = Sidedefs[i];
seg->v1 = side->V1();
seg->v2 = side->V2();
seg->wall = side;
}
if (!(i_compatflags & COMPATF_POLYOBJ))
{
SplitPoly(node, nodes + numnodes - 1, dummybbox);
}
else
{
subsector_t *sub = CenterSubsector;
// Link node to subsector
node->pnext = sub->polys;
if (node->pnext != NULL)
{
assert(node->pnext->state == 1337);
node->pnext->pprev = node;
}
node->pprev = NULL;
sub->polys = node;
// link node to polyobject
node->snext = node->poly->subsectorlinks;
node->poly->subsectorlinks = node;
node->subsector = sub;
}
}
//==========================================================================
//
//
//
//==========================================================================
void PO_LinkToSubsectors()
{
for (int i = 0; i < po_NumPolyobjs; i++)
{
if (polyobjs[i].subsectorlinks == NULL)
{
polyobjs[i].CreateSubsectorLinks();
}
}
}
//==========================================================================
//
// NewPolyNode
//
//==========================================================================
static FPolyNode *NewPolyNode()
{
FPolyNode *node;
if (FreePolyNodes != NULL)
{
node = FreePolyNodes;
FreePolyNodes = node->pnext;
}
else
{
node = new FPolyNode;
}
node->state = 1337;
node->poly = NULL;
node->pnext = NULL;
node->pprev = NULL;
node->subsector = NULL;
node->snext = NULL;
return node;
}
//==========================================================================
//
// FreePolyNode
//
//==========================================================================
void FreePolyNode(FPolyNode *node)
{
node->segs.Clear();
node->pnext = FreePolyNodes;
FreePolyNodes = node;
}
//==========================================================================
//
// ReleaseAllPolyNodes
//
//==========================================================================
void ReleaseAllPolyNodes()
{
FPolyNode *node, *next;
for (node = FreePolyNodes; node != NULL; node = next)
{
next = node->pnext;
delete node;
}
}