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

Merge branch 'floatcvt' of https://github.com/rheit/zdoom into floatcvt

Browse source
This commit is contained in:
Christoph Oelckers 2016-03-25 14:56:40 +01:00
commit ad74493d5e
48 changed files with 671 additions and 855 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
src/actor.h
View file

@ -590,7 +590,7 @@ public:
DDropItem *GetDropItems() const; DDropItem *GetDropItems() const;
// Return true if the monster should use a missile attack, false for melee // Return true if the monster should use a missile attack, false for melee
bool SuggestMissileAttack (fixed_t dist); bool SuggestMissileAttack (double dist);
// Adjusts the angle for deflection/reflection of incoming missiles // Adjusts the angle for deflection/reflection of incoming missiles
// Returns true if the missile should be allowed to explode anyway // Returns true if the missile should be allowed to explode anyway
@ -837,25 +837,20 @@ public:
// to distinguish between portal-aware and portal-unaware distance calculation. // to distinguish between portal-aware and portal-unaware distance calculation.
fixed_t AproxDistance(AActor *other, bool absolute = false) fixed_t AproxDistance(AActor *other, bool absolute = false)
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return P_AproxDistance(_f_X() - otherpos.x, _f_Y() - otherpos.y); return P_AproxDistance(_f_X() - otherpos.x, _f_Y() - otherpos.y);
} }
fixed_t AproxDistance(AActor *other, fixed_t xadd, fixed_t yadd, bool absolute = false) fixed_t AproxDistance(AActor *other, fixed_t xadd, fixed_t yadd, bool absolute = false)
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return P_AproxDistance(_f_X() - otherpos.x + xadd, _f_Y() - otherpos.y + yadd); return P_AproxDistance(_f_X() - otherpos.x + xadd, _f_Y() - otherpos.y + yadd);
} }
fixed_t AproxDistance3D(AActor *other, bool absolute = false)
{
return P_AproxDistance(AproxDistance(other), _f_Z() - other->_f_Z());
}
// more precise, but slower version, being used in a few places // more precise, but slower version, being used in a few places
double Distance2D(AActor *other, bool absolute = false) double Distance2D(AActor *other, bool absolute = false)
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return (DVector2(_f_X() - otherpos.x, _f_Y() - otherpos.y).Length())/FRACUNIT; return (DVector2(_f_X() - otherpos.x, _f_Y() - otherpos.y).Length())/FRACUNIT;
} }
@ -867,13 +862,13 @@ public:
// a full 3D version of the above // a full 3D version of the above
fixed_t Distance3D(AActor *other, bool absolute = false) fixed_t Distance3D(AActor *other, bool absolute = false)
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return xs_RoundToInt(DVector3(_f_X() - otherpos.x, _f_Y() - otherpos.y, _f_Z() - otherpos.z).Length()); return xs_RoundToInt(DVector3(_f_X() - otherpos.x, _f_Y() - otherpos.y, _f_Z() - otherpos.z).Length());
} }
angle_t __f_AngleTo(AActor *other, bool absolute = false) angle_t __f_AngleTo(AActor *other, bool absolute = false)
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return R_PointToAngle2(_f_X(), _f_Y(), otherpos.x, otherpos.y); return R_PointToAngle2(_f_X(), _f_Y(), otherpos.x, otherpos.y);
} }
@ -884,13 +879,13 @@ public:
DAngle AngleTo(AActor *other, bool absolute = false) DAngle AngleTo(AActor *other, bool absolute = false)
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return VecToAngle(otherpos.x - _f_X(), otherpos.y - _f_Y()); return VecToAngle(otherpos.x - _f_X(), otherpos.y - _f_Y());
} }
DAngle AngleTo(AActor *other, fixed_t oxofs, fixed_t oyofs, bool absolute = false) const DAngle AngleTo(AActor *other, fixed_t oxofs, fixed_t oyofs, bool absolute = false) const
{ {
fixedvec3 otherpos = absolute ? other->_f_Pos() : other->PosRelative(this); fixedvec3 otherpos = absolute ? other->_f_Pos() : other->_f_PosRelative(this);
return VecToAngle(otherpos.y + oxofs - _f_Y(), otherpos.x + oyofs - _f_X()); return VecToAngle(otherpos.y + oxofs - _f_Y(), otherpos.x + oyofs - _f_X());
} }
@ -901,27 +896,27 @@ public:
fixedvec2 _f_Vec2To(AActor *other) const fixedvec2 _f_Vec2To(AActor *other) const
{ {
fixedvec3 otherpos = other->PosRelative(this); fixedvec3 otherpos = other->_f_PosRelative(this);
fixedvec2 ret = { otherpos.x - _f_X(), otherpos.y - _f_Y() }; fixedvec2 ret = { otherpos.x - _f_X(), otherpos.y - _f_Y() };
return ret; return ret;
} }
fixedvec3 _f_Vec3To(AActor *other) const fixedvec3 _f_Vec3To(AActor *other) const
{ {
fixedvec3 otherpos = other->PosRelative(this); fixedvec3 otherpos = other->_f_PosRelative(this);
fixedvec3 ret = { otherpos.x - _f_X(), otherpos.y - _f_Y(), otherpos.z - _f_Z() }; fixedvec3 ret = { otherpos.x - _f_X(), otherpos.y - _f_Y(), otherpos.z - _f_Z() };
return ret; return ret;
} }
DVector2 Vec2To(AActor *other) const DVector2 Vec2To(AActor *other) const
{ {
fixedvec3 otherpos = other->PosRelative(this); fixedvec3 otherpos = other->_f_PosRelative(this);
return{ FIXED2DBL(otherpos.x - _f_X()), FIXED2DBL(otherpos.y - _f_Y()) }; return{ FIXED2DBL(otherpos.x - _f_X()), FIXED2DBL(otherpos.y - _f_Y()) };
} }
DVector3 Vec3To(AActor *other) const DVector3 Vec3To(AActor *other) const
{ {
fixedvec3 otherpos = other->PosRelative(this); fixedvec3 otherpos = other->_f_PosRelative(this);
return { FIXED2DBL(otherpos.x - _f_X()), FIXED2DBL(otherpos.y - _f_Y()), FIXED2DBL(otherpos.z - _f_Z()) }; return { FIXED2DBL(otherpos.x - _f_X()), FIXED2DBL(otherpos.y - _f_Y()), FIXED2DBL(otherpos.z - _f_Z()) };
} }
@ -1235,18 +1230,18 @@ public:
SBYTE LastLookPlayerNumber;// Player number last looked for (if TIDtoHate == 0) SBYTE LastLookPlayerNumber;// Player number last looked for (if TIDtoHate == 0)
ActorBounceFlags BounceFlags; // which bouncing type? ActorBounceFlags BounceFlags; // which bouncing type?
DWORD SpawnFlags; // Increased to DWORD because of Doom 64 DWORD SpawnFlags; // Increased to DWORD because of Doom 64
fixed_t meleerange; // specifies how far a melee attack reaches. double meleerange; // specifies how far a melee attack reaches.
fixed_t meleethreshold; // Distance below which a monster doesn't try to shoot missiles anynore double meleethreshold; // Distance below which a monster doesn't try to shoot missiles anynore
// but instead tries to come closer for a melee attack. // but instead tries to come closer for a melee attack.
// This is not the same as meleerange // This is not the same as meleerange
fixed_t maxtargetrange; // any target farther away cannot be attacked double maxtargetrange; // any target farther away cannot be attacked
fixed_t bouncefactor; // Strife's grenades use 50%, Hexen's Flechettes 70. double bouncefactor; // Strife's grenades use 50%, Hexen's Flechettes 70.
fixed_t wallbouncefactor; // The bounce factor for walls can be different. double wallbouncefactor; // The bounce factor for walls can be different.
int bouncecount; // Strife's grenades only bounce twice before exploding int bouncecount; // Strife's grenades only bounce twice before exploding
double Gravity; // [GRB] Gravity factor double Gravity; // [GRB] Gravity factor
fixed_t Friction; double Friction;
int FastChaseStrafeCount; int FastChaseStrafeCount;
fixed_t pushfactor; double pushfactor;
int lastpush; int lastpush;
int activationtype; // How the thing behaves when activated with USESPECIAL or BUMPSPECIAL int activationtype; // How the thing behaves when activated with USESPECIAL or BUMPSPECIAL
int lastbump; // Last time the actor was bumped, used to control BUMPSPECIAL int lastbump; // Last time the actor was bumped, used to control BUMPSPECIAL
@ -1419,10 +1414,10 @@ public:
return DVector3(X(), Y(), Z()); return DVector3(X(), Y(), Z());
} }
fixedvec3 PosRelative(int grp) const; fixedvec3 _f_PosRelative(int grp) const;
fixedvec3 PosRelative(const AActor *other) const; fixedvec3 _f_PosRelative(const AActor *other) const;
fixedvec3 PosRelative(sector_t *sec) const; fixedvec3 _f_PosRelative(sector_t *sec) const;
fixedvec3 PosRelative(line_t *line) const; fixedvec3 _f_PosRelative(line_t *line) const;
fixed_t SoundX() const fixed_t SoundX() const
{ {
@ -1478,14 +1473,6 @@ public:
{ {
return Z() + Height/2; return Z() + Height/2;
} }
double _pushfactor() const
{
return FIXED2DBL(pushfactor);
}
double _bouncefactor() const
{
return FIXED2DBL(bouncefactor);
}
void SetZ(double newz, bool moving = true) void SetZ(double newz, bool moving = true)
{ {
__pos.z = FLOAT2FIXED(newz); __pos.z = FLOAT2FIXED(newz);

6
src/am_map.cpp
View file

@ -2732,7 +2732,7 @@ void AM_drawPlayers ()
if (p->mo != NULL) if (p->mo != NULL)
{ {
fixedvec3 pos = p->mo->PosRelative(MapPortalGroup); fixedvec3 pos = p->mo->_f_PosRelative(MapPortalGroup);
pt.x = pos.x >> FRACTOMAPBITS; pt.x = pos.x >> FRACTOMAPBITS;
pt.y = pos.y >> FRACTOMAPBITS; pt.y = pos.y >> FRACTOMAPBITS;
@ -2766,7 +2766,7 @@ void AM_drawKeys ()
while ((key = it.Next()) != NULL) while ((key = it.Next()) != NULL)
{ {
fixedvec3 pos = key->PosRelative(MapPortalGroup); fixedvec3 pos = key->_f_PosRelative(MapPortalGroup);
p.x = pos.x >> FRACTOMAPBITS; p.x = pos.x >> FRACTOMAPBITS;
p.y = pos.y >> FRACTOMAPBITS; p.y = pos.y >> FRACTOMAPBITS;
@ -2813,7 +2813,7 @@ void AM_drawThings ()
{ {
if (am_cheat > 0 || !(t->flags6 & MF6_NOTONAUTOMAP)) if (am_cheat > 0 || !(t->flags6 & MF6_NOTONAUTOMAP))
{ {
fixedvec3 pos = t->PosRelative(MapPortalGroup); fixedvec3 pos = t->_f_PosRelative(MapPortalGroup);
p.x = pos.x >> FRACTOMAPBITS; p.x = pos.x >> FRACTOMAPBITS;
p.y = pos.y >> FRACTOMAPBITS; p.y = pos.y >> FRACTOMAPBITS;

14
src/d_dehacked.cpp
View file

@ -1141,14 +1141,12 @@ static int PatchThing (int thingy)
} }
// MBF bounce factors depend on flag combos: // MBF bounce factors depend on flag combos:
enum const double MBF_BOUNCE_NOGRAVITY = 1; // With NOGRAVITY: full momentum
{ const double MBF_BOUNCE_FLOATDROPOFF = 0.85; // With FLOAT and DROPOFF: 85%
MBF_BOUNCE_NOGRAVITY = FRACUNIT, // With NOGRAVITY: full momentum const double MBF_BOUNCE_FLOAT = 0.7; // With FLOAT alone: 70%
MBF_BOUNCE_FLOATDROPOFF = (FRACUNIT * 85) / 100,// With FLOAT and DROPOFF: 85% const double MBF_BOUNCE_DEFAULT = 0.45; // Without the above flags: 45%
MBF_BOUNCE_FLOAT = (FRACUNIT * 70) / 100,// With FLOAT alone: 70% const double MBF_BOUNCE_WALL = 0.5; // Bouncing off walls: 50%
MBF_BOUNCE_DEFAULT = (FRACUNIT * 45) / 100,// Without the above flags: 45%
MBF_BOUNCE_WALL = (FRACUNIT * 50) / 100,// Bouncing off walls: 50%
};
info->bouncefactor = ((value[0] & MF_NOGRAVITY) ? MBF_BOUNCE_NOGRAVITY info->bouncefactor = ((value[0] & MF_NOGRAVITY) ? MBF_BOUNCE_NOGRAVITY
: (value[0] & MF_FLOAT) ? (value[0] & MF_DROPOFF) ? MBF_BOUNCE_FLOATDROPOFF : (value[0] & MF_FLOAT) ? (value[0] & MF_DROPOFF) ? MBF_BOUNCE_FLOATDROPOFF
: MBF_BOUNCE_FLOAT : MBF_BOUNCE_DEFAULT); : MBF_BOUNCE_FLOAT : MBF_BOUNCE_DEFAULT);

10
src/d_player.h
View file

@ -150,17 +150,17 @@ public:
// [GRB] Player class properties // [GRB] Player class properties
double JumpZ; double JumpZ;
fixed_t GruntSpeed; double GruntSpeed;
fixed_t FallingScreamMinSpeed, FallingScreamMaxSpeed; double FallingScreamMinSpeed, FallingScreamMaxSpeed;
double ViewHeight; double ViewHeight;
double ForwardMove1, ForwardMove2; double ForwardMove1, ForwardMove2;
double SideMove1, SideMove2; double SideMove1, SideMove2;
FTextureID ScoreIcon; FTextureID ScoreIcon;
int SpawnMask; int SpawnMask;
FNameNoInit MorphWeapon; FNameNoInit MorphWeapon;
fixed_t AttackZOffset; // attack height, relative to player center double AttackZOffset; // attack height, relative to player center
fixed_t UseRange; // [NS] Distance at which player can +use double UseRange; // [NS] Distance at which player can +use
fixed_t AirCapacity; // Multiplier for air supply underwater. double AirCapacity; // Multiplier for air supply underwater.
PClassActor *FlechetteType; PClassActor *FlechetteType;

65
src/dobjtype.cpp
View file

@ -80,7 +80,6 @@ PSound *TypeSound;
PColor *TypeColor; PColor *TypeColor;
PStatePointer *TypeState; PStatePointer *TypeState;
PFixed *TypeFixed; PFixed *TypeFixed;
PAngle *TypeAngle;
// PRIVATE DATA DEFINITIONS ------------------------------------------------ // PRIVATE DATA DEFINITIONS ------------------------------------------------
@ -507,7 +506,6 @@ void PType::StaticInit()
RUNTIME_CLASS(PClass)->TypeTableType = RUNTIME_CLASS(PClass); RUNTIME_CLASS(PClass)->TypeTableType = RUNTIME_CLASS(PClass);
RUNTIME_CLASS(PStatePointer)->TypeTableType = RUNTIME_CLASS(PStatePointer); RUNTIME_CLASS(PStatePointer)->TypeTableType = RUNTIME_CLASS(PStatePointer);
RUNTIME_CLASS(PFixed)->TypeTableType = RUNTIME_CLASS(PFixed); RUNTIME_CLASS(PFixed)->TypeTableType = RUNTIME_CLASS(PFixed);
RUNTIME_CLASS(PAngle)->TypeTableType = RUNTIME_CLASS(PAngle);
// Create types and add them type the type table. // Create types and add them type the type table.
TypeTable.AddType(TypeError = new PErrorType); TypeTable.AddType(TypeError = new PErrorType);
@ -527,7 +525,6 @@ void PType::StaticInit()
TypeTable.AddType(TypeColor = new PColor); TypeTable.AddType(TypeColor = new PColor);
TypeTable.AddType(TypeState = new PStatePointer); TypeTable.AddType(TypeState = new PStatePointer);
TypeTable.AddType(TypeFixed = new PFixed); TypeTable.AddType(TypeFixed = new PFixed);
TypeTable.AddType(TypeAngle = new PAngle);
GlobalSymbols.AddSymbol(new PSymbolType(NAME_sByte, TypeSInt8)); GlobalSymbols.AddSymbol(new PSymbolType(NAME_sByte, TypeSInt8));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Byte, TypeUInt8)); GlobalSymbols.AddSymbol(new PSymbolType(NAME_Byte, TypeUInt8));
@ -546,7 +543,6 @@ void PType::StaticInit()
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Color, TypeColor)); GlobalSymbols.AddSymbol(new PSymbolType(NAME_Color, TypeColor));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_State, TypeState)); GlobalSymbols.AddSymbol(new PSymbolType(NAME_State, TypeState));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Fixed, TypeFixed)); GlobalSymbols.AddSymbol(new PSymbolType(NAME_Fixed, TypeFixed));
GlobalSymbols.AddSymbol(new PSymbolType(NAME_Angle, TypeAngle));
} }
@ -1146,67 +1142,6 @@ int PFixed::GetLoadOp() const
return OP_LX; return OP_LX;
} }
/* PAngle *****************************************************************/
IMPLEMENT_CLASS(PAngle)
//==========================================================================
//
// PAngle Default Constructor
//
//==========================================================================
PAngle::PAngle()
: PFloat(sizeof(angle_t))
{
}
//==========================================================================
//
// PAngle :: SetValue
//
//==========================================================================
void PAngle::SetValue(void *addr, int val)
{
assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address");
*(angle_t *)addr = Scale(val, ANGLE_90, 90);
}
//==========================================================================
//
// PAngle :: GetValueInt
//
//==========================================================================
int PAngle::GetValueInt(void *addr) const
{
assert(((intptr_t)addr & (Align - 1)) == 0 && "unaligned address");
return *(angle_t *)addr / ANGLE_1;
}
//==========================================================================
//
// PAngle :: GetStoreOp
//
//==========================================================================
int PAngle::GetStoreOp() const
{
return OP_SANG;
}
//==========================================================================
//
// PAngle :: GetLoadOp
//
//==========================================================================
int PAngle::GetLoadOp() const
{
return OP_LANG;
}
/* PStatePointer **********************************************************/ /* PStatePointer **********************************************************/
IMPLEMENT_CLASS(PStatePointer) IMPLEMENT_CLASS(PStatePointer)

13
src/dobjtype.h
View file

@ -415,18 +415,6 @@ public:
virtual int GetLoadOp() const; virtual int GetLoadOp() const;
}; };
class PAngle : public PFloat
{
DECLARE_CLASS(PAngle, PFloat);
public:
PAngle();
virtual void SetValue(void *addr, int val);
virtual int GetValueInt(void *addr) const;
virtual int GetStoreOp() const;
virtual int GetLoadOp() const;
};
// Pointers ----------------------------------------------------------------- // Pointers -----------------------------------------------------------------
class PStatePointer : public PBasicType class PStatePointer : public PBasicType
@ -784,7 +772,6 @@ extern PSound *TypeSound;
extern PColor *TypeColor; extern PColor *TypeColor;
extern PStatePointer *TypeState; extern PStatePointer *TypeState;
extern PFixed *TypeFixed; extern PFixed *TypeFixed;
extern PAngle *TypeAngle;
// A constant value --------------------------------------------------------- // A constant value ---------------------------------------------------------

11
src/doomdef.h
View file

@ -366,13 +366,10 @@ enum
// magnetized floors, etc. Less friction can create ice. // magnetized floors, etc. Less friction can create ice.
#define MORE_FRICTION_VELOCITY (15000/65536.) // mud factor based on velocity #define MORE_FRICTION_VELOCITY (15000/65536.) // mud factor based on velocity
#define ORIG_FRICTION 0xE800 // original value #define ORIG_FRICTION (0xE800/65536.) // original value
#define fORIG_FRICTION (ORIG_FRICTION/65536.) #define ORIG_FRICTION_FACTOR (2048/65536.) // original value
#define ORIG_FRICTION_FACTOR 2048 // original value #define FRICTION_LOW (0xf900/65536.)
#define fORIG_FRICTION_FACTOR (2048/65536.) // original value #define FRICTION_FLY (0xeb00/65536.)
#define FRICTION_LOW 0xf900
#define FRICTION_FLY 0xeb00
#define fFRICTION_FLY (0xeb00/65536.)
#define BLINKTHRESHOLD (4*32) #define BLINKTHRESHOLD (4*32)

14
src/g_doom/a_doomweaps.cpp
View file

@ -122,8 +122,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Saw)
PARAM_CLASS_OPT (pufftype, AActor) { pufftype = NULL; } PARAM_CLASS_OPT (pufftype, AActor) { pufftype = NULL; }
PARAM_INT_OPT (flags) { flags = 0; } PARAM_INT_OPT (flags) { flags = 0; }
PARAM_FLOAT_OPT (range) { range = 0; } PARAM_FLOAT_OPT (range) { range = 0; }
PARAM_DANGLE_OPT(spread_xy) { spread_xy = 2.8125; } PARAM_ANGLE_OPT (spread_xy) { spread_xy = 2.8125; }
PARAM_DANGLE_OPT(spread_z) { spread_z = 0.; } PARAM_ANGLE_OPT (spread_z) { spread_z = 0.; }
PARAM_FLOAT_OPT (lifesteal) { lifesteal = 0; } PARAM_FLOAT_OPT (lifesteal) { lifesteal = 0; }
PARAM_INT_OPT (lifestealmax) { lifestealmax = 0; } PARAM_INT_OPT (lifestealmax) { lifestealmax = 0; }
PARAM_CLASS_OPT (armorbonustype, ABasicArmorBonus) { armorbonustype = NULL; } PARAM_CLASS_OPT (armorbonustype, ABasicArmorBonus) { armorbonustype = NULL; }
@ -564,7 +564,11 @@ static void FireRailgun(AActor *self, int offset_xy, bool fromweapon)
damage = deathmatch ? 100 : 150; damage = deathmatch ? 100 : 150;
P_RailAttack (self, damage, offset_xy); FRailParams p;
p.source = self;
p.damage = damage;
p.offset_xy = offset_xy;
P_RailAttack (&p);
} }
@ -632,9 +636,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_BFGSpray)
PARAM_CLASS_OPT (spraytype, AActor) { spraytype = NULL; } PARAM_CLASS_OPT (spraytype, AActor) { spraytype = NULL; }
PARAM_INT_OPT (numrays) { numrays = 0; } PARAM_INT_OPT (numrays) { numrays = 0; }
PARAM_INT_OPT (damagecnt) { damagecnt = 0; } PARAM_INT_OPT (damagecnt) { damagecnt = 0; }
PARAM_DANGLE_OPT(angle) { angle = 0.; } PARAM_ANGLE_OPT (angle) { angle = 0.; }
PARAM_FLOAT_OPT (distance) { distance = 0; } PARAM_FLOAT_OPT (distance) { distance = 0; }
PARAM_DANGLE_OPT(vrange) { vrange = 0.; } PARAM_ANGLE_OPT (vrange) { vrange = 0.; }
PARAM_INT_OPT (defdamage) { defdamage = 0; } PARAM_INT_OPT (defdamage) { defdamage = 0; }
int i; int i;

2
src/g_doom/a_painelemental.cpp
View file

@ -153,7 +153,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_PainAttack)
return 0; return 0;
PARAM_CLASS_OPT (spawntype, AActor) { spawntype = NULL; } PARAM_CLASS_OPT (spawntype, AActor) { spawntype = NULL; }
PARAM_DANGLE_OPT (angle) { angle = 0.; } PARAM_ANGLE_OPT (angle) { angle = 0.; }
PARAM_INT_OPT (flags) { flags = 0; } PARAM_INT_OPT (flags) { flags = 0; }
PARAM_INT_OPT (limit) { limit = -1; } PARAM_INT_OPT (limit) { limit = -1; }

2
src/g_shared/a_fastprojectile.cpp
View file

@ -73,7 +73,7 @@ void AFastProjectile::Tick ()
if (tm.ceilingline && if (tm.ceilingline &&
tm.ceilingline->backsector && tm.ceilingline->backsector &&
tm.ceilingline->backsector->GetTexture(sector_t::ceiling) == skyflatnum && tm.ceilingline->backsector->GetTexture(sector_t::ceiling) == skyflatnum &&
Z() >= tm.ceilingline->backsector->ceilingplane.ZatPointF(PosRelative(tm.ceilingline))) Z() >= tm.ceilingline->backsector->ceilingplane.ZatPointF(_f_PosRelative(tm.ceilingline)))
{ {
// Hack to prevent missiles exploding against the sky. // Hack to prevent missiles exploding against the sky.
// Does not handle sky floors. // Does not handle sky floors.

3
src/g_shared/a_quake.cpp
View file

@ -238,9 +238,8 @@ double DEarthquake::GetFalloff(double dist) const
else if ((dist > m_Falloff) && (dist < m_TremorRadius)) else if ((dist > m_Falloff) && (dist < m_TremorRadius))
{ //Player inside the radius, and outside the min distance for falloff. { //Player inside the radius, and outside the min distance for falloff.
double tremorsize = m_TremorRadius - m_Falloff; double tremorsize = m_TremorRadius - m_Falloff;
double tremordist = dist - m_Falloff;
assert(tremorsize > 0); assert(tremorsize > 0);
return (1. - tremordist) / tremorsize; return (1. - ((dist - m_Falloff) / tremorsize));
} }
else else
{ //Shouldn't happen. { //Shouldn't happen.

2
src/g_strife/a_strifeweapons.cpp
View file

@ -690,7 +690,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireGrenade)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
PARAM_CLASS(grenadetype, AActor); PARAM_CLASS(grenadetype, AActor);
PARAM_DANGLE(angleofs); PARAM_ANGLE(angleofs);
PARAM_STATE(flash) PARAM_STATE(flash)
player_t *player = self->player; player_t *player = self->player;

2
src/info.cpp
View file

@ -230,7 +230,7 @@ PClassActor::PClassActor()
WoundHealth = 6; WoundHealth = 6;
PoisonDamage = 0; PoisonDamage = 0;
FastSpeed = -1.; FastSpeed = -1.;
RDFactor = FRACUNIT; RDFactor = 1.;
CameraHeight = INT_MIN; CameraHeight = INT_MIN;
DropItems = NULL; DropItems = NULL;

2
src/info.h
View file

@ -250,7 +250,7 @@ public:
int WoundHealth; // Health needed to enter wound state int WoundHealth; // Health needed to enter wound state
int PoisonDamage; // Amount of poison damage int PoisonDamage; // Amount of poison damage
double FastSpeed; // speed in fast mode double FastSpeed; // speed in fast mode
fixed_t RDFactor; // Radius damage factor double RDFactor; // Radius damage factor
double CameraHeight; // Height of camera when used as such double CameraHeight; // Height of camera when used as such
FSoundID HowlSound; // Sound being played when electrocuted or poisoned FSoundID HowlSound; // Sound being played when electrocuted or poisoned
FName BloodType; // Blood replacement type FName BloodType; // Blood replacement type

18
src/p_acs.cpp
View file

@ -3998,7 +3998,7 @@ void DLevelScript::DoSetActorProperty (AActor *actor, int property, int value)
break; break;
case APROP_MeleeRange: case APROP_MeleeRange:
actor->meleerange = value; actor->meleerange = ACSToDouble(value);
break; break;
case APROP_ViewHeight: case APROP_ViewHeight:
@ -4014,7 +4014,7 @@ void DLevelScript::DoSetActorProperty (AActor *actor, int property, int value)
case APROP_AttackZOffset: case APROP_AttackZOffset:
if (actor->IsKindOf (RUNTIME_CLASS (APlayerPawn))) if (actor->IsKindOf (RUNTIME_CLASS (APlayerPawn)))
static_cast<APlayerPawn *>(actor)->AttackZOffset = value; static_cast<APlayerPawn *>(actor)->AttackZOffset = ACSToDouble(value);
break; break;
case APROP_StencilColor: case APROP_StencilColor:
@ -4022,7 +4022,7 @@ void DLevelScript::DoSetActorProperty (AActor *actor, int property, int value)
break; break;
case APROP_Friction: case APROP_Friction:
actor->Friction = value; actor->Friction = ACSToDouble(value);
default: default:
// do nothing. // do nothing.
@ -4093,10 +4093,10 @@ int DLevelScript::GetActorProperty (int tid, int property)
case APROP_Mass: return actor->Mass; case APROP_Mass: return actor->Mass;
case APROP_Accuracy: return actor->accuracy; case APROP_Accuracy: return actor->accuracy;
case APROP_Stamina: return actor->stamina; case APROP_Stamina: return actor->stamina;
case APROP_Height: return actor->_f_height(); case APROP_Height: return DoubleToACS(actor->Height);
case APROP_Radius: return actor->_f_radius(); case APROP_Radius: return DoubleToACS(actor->radius);
case APROP_ReactionTime:return actor->reactiontime; case APROP_ReactionTime:return actor->reactiontime;
case APROP_MeleeRange: return actor->meleerange; case APROP_MeleeRange: return DoubleToACS(actor->meleerange);
case APROP_ViewHeight: if (actor->IsKindOf (RUNTIME_CLASS (APlayerPawn))) case APROP_ViewHeight: if (actor->IsKindOf (RUNTIME_CLASS (APlayerPawn)))
{ {
return DoubleToACS(static_cast<APlayerPawn *>(actor)->ViewHeight); return DoubleToACS(static_cast<APlayerPawn *>(actor)->ViewHeight);
@ -4108,7 +4108,7 @@ int DLevelScript::GetActorProperty (int tid, int property)
case APROP_AttackZOffset: case APROP_AttackZOffset:
if (actor->IsKindOf (RUNTIME_CLASS (APlayerPawn))) if (actor->IsKindOf (RUNTIME_CLASS (APlayerPawn)))
{ {
return static_cast<APlayerPawn *>(actor)->AttackZOffset; return DoubleToACS(static_cast<APlayerPawn *>(actor)->AttackZOffset);
} }
else else
{ {
@ -4123,7 +4123,7 @@ int DLevelScript::GetActorProperty (int tid, int property)
case APROP_Species: return GlobalACSStrings.AddString(actor->GetSpecies()); case APROP_Species: return GlobalACSStrings.AddString(actor->GetSpecies());
case APROP_NameTag: return GlobalACSStrings.AddString(actor->GetTag()); case APROP_NameTag: return GlobalACSStrings.AddString(actor->GetTag());
case APROP_StencilColor:return actor->fillcolor; case APROP_StencilColor:return actor->fillcolor;
case APROP_Friction: return actor->Friction; case APROP_Friction: return DoubleToACS(actor->Friction);
default: return 0; default: return 0;
} }
@ -5990,7 +5990,7 @@ doplaysound: if (funcIndex == ACSF_PlayActorSound)
if (activator == NULL || !reference) if (activator == NULL || !reference)
return false; return false;
if (P_Thing_Warp(activator, reference, xofs, yofs, zofs, angle, flags, heightoffset, radiusoffset, pitch)) if (P_Thing_Warp(activator, reference, ACSToDouble(xofs), ACSToDouble(yofs), ACSToDouble(zofs), ACSToAngle(angle), flags, ACSToDouble(heightoffset), ACSToDouble(radiusoffset), ACSToAngle(pitch)))
{ {
if (state && argCount > 6) if (state && argCount > 6)
{ {

4
src/p_effect.cpp
View file

@ -313,7 +313,7 @@ void P_ThinkParticles ()
} }
} }
void P_SpawnParticle(fixed_t x, fixed_t y, fixed_t z, fixed_t vx, fixed_t vy, fixed_t vz, PalEntry color, bool fullbright, BYTE startalpha, BYTE lifetime, WORD size, int fadestep, fixed_t accelx, fixed_t accely, fixed_t accelz) void P_SpawnParticle(fixed_t x, fixed_t y, fixed_t z, fixed_t vx, fixed_t vy, fixed_t vz, PalEntry color, bool fullbright, BYTE startalpha, BYTE lifetime, int size, int fadestep, fixed_t accelx, fixed_t accely, fixed_t accelz)
{ {
particle_t *particle = NewParticle(); particle_t *particle = NewParticle();
@ -334,7 +334,7 @@ void P_SpawnParticle(fixed_t x, fixed_t y, fixed_t z, fixed_t vx, fixed_t vy, fi
particle->accy = accely; particle->accy = accely;
particle->accz = accelz; particle->accz = accelz;
particle->bright = fullbright; particle->bright = fullbright;
particle->size = size; particle->size = (WORD)size;
} }
} }

7
src/p_effect.h
View file

@ -83,7 +83,12 @@ particle_t *JitterParticle (int ttl);
particle_t *JitterParticle (int ttl, double drift); particle_t *JitterParticle (int ttl, double drift);
void P_ThinkParticles (void); void P_ThinkParticles (void);
void P_SpawnParticle(fixed_t x, fixed_t y, fixed_t z, fixed_t vx, fixed_t vy, fixed_t vz, PalEntry color, bool fullbright, BYTE startalpha, BYTE lifetime, WORD size, int fadestep, fixed_t accelx, fixed_t accely, fixed_t accelz); void P_SpawnParticle(fixed_t x, fixed_t y, fixed_t z, fixed_t vx, fixed_t vy, fixed_t vz, PalEntry color, bool fullbright, BYTE startalpha, BYTE lifetime, int size, int fadestep, fixed_t accelx, fixed_t accely, fixed_t accelz);
inline void P_SpawnParticle(const DVector3 &pos, const DVector3 &vel, const DVector3 &accel, PalEntry color, bool fullbright, double startalpha, int lifetime, WORD size, double fadestep)
{
P_SpawnParticle(FLOAT2FIXED(pos.X), FLOAT2FIXED(pos.Y), FLOAT2FIXED(pos.Z), FLOAT2FIXED(vel.X), FLOAT2FIXED(vel.Y), FLOAT2FIXED(vel.Z),
color, fullbright, BYTE(startalpha * 255), BYTE(lifetime), WORD(size), fadestep < 0 ? -1 : int(fadestep * 255), FLOAT2FIXED(accel.X), FLOAT2FIXED(accel.Y), FLOAT2FIXED(accel.Z));
}
void P_InitEffects (void); void P_InitEffects (void);
void P_RunEffects (void); void P_RunEffects (void);

136
src/p_enemy.cpp
View file

@ -264,14 +264,14 @@ bool AActor::CheckMeleeRange ()
{ {
AActor *pl = target; AActor *pl = target;
fixed_t dist; double dist;
if (!pl) if (!pl)
return false; return false;
dist = AproxDistance (pl); dist = Distance2D (pl);
if (dist >= meleerange + pl->_f_radius()) if (dist >= meleerange + pl->radius)
return false; return false;
// [RH] If moving toward goal, then we've reached it. // [RH] If moving toward goal, then we've reached it.
@ -306,7 +306,7 @@ bool AActor::CheckMeleeRange ()
bool P_CheckMeleeRange2 (AActor *actor) bool P_CheckMeleeRange2 (AActor *actor)
{ {
AActor *mo; AActor *mo;
fixed_t dist; double dist;
if (!actor->target) if (!actor->target)
@ -314,8 +314,8 @@ bool P_CheckMeleeRange2 (AActor *actor)
return false; return false;
} }
mo = actor->target; mo = actor->target;
dist = mo->AproxDistance (actor); dist = mo->Distance2D (actor);
if (dist >= (128 << FRACBITS) || dist < actor->meleerange + mo->_f_radius()) if (dist >= 128 || dist < actor->meleerange + mo->radius)
{ {
return false; return false;
} }
@ -348,7 +348,7 @@ bool P_CheckMeleeRange2 (AActor *actor)
//============================================================================= //=============================================================================
bool P_CheckMissileRange (AActor *actor) bool P_CheckMissileRange (AActor *actor)
{ {
fixed_t dist; double dist;
if (!P_CheckSight (actor, actor->target, SF_SEEPASTBLOCKEVERYTHING)) if (!P_CheckSight (actor, actor->target, SF_SEEPASTBLOCKEVERYTHING))
return false; return false;
@ -387,15 +387,15 @@ bool P_CheckMissileRange (AActor *actor)
// OPTIMIZE: get this from a global checksight // OPTIMIZE: get this from a global checksight
// [RH] What? // [RH] What?
dist = actor->AproxDistance (actor->target) - 64*FRACUNIT; dist = actor->Distance2D (actor->target) - 64;
if (actor->MeleeState == NULL) if (actor->MeleeState == NULL)
dist -= 128*FRACUNIT; // no melee attack, so fire more dist -= 128; // no melee attack, so fire more
return actor->SuggestMissileAttack (dist); return actor->SuggestMissileAttack (dist);
} }
bool AActor::SuggestMissileAttack (fixed_t dist) bool AActor::SuggestMissileAttack (double dist)
{ {
// new version encapsulates the different behavior in flags instead of virtual functions // new version encapsulates the different behavior in flags instead of virtual functions
// The advantage is that this allows inheriting the missile attack attributes from the // The advantage is that this allows inheriting the missile attack attributes from the
@ -407,11 +407,11 @@ bool AActor::SuggestMissileAttack (fixed_t dist)
if (MeleeState != NULL && dist < meleethreshold) if (MeleeState != NULL && dist < meleethreshold)
return false; // From the Revenant: close enough for fist attack return false; // From the Revenant: close enough for fist attack
if (flags4 & MF4_MISSILEMORE) dist >>= 1; if (flags4 & MF4_MISSILEMORE) dist *= 0.5;
if (flags4 & MF4_MISSILEEVENMORE) dist >>= 3; if (flags4 & MF4_MISSILEEVENMORE) dist *= 0.125;
int mmc = int(MinMissileChance * G_SkillProperty(SKILLP_Aggressiveness)); int mmc = int(MinMissileChance * G_SkillProperty(SKILLP_Aggressiveness));
return pr_checkmissilerange() >= MIN<int> (dist >> FRACBITS, mmc); return pr_checkmissilerange() >= MIN<int> (int(dist), mmc);
} }
//============================================================================= //=============================================================================
@ -453,9 +453,9 @@ bool P_Move (AActor *actor)
fixed_t tryx, tryy, deltax, deltay, origx, origy; fixed_t tryx, tryy, deltax, deltay, origx, origy;
bool try_ok; bool try_ok;
int speed = actor->_f_speed(); fixed_t speed = actor->_f_speed();
int movefactor = ORIG_FRICTION_FACTOR; double movefactor = ORIG_FRICTION_FACTOR;
int friction = ORIG_FRICTION; double friction = ORIG_FRICTION;
int dropoff = 0; int dropoff = 0;
if (actor->flags2 & MF2_BLASTED) if (actor->flags2 & MF2_BLASTED)
@ -503,8 +503,7 @@ bool P_Move (AActor *actor)
if (friction < ORIG_FRICTION) if (friction < ORIG_FRICTION)
{ // sludge { // sludge
speed = ((ORIG_FRICTION_FACTOR - (ORIG_FRICTION_FACTOR-movefactor)/2) speed = fixed_t(speed * ((ORIG_FRICTION_FACTOR - (ORIG_FRICTION_FACTOR-movefactor)/2)) / ORIG_FRICTION_FACTOR);
* speed) / ORIG_FRICTION_FACTOR;
if (speed == 0) if (speed == 0)
{ // always give the monster a little bit of speed { // always give the monster a little bit of speed
speed = ksgn(actor->_f_speed()); speed = ksgn(actor->_f_speed());
@ -564,9 +563,9 @@ bool P_Move (AActor *actor)
if (try_ok && friction > ORIG_FRICTION) if (try_ok && friction > ORIG_FRICTION)
{ {
actor->SetOrigin(origx, origy, actor->_f_Z(), false); actor->SetOrigin(origx, origy, actor->_f_Z(), false);
movefactor *= FRACUNIT / ORIG_FRICTION_FACTOR / 4; movefactor *= 1.f / ORIG_FRICTION_FACTOR / 4;
actor->Vel.X += FIXED2DBL(FixedMul (deltax, movefactor)); actor->Vel.X += FIXED2DBL(deltax * movefactor);
actor->Vel.Y += FIXED2DBL(FixedMul (deltay, movefactor)); actor->Vel.Y += FIXED2DBL(deltay * movefactor);
} }
// [RH] If a walking monster is no longer on the floor, move it down // [RH] If a walking monster is no longer on the floor, move it down
@ -589,7 +588,7 @@ bool P_Move (AActor *actor)
else else
{ // The monster just hit the floor, so trigger any actions. { // The monster just hit the floor, so trigger any actions.
if (actor->floorsector->SecActTarget != NULL && if (actor->floorsector->SecActTarget != NULL &&
actor->_f_floorz() == actor->floorsector->floorplane.ZatPoint(actor->PosRelative(actor->floorsector))) actor->_f_floorz() == actor->floorsector->floorplane.ZatPoint(actor->_f_PosRelative(actor->floorsector)))
{ {
actor->floorsector->SecActTarget->TriggerAction(actor, SECSPAC_HitFloor); actor->floorsector->SecActTarget->TriggerAction(actor, SECSPAC_HitFloor);
} }
@ -899,8 +898,8 @@ void P_NewChaseDir(AActor * actor)
box.Bottom() < line->bbox[BOXTOP] && box.Bottom() < line->bbox[BOXTOP] &&
box.BoxOnLineSide(line) == -1) box.BoxOnLineSide(line) == -1)
{ {
double front = line->frontsector->floorplane.ZatPointF(actor->PosRelative(line)); double front = line->frontsector->floorplane.ZatPointF(actor->_f_PosRelative(line));
double back = line->backsector->floorplane.ZatPointF(actor->PosRelative(line)); double back = line->backsector->floorplane.ZatPointF(actor->_f_PosRelative(line));
DAngle angle; DAngle angle;
// The monster must contact one of the two floors, // The monster must contact one of the two floors,
@ -965,16 +964,16 @@ void P_NewChaseDir(AActor * actor)
if (actor->flags3 & MF3_AVOIDMELEE) if (actor->flags3 & MF3_AVOIDMELEE)
{ {
bool ismeleeattacker = false; bool ismeleeattacker = false;
fixed_t dist = actor->AproxDistance(target); double dist = actor->Distance2D(target);
if (target->player == NULL) if (target->player == NULL)
{ {
ismeleeattacker = (target->MissileState == NULL && dist < (target->meleerange + target->_f_radius())*2); ismeleeattacker = (target->MissileState == NULL && dist < (target->meleerange + target->radius)*2);
} }
else if (target->player->ReadyWeapon != NULL) else if (target->player->ReadyWeapon != NULL)
{ {
// melee range of player weapon is a parameter of the action function and cannot be checked here. // melee range of player weapon is a parameter of the action function and cannot be checked here.
// Add a new weapon property? // Add a new weapon property?
ismeleeattacker = (target->player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON && dist < (192 << FRACBITS)); ismeleeattacker = ((target->player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON) && dist < 192);
} }
if (ismeleeattacker) if (ismeleeattacker)
{ {
@ -1166,23 +1165,23 @@ void P_RandomChaseDir (AActor *actor)
bool P_IsVisible(AActor *lookee, AActor *other, INTBOOL allaround, FLookExParams *params) bool P_IsVisible(AActor *lookee, AActor *other, INTBOOL allaround, FLookExParams *params)
{ {
fixed_t maxdist; double maxdist;
fixed_t mindist; double mindist;
angle_t fov; DAngle fov;
if (params != NULL) if (params != NULL)
{ {
maxdist = params->maxdist; maxdist = params->maxDist;
mindist = params->mindist; mindist = params->minDist;
fov = params->fov; fov = params->Fov;
} }
else else
{ {
mindist = maxdist = 0; mindist = maxdist = 0;
fov = allaround ? 0 : ANGLE_180; fov = allaround ? 0. : 180.;
} }
fixed_t dist = lookee->AproxDistance (other); double dist = lookee->Distance2D (other);
if (maxdist && dist > maxdist) if (maxdist && dist > maxdist)
return false; // [KS] too far return false; // [KS] too far
@ -1190,15 +1189,15 @@ bool P_IsVisible(AActor *lookee, AActor *other, INTBOOL allaround, FLookExParams
if (mindist && dist < mindist) if (mindist && dist < mindist)
return false; // [KS] too close return false; // [KS] too close
if (fov && fov < ANGLE_MAX) if (fov != 0)
{ {
angle_t an = lookee->__f_AngleTo(other) - lookee->_f_angle(); DAngle an = absangle(lookee->AngleTo(other), lookee->Angles.Yaw);
if (an > (fov / 2) && an < (ANGLE_MAX - (fov / 2))) if (an > (fov / 2))
{ {
// if real close, react anyway // if real close, react anyway
// [KS] but respect minimum distance rules // [KS] but respect minimum distance rules
if (mindist || dist > lookee->meleerange + lookee->_f_radius()) if (mindist || dist > lookee->meleerange + lookee->radius)
return false; // outside of fov return false; // outside of fov
} }
} }
@ -1888,15 +1887,15 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_LookEx)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
PARAM_INT_OPT (flags) { flags = 0; } PARAM_INT_OPT (flags) { flags = 0; }
PARAM_FIXED_OPT (minseedist) { minseedist = 0; } PARAM_FLOAT_OPT (minseedist) { minseedist = 0; }
PARAM_FIXED_OPT (maxseedist) { maxseedist = 0; } PARAM_FLOAT_OPT (maxseedist) { maxseedist = 0; }
PARAM_FIXED_OPT (maxheardist) { maxheardist = 0; } PARAM_FLOAT_OPT (maxheardist) { maxheardist = 0; }
PARAM_FLOAT_OPT (fov_f) { fov_f = 0; } PARAM_ANGLE_OPT (fov) { fov = 0.; }
PARAM_STATE_OPT (seestate) { seestate = NULL; } PARAM_STATE_OPT (seestate) { seestate = NULL; }
AActor *targ = NULL; // Shuts up gcc AActor *targ = NULL; // Shuts up gcc
fixed_t dist; fixed_t dist;
angle_t fov = (fov_f == 0) ? ANGLE_180 : FLOAT2ANGLE(fov_f); if (fov == 0) fov = 180.;
FLookExParams params = { fov, minseedist, maxseedist, maxheardist, flags, seestate }; FLookExParams params = { fov, minseedist, maxseedist, maxheardist, flags, seestate };
if (self->flags5 & MF5_INCONVERSATION) if (self->flags5 & MF5_INCONVERSATION)
@ -2818,7 +2817,7 @@ enum FAF_Flags
FAF_TOP = 4, FAF_TOP = 4,
FAF_NODISTFACTOR = 8, // deprecated FAF_NODISTFACTOR = 8, // deprecated
}; };
void A_Face (AActor *self, AActor *other, angle_t _max_turn, angle_t _max_pitch, angle_t _ang_offset, angle_t _pitch_offset, int flags, fixed_t z_add) void A_Face(AActor *self, AActor *other, DAngle max_turn, DAngle max_pitch, DAngle ang_offset, DAngle pitch_offset, int flags, double z_add)
{ {
if (!other) if (!other)
return; return;
@ -2831,12 +2830,7 @@ void A_Face (AActor *self, AActor *other, angle_t _max_turn, angle_t _max_pitch,
self->flags &= ~MF_AMBUSH; self->flags &= ~MF_AMBUSH;
DAngle max_turn = ANGLE2DBL(_max_turn);
DAngle ang_offset = ANGLE2DBL(_ang_offset);
DAngle max_pitch = ANGLE2DBL(_max_pitch);
DAngle pitch_offset = ANGLE2DBL(_pitch_offset);
DAngle other_angle = self->AngleTo(other); DAngle other_angle = self->AngleTo(other);
DAngle delta = deltaangle(self->Angles.Yaw, other_angle); DAngle delta = deltaangle(self->Angles.Yaw, other_angle);
// 0 means no limit. Also, if we turn in a single step anyways, no need to go through the algorithms. // 0 means no limit. Also, if we turn in a single step anyways, no need to go through the algorithms.
@ -2883,7 +2877,7 @@ void A_Face (AActor *self, AActor *other, angle_t _max_turn, angle_t _max_pitch,
if (flags & FAF_TOP) if (flags & FAF_TOP)
target_z = other->Top() + other->GetBobOffset(); target_z = other->Top() + other->GetBobOffset();
target_z += FIXED2FLOAT(z_add); target_z += z_add;
double dist_z = target_z - source_z; double dist_z = target_z - source_z;
double ddist = g_sqrt(dist.X*dist.X + dist.Y*dist.Y + dist_z*dist_z); double ddist = g_sqrt(dist.X*dist.X + dist.Y*dist.Y + dist_z*dist_z);
@ -2927,12 +2921,12 @@ void A_FaceTarget(AActor *self)
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTarget) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTarget)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
PARAM_ANGLE_OPT(max_turn) { max_turn = 0; } PARAM_ANGLE_OPT(max_turn) { max_turn = 0.; }
PARAM_ANGLE_OPT(max_pitch) { max_pitch = 270; } PARAM_ANGLE_OPT(max_pitch) { max_pitch = 270.; }
PARAM_ANGLE_OPT(ang_offset) { ang_offset = 0; } PARAM_ANGLE_OPT(ang_offset) { ang_offset = 0.; }
PARAM_ANGLE_OPT(pitch_offset) { pitch_offset = 0; } PARAM_ANGLE_OPT(pitch_offset) { pitch_offset = 0.; }
PARAM_INT_OPT(flags) { flags = 0; } PARAM_INT_OPT(flags) { flags = 0; }
PARAM_FIXED_OPT(z_add) { z_add = 0; } PARAM_FLOAT_OPT(z_add) { z_add = 0; }
A_Face(self, self->target, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add); A_Face(self, self->target, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add);
return 0; return 0;
@ -2941,12 +2935,12 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTarget)
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceMaster) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceMaster)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
PARAM_ANGLE_OPT(max_turn) { max_turn = 0; } PARAM_ANGLE_OPT(max_turn) { max_turn = 0.; }
PARAM_ANGLE_OPT(max_pitch) { max_pitch = 270; } PARAM_ANGLE_OPT(max_pitch) { max_pitch = 270.; }
PARAM_ANGLE_OPT(ang_offset) { ang_offset = 0; } PARAM_ANGLE_OPT(ang_offset) { ang_offset = 0.; }
PARAM_ANGLE_OPT(pitch_offset) { pitch_offset = 0; } PARAM_ANGLE_OPT(pitch_offset) { pitch_offset = 0.; }
PARAM_INT_OPT(flags) { flags = 0; } PARAM_INT_OPT(flags) { flags = 0; }
PARAM_FIXED_OPT(z_add) { z_add = 0; } PARAM_FLOAT_OPT(z_add) { z_add = 0; }
A_Face(self, self->master, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add); A_Face(self, self->master, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add);
return 0; return 0;
@ -2955,12 +2949,12 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceMaster)
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTracer) DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTracer)
{ {
PARAM_ACTION_PROLOGUE; PARAM_ACTION_PROLOGUE;
PARAM_ANGLE_OPT(max_turn) { max_turn = 0; } PARAM_ANGLE_OPT(max_turn) { max_turn = 0.; }
PARAM_ANGLE_OPT(max_pitch) { max_pitch = 270; } PARAM_ANGLE_OPT(max_pitch) { max_pitch = 270.; }
PARAM_ANGLE_OPT(ang_offset) { ang_offset = 0; } PARAM_ANGLE_OPT(ang_offset) { ang_offset = 0.; }
PARAM_ANGLE_OPT(pitch_offset) { pitch_offset = 0; } PARAM_ANGLE_OPT(pitch_offset) { pitch_offset = 0.; }
PARAM_INT_OPT(flags) { flags = 0; } PARAM_INT_OPT(flags) { flags = 0; }
PARAM_FIXED_OPT(z_add) { z_add = 0; } PARAM_FLOAT_OPT(z_add) { z_add = 0; }
A_Face(self, self->tracer, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add); A_Face(self, self->tracer, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add);
return 0; return 0;
@ -3010,7 +3004,11 @@ DEFINE_ACTION_FUNCTION(AActor, A_MonsterRail)
self->Angles.Yaw += pr_railface.Random2() * 45./256; self->Angles.Yaw += pr_railface.Random2() * 45./256;
} }
P_RailAttack (self, self->GetMissileDamage (0, 1), 0); FRailParams p;
p.source = self;
p.damage = self->GetMissileDamage(0, 1);
P_RailAttack (&p);
self->Angles.Pitch = saved_pitch; self->Angles.Pitch = saved_pitch;
return 0; return 0;
} }

10
src/p_enemy.h
View file

@ -38,10 +38,10 @@ enum LO_Flags
struct FLookExParams struct FLookExParams
{ {
angle_t fov; DAngle Fov;
fixed_t mindist; double minDist;
fixed_t maxdist; double maxDist;
fixed_t maxheardist; double maxHeardist;
int flags; int flags;
FState *seestate; FState *seestate;
}; };
@ -78,7 +78,7 @@ void A_BossDeath(AActor *self);
void A_Wander(AActor *self, int flags = 0); void A_Wander(AActor *self, int flags = 0);
void A_Chase(VMFrameStack *stack, AActor *self); void A_Chase(VMFrameStack *stack, AActor *self);
void A_FaceTarget(AActor *actor); void A_FaceTarget(AActor *actor);
void A_Face(AActor *self, AActor *other, angle_t max_turn = 0, angle_t max_pitch = ANGLE_270, angle_t ang_offset = 0, angle_t pitch_offset = 0, int flags = 0, fixed_t z_add = 0); void A_Face(AActor *self, AActor *other, DAngle max_turn = 0., DAngle max_pitch = 270., DAngle ang_offset = 0., DAngle pitch_offset = 0., int flags = 0, double z_add = 0);
bool A_RaiseMobj (AActor *, double speed); bool A_RaiseMobj (AActor *, double speed);
bool A_SinkMobj (AActor *, double speed); bool A_SinkMobj (AActor *, double speed);

41
src/p_local.h
View file

@ -221,7 +221,7 @@ bool P_Thing_Raise(AActor *thing, AActor *raiser);
bool P_Thing_CanRaise(AActor *thing); bool P_Thing_CanRaise(AActor *thing);
PClassActor *P_GetSpawnableType(int spawnnum); PClassActor *P_GetSpawnableType(int spawnnum);
void InitSpawnablesFromMapinfo(); void InitSpawnablesFromMapinfo();
int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs, fixed_t zofs, angle_t angle, int flags, fixed_t heightoffset, fixed_t radiusoffset, angle_t pitch); int P_Thing_Warp(AActor *caller, AActor *reference, double xofs, double yofs, double zofs, DAngle angle, int flags, double heightoffset, double radiusoffset, DAngle pitch);
enum WARPF enum WARPF
{ {
@ -302,6 +302,10 @@ inline bool P_TryMove(AActor* thing, const DVector2 &pos, int dropoff, const sec
return P_TryMove(thing, FLOAT2FIXED(pos.X), FLOAT2FIXED(pos.Y), dropoff, onfloor, tm, missileCheck); return P_TryMove(thing, FLOAT2FIXED(pos.X), FLOAT2FIXED(pos.Y), dropoff, onfloor, tm, missileCheck);
} }
bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y); bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y);
inline bool P_CheckMove(AActor *thing, double x, double y)
{
return P_CheckMove(thing, FLOAT2FIXED(x), FLOAT2FIXED(y));
}
void P_ApplyTorque(AActor *mo); void P_ApplyTorque(AActor *mo);
bool P_TeleportMove (AActor* thing, fixed_t x, fixed_t y, fixed_t z, bool telefrag, bool modifyactor = true); // [RH] Added z and telefrag parameters bool P_TeleportMove (AActor* thing, fixed_t x, fixed_t y, fixed_t z, bool telefrag, bool modifyactor = true); // [RH] Added z and telefrag parameters
inline bool P_TeleportMove(AActor* thing, const fixedvec3 &pos, bool telefrag, bool modifyactor = true) inline bool P_TeleportMove(AActor* thing, const fixedvec3 &pos, bool telefrag, bool modifyactor = true)
@ -394,7 +398,28 @@ inline bool P_HitWater(AActor *thing, sector_t *sec, const fixedvec3 &pos, bool
return P_HitWater(thing, sec, fpos, checkabove, alert, force); return P_HitWater(thing, sec, fpos, checkabove, alert, force);
} }
void P_CheckSplash(AActor *self, double distance); void P_CheckSplash(AActor *self, double distance);
void P_RailAttack (AActor *source, int damage, int offset_xy, fixed_t offset_z = 0, int color1 = 0, int color2 = 0, double maxdiff = 0, int flags = 0, PClassActor *puff = NULL, angle_t angleoffset = 0, angle_t pitchoffset = 0, fixed_t distance = 8192*FRACUNIT, int duration = 0, double sparsity = 1.0, double drift = 1.0, PClassActor *spawnclass = NULL, int SpiralOffset = 270); // [RH] Shoot a railgun
struct FRailParams
{
AActor *source = nullptr;
int damage = 0;
double offset_xy = 0;
double offset_z = 0;
int color1 = 0, color2 = 0;
double maxdiff = 0;
int flags = 0;
PClassActor *puff = nullptr;
DAngle angleoffset = 0.;
DAngle pitchoffset = 0.;
double distance = 8192;
int duration = 0;
double sparsity = 1.0;
double drift = 1.0;
PClassActor *spawnclass = nullptr;
int SpiralOffset = 270;
}; // [RH] Shoot a railgun
void P_RailAttack(FRailParams *params);
enum // P_RailAttack / A_RailAttack / A_CustomRailgun / P_DrawRailTrail flags enum // P_RailAttack / A_RailAttack / A_CustomRailgun / P_DrawRailTrail flags
{ {
@ -428,16 +453,8 @@ void P_DelSector_List();
void P_DelSeclist(msecnode_t *); // phares 3/16/98 void P_DelSeclist(msecnode_t *); // phares 3/16/98
msecnode_t* P_DelSecnode(msecnode_t *); msecnode_t* P_DelSecnode(msecnode_t *);
void P_CreateSecNodeList(AActor*,fixed_t,fixed_t); // phares 3/14/98 void P_CreateSecNodeList(AActor*,fixed_t,fixed_t); // phares 3/14/98
int P_GetMoveFactor(const AActor *mo, int *frictionp); // phares 3/6/98 double P_GetMoveFactor(const AActor *mo, double *frictionp); // phares 3/6/98
inline double P_GetMoveFactor(const AActor *mo, double *frictionp) double P_GetFriction(const AActor *mo, double *frictionfactor);
{
int rv, fp;
rv = P_GetMoveFactor(mo, &fp);
*frictionp = FIXED2DBL(fp);
return FIXED2DBL(rv);
}
int P_GetFriction(const AActor *mo, int *frictionfactor);
bool Check_Sides(AActor *, int, int); // phares bool Check_Sides(AActor *, int, int); // phares
// [RH] // [RH]

144
src/p_map.cpp
View file

@ -587,14 +587,15 @@ void P_PlayerStartStomp(AActor *actor, bool mononly)
// //
//========================================================================== //==========================================================================
int P_GetFriction(const AActor *mo, int *frictionfactor) double P_GetFriction(const AActor *mo, double *frictionfactor)
{ {
int friction = ORIG_FRICTION; double friction = ORIG_FRICTION;
int movefactor = ORIG_FRICTION_FACTOR; double movefactor = ORIG_FRICTION_FACTOR;
fixed_t newfriction; double newfriction;
double newmf;
const msecnode_t *m; const msecnode_t *m;
sector_t *sec; sector_t *sec;
fixed_t newmf;
if (mo->IsNoClip2()) if (mo->IsNoClip2())
{ {
@ -608,7 +609,7 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
(mo->waterlevel == 1 && mo->Z() > mo->floorz+ 6)) (mo->waterlevel == 1 && mo->Z() > mo->floorz+ 6))
{ {
friction = mo->Sector->GetFriction(sector_t::floor, &movefactor); friction = mo->Sector->GetFriction(sector_t::floor, &movefactor);
movefactor >>= 1; movefactor *= 0.5;
// Check 3D floors -- might be the source of the waterlevel // Check 3D floors -- might be the source of the waterlevel
for (unsigned i = 0; i < mo->Sector->e->XFloor.ffloors.Size(); i++) for (unsigned i = 0; i < mo->Sector->e->XFloor.ffloors.Size(); i++)
@ -625,7 +626,7 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
if (newfriction < friction || friction == ORIG_FRICTION) if (newfriction < friction || friction == ORIG_FRICTION)
{ {
friction = newfriction; friction = newfriction;
movefactor = newmf >> 1; movefactor = newmf * 0.5;
} }
} }
} }
@ -637,7 +638,7 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
for (m = mo->touching_sectorlist; m; m = m->m_tnext) for (m = mo->touching_sectorlist; m; m = m->m_tnext)
{ {
sec = m->m_sector; sec = m->m_sector;
fixedvec3 pos = mo->PosRelative(sec); fixedvec3 pos = mo->_f_PosRelative(sec);
// 3D floors must be checked, too // 3D floors must be checked, too
for (unsigned i = 0; i < sec->e->XFloor.ffloors.Size(); i++) for (unsigned i = 0; i < sec->e->XFloor.ffloors.Size(); i++)
@ -648,13 +649,13 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
if (rover->flags & FF_SOLID) if (rover->flags & FF_SOLID)
{ {
// Must be standing on a solid floor // Must be standing on a solid floor
if (mo->_f_Z() != rover->top.plane->ZatPoint(pos)) continue; if (mo->Z() != rover->top.plane->ZatPointF(pos)) continue;
} }
else if (rover->flags & FF_SWIMMABLE) else if (rover->flags & FF_SWIMMABLE)
{ {
// Or on or inside a swimmable floor (e.g. in shallow water) // Or on or inside a swimmable floor (e.g. in shallow water)
if (mo->_f_Z() > rover->top.plane->ZatPoint(pos) || if (mo->Z() > rover->top.plane->ZatPointF(pos) ||
(mo->_f_Top()) < rover->bottom.plane->ZatPoint(pos)) (mo->Top()) < rover->bottom.plane->ZatPointF(pos))
continue; continue;
} }
else else
@ -664,7 +665,7 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
if (newfriction < friction || friction == ORIG_FRICTION) if (newfriction < friction || friction == ORIG_FRICTION)
{ {
friction = newfriction; friction = newfriction;
movefactor = newmf >> 1; movefactor = newmf * 0.5;
} }
} }
@ -675,9 +676,9 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
} }
newfriction = sec->GetFriction(sector_t::floor, &newmf); newfriction = sec->GetFriction(sector_t::floor, &newmf);
if ((newfriction < friction || friction == ORIG_FRICTION) && if ((newfriction < friction || friction == ORIG_FRICTION) &&
(mo->_f_Z() <= sec->floorplane.ZatPoint(pos) || (mo->Z() <= sec->floorplane.ZatPointF(pos) ||
(sec->GetHeightSec() != NULL && (sec->GetHeightSec() != NULL &&
mo->_f_Z() <= sec->heightsec->floorplane.ZatPoint(pos)))) mo->Z() <= sec->heightsec->floorplane.ZatPointF(pos))))
{ {
friction = newfriction; friction = newfriction;
movefactor = newmf; movefactor = newmf;
@ -685,9 +686,9 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
} }
} }
if (mo->Friction != FRACUNIT) if (mo->Friction != 1)
{ {
friction = clamp(FixedMul(friction, mo->Friction), 0, FRACUNIT); friction = clamp((friction * mo->Friction), 0., 1.);
movefactor = FrictionToMoveFactor(friction); movefactor = FrictionToMoveFactor(friction);
} }
@ -707,9 +708,9 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
// //
//========================================================================== //==========================================================================
int P_GetMoveFactor(const AActor *mo, int *frictionp) double P_GetMoveFactor(const AActor *mo, double *frictionp)
{ {
int movefactor, friction; double movefactor, friction;
// If the floor is icy or muddy, it's harder to get moving. This is where // If the floor is icy or muddy, it's harder to get moving. This is where
// the different friction factors are applied to 'trying to move'. In // the different friction factors are applied to 'trying to move'. In
@ -723,11 +724,11 @@ int P_GetMoveFactor(const AActor *mo, int *frictionp)
double velocity = mo->VelXYToSpeed(); double velocity = mo->VelXYToSpeed();
if (velocity > MORE_FRICTION_VELOCITY * 4) if (velocity > MORE_FRICTION_VELOCITY * 4)
movefactor <<= 3; movefactor *= 8;
else if (velocity > MORE_FRICTION_VELOCITY * 2) else if (velocity > MORE_FRICTION_VELOCITY * 2)
movefactor <<= 2; movefactor *= 4;
else if (velocity > MORE_FRICTION_VELOCITY) else if (velocity > MORE_FRICTION_VELOCITY)
movefactor <<= 1; movefactor *= 2;
} }
if (frictionp) if (frictionp)
@ -808,7 +809,7 @@ bool PIT_CheckLine(FMultiBlockLinesIterator &mit, FMultiBlockLinesIterator::Chec
spechit_t spec; spechit_t spec;
spec.line = ld; spec.line = ld;
spec.refpos = cres.position; spec.refpos = cres.position;
spec.oldrefpos = tm.thing->PosRelative(ld); spec.oldrefpos = tm.thing->_f_PosRelative(ld);
portalhit.Push(spec); portalhit.Push(spec);
return true; return true;
} }
@ -976,14 +977,14 @@ bool PIT_CheckLine(FMultiBlockLinesIterator &mit, FMultiBlockLinesIterator::Chec
{ {
spec.line = ld; spec.line = ld;
spec.refpos = cres.position; spec.refpos = cres.position;
spec.oldrefpos = tm.thing->PosRelative(ld); spec.oldrefpos = tm.thing->_f_PosRelative(ld);
spechit.Push(spec); spechit.Push(spec);
} }
if (ld->isLinePortal()) if (ld->isLinePortal())
{ {
spec.line = ld; spec.line = ld;
spec.refpos = cres.position; spec.refpos = cres.position;
spec.oldrefpos = tm.thing->PosRelative(ld); spec.oldrefpos = tm.thing->_f_PosRelative(ld);
portalhit.Push(spec); portalhit.Push(spec);
} }
@ -1241,7 +1242,7 @@ bool PIT_CheckThing(FMultiBlockThingsIterator &it, FMultiBlockThingsIterator::Ch
if (((tm.FromPMove || tm.thing->player != NULL) && thing->flags&MF_SOLID)) if (((tm.FromPMove || tm.thing->player != NULL) && thing->flags&MF_SOLID))
{ {
fixedvec3 oldpos = tm.thing->PosRelative(thing); fixedvec3 oldpos = tm.thing->_f_PosRelative(thing);
// Both actors already overlap. To prevent them from remaining stuck allow the move if it // Both actors already overlap. To prevent them from remaining stuck allow the move if it
// takes them further apart or the move does not change the position (when called from P_ChangeSector.) // takes them further apart or the move does not change the position (when called from P_ChangeSector.)
if (oldpos.x == thing->_f_X() && oldpos.y == thing->_f_Y()) if (oldpos.x == thing->_f_X() && oldpos.y == thing->_f_Y())
@ -1477,7 +1478,7 @@ bool PIT_CheckThing(FMultiBlockThingsIterator &it, FMultiBlockThingsIterator::Ch
{ // Push thing { // Push thing
if (thing->lastpush != tm.PushTime) if (thing->lastpush != tm.PushTime)
{ {
thing->Vel += tm.thing->Vel.XY() * thing->_pushfactor(); thing->Vel += tm.thing->Vel.XY() * thing->pushfactor;
thing->lastpush = tm.PushTime; thing->lastpush = tm.PushTime;
} }
} }
@ -1535,7 +1536,7 @@ bool PIT_CheckThing(FMultiBlockThingsIterator &it, FMultiBlockThingsIterator::Ch
{ // Push thing { // Push thing
if (thing->lastpush != tm.PushTime) if (thing->lastpush != tm.PushTime)
{ {
thing->Vel += tm.thing->Vel.XY() * thing->_pushfactor(); thing->Vel += tm.thing->Vel.XY() * thing->pushfactor;
thing->lastpush = tm.PushTime; thing->lastpush = tm.PushTime;
} }
} }
@ -1962,7 +1963,7 @@ static void CheckForPushSpecial(line_t *line, int side, AActor *mobj, fixedvec2
if (posforwindowcheck && !(ib_compatflags & BCOMPATF_NOWINDOWCHECK) && line->backsector != NULL) if (posforwindowcheck && !(ib_compatflags & BCOMPATF_NOWINDOWCHECK) && line->backsector != NULL)
{ // Make sure this line actually blocks us and is not a window { // Make sure this line actually blocks us and is not a window
// or similar construct we are standing inside of. // or similar construct we are standing inside of.
fixedvec3 pos = mobj->PosRelative(line); fixedvec3 pos = mobj->_f_PosRelative(line);
fixed_t fzt = line->frontsector->ceilingplane.ZatPoint(*posforwindowcheck); fixed_t fzt = line->frontsector->ceilingplane.ZatPoint(*posforwindowcheck);
fixed_t fzb = line->frontsector->floorplane.ZatPoint(*posforwindowcheck); fixed_t fzb = line->frontsector->floorplane.ZatPoint(*posforwindowcheck);
fixed_t bzt = line->backsector->ceilingplane.ZatPoint(*posforwindowcheck); fixed_t bzt = line->backsector->ceilingplane.ZatPoint(*posforwindowcheck);
@ -2697,7 +2698,7 @@ void FSlide::HitSlideLine(line_t* ld)
// The wall is angled. Bounce if the angle of approach is // phares // The wall is angled. Bounce if the angle of approach is // phares
// less than 45 degrees. // phares // less than 45 degrees. // phares
fixedvec3 pos = slidemo->PosRelative(ld); fixedvec3 pos = slidemo->_f_PosRelative(ld);
side = P_PointOnLineSide(pos.x, pos.y, ld); side = P_PointOnLineSide(pos.x, pos.y, ld);
lineangle = R_PointToAngle2(0, 0, ld->dx, ld->dy); lineangle = R_PointToAngle2(0, 0, ld->dx, ld->dy);
@ -2803,7 +2804,7 @@ void FSlide::SlideTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_t
if (!(li->flags & ML_TWOSIDED) || !li->backsector) if (!(li->flags & ML_TWOSIDED) || !li->backsector)
{ {
fixedvec3 pos = slidemo->PosRelative(li); fixedvec3 pos = slidemo->_f_PosRelative(li);
if (P_PointOnLineSide(pos.x, pos.y, li)) if (P_PointOnLineSide(pos.x, pos.y, li))
{ {
// don't hit the back side // don't hit the back side
@ -3019,7 +3020,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
return NULL; return NULL;
} }
fixedvec3 pos = actor->PosRelative(actor->floorsector); fixedvec3 pos = actor->_f_PosRelative(actor->floorsector);
const secplane_t *plane = &actor->floorsector->floorplane; const secplane_t *plane = &actor->floorsector->floorplane;
fixed_t planezhere = plane->ZatPoint(pos); fixed_t planezhere = plane->ZatPoint(pos);
@ -3099,7 +3100,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
sector_t *sec = node->m_sector; sector_t *sec = node->m_sector;
if (sec->floorplane.c >= STEEPSLOPE) if (sec->floorplane.c >= STEEPSLOPE)
{ {
fixedvec3 pos = actor->PosRelative(sec); fixedvec3 pos = actor->_f_PosRelative(sec);
pos.x += xmove; pos.x += xmove;
pos.y += ymove; pos.y += ymove;
@ -3296,7 +3297,7 @@ bool FSlide::BounceWall(AActor *mo)
deltaangle >>= ANGLETOFINESHIFT; deltaangle >>= ANGLETOFINESHIFT;
movelen = fixed_t(g_sqrt(double(mo->_f_velx())*mo->_f_velx() + double(mo->_f_vely())*mo->_f_vely())); movelen = fixed_t(g_sqrt(double(mo->_f_velx())*mo->_f_velx() + double(mo->_f_vely())*mo->_f_vely()));
movelen = FixedMul(movelen, mo->wallbouncefactor); movelen = fixed_t(movelen * mo->wallbouncefactor);
FBoundingBox box(mo->_f_X(), mo->_f_Y(), mo->_f_radius()); FBoundingBox box(mo->_f_X(), mo->_f_Y(), mo->_f_radius());
if (box.BoxOnLineSide(line) == -1) if (box.BoxOnLineSide(line) == -1)
@ -3356,7 +3357,7 @@ bool P_BounceActor(AActor *mo, AActor *BlockingMobj, bool ontop)
if (!ontop) if (!ontop)
{ {
DAngle angle = BlockingMobj->AngleTo(mo) + ((pr_bounce() % 16) - 8); DAngle angle = BlockingMobj->AngleTo(mo) + ((pr_bounce() % 16) - 8);
double speed = mo->VelXYToSpeed() * FIXED2DBL(mo->wallbouncefactor); // [GZ] was 0.75, using wallbouncefactor seems more consistent double speed = mo->VelXYToSpeed() * mo->wallbouncefactor; // [GZ] was 0.75, using wallbouncefactor seems more consistent
mo->Angles.Yaw = ANGLE2DBL(angle); mo->Angles.Yaw = ANGLE2DBL(angle);
mo->VelFromAngle(speed); mo->VelFromAngle(speed);
mo->PlayBounceSound(true); mo->PlayBounceSound(true);
@ -3393,13 +3394,13 @@ bool P_BounceActor(AActor *mo, AActor *BlockingMobj, bool ontop)
} }
else else
{ {
mo->Vel.Z *= mo->_bouncefactor(); mo->Vel.Z *= mo->bouncefactor;
} }
} }
else // Don't run through this for MBF-style bounces else // Don't run through this for MBF-style bounces
{ {
// The reflected velocity keeps only about 70% of its original speed // The reflected velocity keeps only about 70% of its original speed
mo->Vel.Z = (mo->Vel.Z - 2. / dot) * mo->_bouncefactor(); mo->Vel.Z = (mo->Vel.Z - 2. / dot) * mo->bouncefactor;
} }
mo->PlayBounceSound(true); mo->PlayBounceSound(true);
@ -4026,7 +4027,7 @@ DAngle P_AimLineAttack(AActor *t1, DAngle angle, double distance, FTranslatedLin
fixed_t shootz = t1->_f_Z() + (t1->_f_height() >> 1) - t1->_f_floorclip(); fixed_t shootz = t1->_f_Z() + (t1->_f_height() >> 1) - t1->_f_floorclip();
if (t1->player != NULL) if (t1->player != NULL)
{ {
shootz += fixed_t(t1->player->mo->AttackZOffset * t1->player->crouchfactor); shootz += FLOAT2FIXED(t1->player->mo->AttackZOffset * t1->player->crouchfactor);
} }
else else
{ {
@ -4171,7 +4172,7 @@ AActor *P_LineAttack(AActor *t1, DAngle angle, double distance,
shootz = t1->_f_Z() - t1->_f_floorclip() + (t1->_f_height() >> 1); shootz = t1->_f_Z() - t1->_f_floorclip() + (t1->_f_height() >> 1);
if (t1->player != NULL) if (t1->player != NULL)
{ {
shootz += fixed_t(t1->player->mo->AttackZOffset * t1->player->crouchfactor); shootz += FLOAT2FIXED(t1->player->mo->AttackZOffset * t1->player->crouchfactor);
if (damageType == NAME_Melee || damageType == NAME_Hitscan) if (damageType == NAME_Melee || damageType == NAME_Hitscan)
{ {
// this is coming from a weapon attack function which needs to transfer information to the obituary code, // this is coming from a weapon attack function which needs to transfer information to the obituary code,
@ -4432,7 +4433,7 @@ AActor *P_LinePickActor(AActor *t1, angle_t angle, fixed_t distance, int pitch,
shootz = t1->_f_Z() - t1->_f_floorclip() + (t1->_f_height() >> 1); shootz = t1->_f_Z() - t1->_f_floorclip() + (t1->_f_height() >> 1);
if (t1->player != NULL) if (t1->player != NULL)
{ {
shootz += fixed_t(t1->player->mo->AttackZOffset * t1->player->crouchfactor); shootz += FLOAT2FIXED(t1->player->mo->AttackZOffset * t1->player->crouchfactor);
} }
else else
{ {
@ -4680,51 +4681,45 @@ static ETraceStatus ProcessRailHit(FTraceResults &res, void *userdata)
// //
// //
//========================================================================== //==========================================================================
void P_RailAttack(AActor *source, int damage, int offset_xy, fixed_t offset_z, int color1, int color2, double maxdiff, int railflags, PClassActor *puffclass, angle_t angleoffset, angle_t pitchoffset, fixed_t distance, int duration, double sparsity, double drift, PClassActor *spawnclass, int SpiralOffset) void P_RailAttack(FRailParams *p)
{ {
fixed_t vx, vy, vz; DVector3 start;
angle_t angle, pitch;
DVector3 start, end;
FTraceResults trace; FTraceResults trace;
fixed_t shootz;
PClassActor *puffclass = p->puff;
if (puffclass == NULL) if (puffclass == NULL)
{ {
puffclass = PClass::FindActor(NAME_BulletPuff); puffclass = PClass::FindActor(NAME_BulletPuff);
} }
pitch = ((angle_t)(-source->_f_pitch()) + pitchoffset) >> ANGLETOFINESHIFT; AActor *source = p->source;
angle = (source->_f_angle() + angleoffset) >> ANGLETOFINESHIFT; DAngle pitch = -source->Angles.Pitch + p->pitchoffset;
DAngle angle = source->Angles.Yaw + p->angleoffset;
vx = FixedMul(finecosine[pitch], finecosine[angle]); DVector3 vec(DRotator(pitch, angle, angle));
vy = FixedMul(finecosine[pitch], finesine[angle]); double shootz = source->Center() - source->FloatSpeed + p->offset_z;
vz = finesine[pitch];
shootz = source->_f_Z() - source->_f_floorclip() + (source->_f_height() >> 1) + offset_z; if (!(p->flags & RAF_CENTERZ))
if (!(railflags & RAF_CENTERZ))
{ {
if (source->player != NULL) if (source->player != NULL)
{ {
shootz += fixed_t(source->player->mo->AttackZOffset * source->player->crouchfactor); shootz += source->player->mo->AttackZOffset * source->player->crouchfactor;
} }
else else
{ {
shootz += 8 * FRACUNIT; shootz += 8;
} }
} }
angle = ((source->_f_angle() + angleoffset) - ANG90) >> ANGLETOFINESHIFT; DVector2 xy = source->Vec2Angle(p->offset_xy, angle - 90.);
fixedvec2 xy = source->Vec2Offset(offset_xy * finecosine[angle], offset_xy * finesine[angle]);
RailData rail_data; RailData rail_data;
rail_data.Caller = source; rail_data.Caller = source;
rail_data.StopAtOne = !!(railflags & RAF_NOPIERCE); rail_data.StopAtOne = !!(p->flags & RAF_NOPIERCE);
start.X = FIXED2DBL(xy.x); start.X = xy.X;
start.Y = FIXED2DBL(xy.y); start.Y = xy.Y;
start.Z = FIXED2DBL(shootz); start.Z = shootz;
int flags; int flags;
@ -4734,9 +4729,7 @@ void P_RailAttack(AActor *source, int damage, int offset_xy, fixed_t offset_z, i
flags = (puffDefaults->flags6 & MF6_NOTRIGGER) ? 0 : TRACE_PCross | TRACE_Impact; flags = (puffDefaults->flags6 & MF6_NOTRIGGER) ? 0 : TRACE_PCross | TRACE_Impact;
rail_data.StopAtInvul = (puffDefaults->flags3 & MF3_FOILINVUL) ? false : true; rail_data.StopAtInvul = (puffDefaults->flags3 & MF3_FOILINVUL) ? false : true;
rail_data.ThruSpecies = (puffDefaults->flags6 & MF6_MTHRUSPECIES) ? true : false; rail_data.ThruSpecies = (puffDefaults->flags6 & MF6_MTHRUSPECIES) ? true : false;
Trace(xy.x, xy.y, shootz, source->Sector, vx, vy, vz, Trace(start, source->Sector, vec, p->distance, MF_SHOOTABLE, ML_BLOCKEVERYTHING, source, trace, flags, ProcessRailHit, &rail_data);
distance, MF_SHOOTABLE, ML_BLOCKEVERYTHING, source, trace,
flags, ProcessRailHit, &rail_data);
// Hurt anything the trace hit // Hurt anything the trace hit
unsigned int i; unsigned int i;
@ -4749,8 +4742,6 @@ void P_RailAttack(AActor *source, int damage, int offset_xy, fixed_t offset_z, i
for (i = 0; i < rail_data.RailHits.Size(); i++) for (i = 0; i < rail_data.RailHits.Size(); i++)
{ {
bool spawnpuff; bool spawnpuff;
bool bleed = false; bool bleed = false;
@ -4788,12 +4779,12 @@ void P_RailAttack(AActor *source, int damage, int offset_xy, fixed_t offset_z, i
if (puffDefaults->flags3 & MF3_FOILINVUL) dmgFlagPass |= DMG_FOILINVUL; if (puffDefaults->flags3 & MF3_FOILINVUL) dmgFlagPass |= DMG_FOILINVUL;
if (puffDefaults->flags7 & MF7_FOILBUDDHA) dmgFlagPass |= DMG_FOILBUDDHA; if (puffDefaults->flags7 & MF7_FOILBUDDHA) dmgFlagPass |= DMG_FOILBUDDHA;
} }
int newdam = P_DamageMobj(hitactor, thepuff ? thepuff : source, source, damage, damagetype, dmgFlagPass|DMG_USEANGLE, hitangle); int newdam = P_DamageMobj(hitactor, thepuff ? thepuff : source, source, p->damage, damagetype, dmgFlagPass|DMG_USEANGLE, hitangle);
if (bleed) if (bleed)
{ {
P_SpawnBlood(hitpos, hitangle, newdam > 0 ? newdam : damage, hitactor); P_SpawnBlood(hitpos, hitangle, newdam > 0 ? newdam : p->damage, hitactor);
P_TraceBleed(newdam > 0 ? newdam : damage, hitpos, hitactor, hitangle, ANGLE2DBL(pitch)); P_TraceBleed(newdam > 0 ? newdam : p->damage, hitpos, hitactor, hitangle, ANGLE2DBL(pitch));
} }
} }
@ -4842,8 +4833,7 @@ void P_RailAttack(AActor *source, int damage, int offset_xy, fixed_t offset_z, i
} }
// Draw the slug's trail. // Draw the slug's trail.
end = trace.HitPos; P_DrawRailTrail(source, start, trace.HitPos, p->color1, p->color2, p->maxdiff, p->flags, p->spawnclass, angle.BAMs(), p->duration, p->sparsity, p->drift, p->SpiralOffset);
P_DrawRailTrail(source, start, end, color1, color2, maxdiff, railflags, spawnclass, source->_f_angle() + angleoffset, duration, sparsity, drift, SpiralOffset);
} }
//========================================================================== //==========================================================================
@ -5091,8 +5081,6 @@ bool P_NoWayTraverse(AActor *usething, fixed_t startx, fixed_t starty, fixed_t e
// //
//========================================================================== //==========================================================================
CVAR(Int, userange, 0, 0);
void P_UseLines(player_t *player) void P_UseLines(player_t *player)
{ {
bool foundline = false; bool foundline = false;
@ -5100,7 +5088,7 @@ void P_UseLines(player_t *player)
// If the player is transitioning a portal, use the group that is at its vertical center. // If the player is transitioning a portal, use the group that is at its vertical center.
fixedvec2 start = player->mo->GetPortalTransition(player->mo->_f_height() / 2); fixedvec2 start = player->mo->GetPortalTransition(player->mo->_f_height() / 2);
// [NS] Now queries the Player's UseRange. // [NS] Now queries the Player's UseRange.
fixedvec2 end = start + Vec2Angle(userange > 0? fixed_t(userange<<FRACBITS) : player->mo->UseRange, player->mo->_f_angle()); fixedvec2 end = start + Vec2Angle(FLOAT2FIXED(player->mo->UseRange), player->mo->_f_angle());
// old code: // old code:
// //
@ -5140,7 +5128,7 @@ bool P_UsePuzzleItem(AActor *PuzzleItemUser, int PuzzleItemType)
// [NS] If it's a Player, get their UseRange. // [NS] If it's a Player, get their UseRange.
if (PuzzleItemUser->player) if (PuzzleItemUser->player)
usedist = PuzzleItemUser->player->mo->UseRange; usedist = FLOAT2FIXED(PuzzleItemUser->player->mo->UseRange);
else else
usedist = USERANGE; usedist = USERANGE;
@ -5328,7 +5316,7 @@ void P_RadiusAttack(AActor *bombspot, AActor *bombsource, int bombdamage, int bo
{ {
points = points * splashfactor; points = points * splashfactor;
} }
points *= thing->GetClass()->RDFactor / (float)FRACUNIT; points *= thing->GetClass()->RDFactor;
// points and bombdamage should be the same sign // points and bombdamage should be the same sign
if (((points * bombdamage) > 0) && P_CheckSight(thing, bombspot, SF_IGNOREVISIBILITY | SF_IGNOREWATERBOUNDARY)) if (((points * bombdamage) > 0) && P_CheckSight(thing, bombspot, SF_IGNOREVISIBILITY | SF_IGNOREWATERBOUNDARY))
@ -5400,9 +5388,9 @@ void P_RadiusAttack(AActor *bombspot, AActor *bombsource, int bombdamage, int bo
{ // OK to damage; target is in direct path { // OK to damage; target is in direct path
dist = clamp<int>(dist - fulldamagedistance, 0, dist); dist = clamp<int>(dist - fulldamagedistance, 0, dist);
int damage = Scale(bombdamage, bombdistance - dist, bombdistance); int damage = Scale(bombdamage, bombdistance - dist, bombdistance);
damage = (int)((double)damage * splashfactor);
damage = Scale(damage, thing->GetClass()->RDFactor, FRACUNIT); double factor = splashfactor * thing->GetClass()->RDFactor;
damage = int(damage * factor);
if (damage > 0) if (damage > 0)
{ {
int newdam = P_DamageMobj(thing, bombspot, bombsource, damage, bombmod); int newdam = P_DamageMobj(thing, bombspot, bombsource, damage, bombmod);

2
src/p_maputl.cpp
View file

@ -497,7 +497,7 @@ void AActor::LinkToWorld(bool spawningmapthing, sector_t *sector)
for (int i = -1; i < (int)check.Size(); i++) for (int i = -1; i < (int)check.Size(); i++)
{ {
fixedvec3 pos = i==-1? _f_Pos() : PosRelative(check[i]); fixedvec3 pos = i==-1? _f_Pos() : _f_PosRelative(check[i]);
int x1 = GetSafeBlockX(pos.x - _f_radius() - bmaporgx); int x1 = GetSafeBlockX(pos.x - _f_radius() - bmaporgx);
int x2 = GetSafeBlockX(pos.x + _f_radius() - bmaporgx); int x2 = GetSafeBlockX(pos.x + _f_radius() - bmaporgx);

4
src/p_maputl.h
View file

@ -356,6 +356,10 @@ public:
FMultiBlockThingsIterator(FPortalGroupArray &check, AActor *origin, fixed_t checkradius = -1, bool ignorerestricted = false); FMultiBlockThingsIterator(FPortalGroupArray &check, AActor *origin, fixed_t checkradius = -1, bool ignorerestricted = false);
FMultiBlockThingsIterator(FPortalGroupArray &check, fixed_t checkx, fixed_t checky, fixed_t checkz, fixed_t checkh, fixed_t checkradius, bool ignorerestricted, sector_t *newsec); FMultiBlockThingsIterator(FPortalGroupArray &check, fixed_t checkx, fixed_t checky, fixed_t checkz, fixed_t checkh, fixed_t checkradius, bool ignorerestricted, sector_t *newsec);
FMultiBlockThingsIterator(FPortalGroupArray &check, double checkx, double checky, double checkz, double checkh, double checkradius, bool ignorerestricted, sector_t *newsec)
: FMultiBlockThingsIterator(check, FLOAT2FIXED(checkx), FLOAT2FIXED(checky), FLOAT2FIXED(checkz), FLOAT2FIXED(checkh), FLOAT2FIXED(checkradius), ignorerestricted, newsec)
{
}
bool Next(CheckResult *item); bool Next(CheckResult *item);
void Reset(); void Reset();
const FBoundingBox &Box() const const FBoundingBox &Box() const

56
src/p_mobj.cpp
View file

@ -1388,7 +1388,7 @@ void P_ExplodeMissile (AActor *mo, line_t *line, AActor *target)
if (line != NULL && cl_missiledecals) if (line != NULL && cl_missiledecals)
{ {
fixedvec3 pos = mo->PosRelative(line); fixedvec3 pos = mo->_f_PosRelative(line);
int side = P_PointOnLineSidePrecise (pos.x, pos.y, line); int side = P_PointOnLineSidePrecise (pos.x, pos.y, line);
if (line->sidedef[side] == NULL) if (line->sidedef[side] == NULL)
side ^= 1; side ^= 1;
@ -1583,12 +1583,12 @@ bool AActor::FloorBounceMissile (secplane_t &plane)
flags &= ~MF_INBOUNCE; flags &= ~MF_INBOUNCE;
return false; return false;
} }
else Vel.Z *= _bouncefactor(); else Vel.Z *= bouncefactor;
} }
else // Don't run through this for MBF-style bounces else // Don't run through this for MBF-style bounces
{ {
// The reflected velocity keeps only about 70% of its original speed // The reflected velocity keeps only about 70% of its original speed
Vel = (Vel - plane.Normal() * dot) * _bouncefactor(); Vel = (Vel - plane.Normal() * dot) * bouncefactor;
AngleFromVel(); AngleFromVel();
} }
@ -2116,7 +2116,7 @@ explode:
if (tm.ceilingline && if (tm.ceilingline &&
tm.ceilingline->backsector && tm.ceilingline->backsector &&
tm.ceilingline->backsector->GetTexture(sector_t::ceiling) == skyflatnum && tm.ceilingline->backsector->GetTexture(sector_t::ceiling) == skyflatnum &&
mo->_f_Z() >= tm.ceilingline->backsector->ceilingplane.ZatPoint(mo->PosRelative(tm.ceilingline))) mo->_f_Z() >= tm.ceilingline->backsector->ceilingplane.ZatPoint(mo->_f_PosRelative(tm.ceilingline)))
{ {
// Hack to prevent missiles exploding against the sky. // Hack to prevent missiles exploding against the sky.
// Does not handle sky floors. // Does not handle sky floors.
@ -2269,7 +2269,7 @@ explode:
// Reducing player velocity is no longer needed to reduce // Reducing player velocity is no longer needed to reduce
// bobbing, so ice works much better now. // bobbing, so ice works much better now.
double friction = FIXED2DBL(P_GetFriction (mo, NULL)); double friction = P_GetFriction (mo, NULL);
mo->Vel.X *= friction; mo->Vel.X *= friction;
mo->Vel.Y *= friction; mo->Vel.Y *= friction;
@ -2280,8 +2280,8 @@ explode:
if (player && player->mo == mo) // Not voodoo dolls if (player && player->mo == mo) // Not voodoo dolls
{ {
player->Vel.X *= fORIG_FRICTION; player->Vel.X *= ORIG_FRICTION;
player->Vel.Y *= fORIG_FRICTION; player->Vel.Y *= ORIG_FRICTION;
} }
// Don't let the velocity become less than the smallest representable fixed point value. // Don't let the velocity become less than the smallest representable fixed point value.
@ -2452,11 +2452,11 @@ void P_ZMovement (AActor *mo, fixed_t oldfloorz)
{ {
mo->_f_AddZ(finesine[(FINEANGLES/80*level.maptime)&FINEMASK]/8); mo->_f_AddZ(finesine[(FINEANGLES/80*level.maptime)&FINEMASK]/8);
} }
mo->Vel.Z *= fFRICTION_FLY; mo->Vel.Z *= FRICTION_FLY;
} }
if (mo->waterlevel && !(mo->flags & MF_NOGRAVITY)) if (mo->waterlevel && !(mo->flags & MF_NOGRAVITY))
{ {
fixed_t friction = FIXED_MIN; double friction = -1;
// Check 3D floors -- might be the source of the waterlevel // Check 3D floors -- might be the source of the waterlevel
for (auto rover : mo->Sector->e->XFloor.ffloors) for (auto rover : mo->Sector->e->XFloor.ffloors)
@ -2464,17 +2464,17 @@ void P_ZMovement (AActor *mo, fixed_t oldfloorz)
if (!(rover->flags & FF_EXISTS)) continue; if (!(rover->flags & FF_EXISTS)) continue;
if (!(rover->flags & FF_SWIMMABLE)) continue; if (!(rover->flags & FF_SWIMMABLE)) continue;
if (mo->_f_Z() >= rover->top.plane->ZatPoint(mo) || if (mo->Z() >= rover->top.plane->ZatPointF(mo) ||
mo->_f_Z() + mo->_f_height()/2 < rover->bottom.plane->ZatPoint(mo)) mo->Center() < rover->bottom.plane->ZatPointF(mo))
continue; continue;
friction = rover->model->GetFriction(rover->top.isceiling); friction = rover->model->GetFriction(rover->top.isceiling);
break; break;
} }
if (friction == FIXED_MIN) if (friction < 0)
friction = mo->Sector->GetFriction(); // get real friction, even if from a terrain definition friction = mo->Sector->GetFriction(); // get real friction, even if from a terrain definition
mo->Vel.Z *= FIXED2DBL(friction); mo->Vel.Z *= friction;
} }
// //
@ -2716,7 +2716,7 @@ static void PlayerLandedOnThing (AActor *mo, AActor *onmobj)
{ {
grunted = false; grunted = false;
// Why should this number vary by gravity? // Why should this number vary by gravity?
if (mo->health > 0 && mo->_f_velz() < -mo->player->mo->GruntSpeed) if (mo->health > 0 && mo->Vel.Z < -mo->player->mo->GruntSpeed)
{ {
S_Sound (mo, CHAN_VOICE, "*grunt", 1, ATTN_NORM); S_Sound (mo, CHAN_VOICE, "*grunt", 1, ATTN_NORM);
grunted = true; grunted = true;
@ -3263,7 +3263,7 @@ fixedvec3 AActor::GetPortalTransition(fixed_t byoffset, sector_t **pSec)
AActor *port = sec->SkyBoxes[sector_t::ceiling]; AActor *port = sec->SkyBoxes[sector_t::ceiling];
if (testz > port->specialf1) if (testz > port->specialf1)
{ {
pos = PosRelative(port->Sector); pos = _f_PosRelative(port->Sector);
sec = P_PointInSector(pos.x, pos.y); sec = P_PointInSector(pos.x, pos.y);
moved = true; moved = true;
} }
@ -3276,7 +3276,7 @@ fixedvec3 AActor::GetPortalTransition(fixed_t byoffset, sector_t **pSec)
AActor *port = sec->SkyBoxes[sector_t::floor]; AActor *port = sec->SkyBoxes[sector_t::floor];
if (testz <= port->specialf1) if (testz <= port->specialf1)
{ {
pos = PosRelative(port->Sector); pos = _f_PosRelative(port->Sector);
sec = P_PointInSector(pos.x, pos.y); sec = P_PointInSector(pos.x, pos.y);
} }
else break; else break;
@ -3298,7 +3298,7 @@ void AActor::CheckPortalTransition(bool islinked)
{ {
fixedvec3 oldpos = _f_Pos(); fixedvec3 oldpos = _f_Pos();
if (islinked && !moved) UnlinkFromWorld(); if (islinked && !moved) UnlinkFromWorld();
SetXYZ(PosRelative(port->Sector)); SetXYZ(_f_PosRelative(port->Sector));
PrevX += _f_X() - oldpos.x; PrevX += _f_X() - oldpos.x;
PrevY += _f_Y() - oldpos.y; PrevY += _f_Y() - oldpos.y;
PrevZ += _f_Z() - oldpos.z; PrevZ += _f_Z() - oldpos.z;
@ -3317,7 +3317,7 @@ void AActor::CheckPortalTransition(bool islinked)
{ {
fixedvec3 oldpos = _f_Pos(); fixedvec3 oldpos = _f_Pos();
if (islinked && !moved) UnlinkFromWorld(); if (islinked && !moved) UnlinkFromWorld();
SetXYZ(PosRelative(port->Sector)); SetXYZ(_f_PosRelative(port->Sector));
PrevX += _f_X() - oldpos.x; PrevX += _f_X() - oldpos.x;
PrevY += _f_Y() - oldpos.y; PrevY += _f_Y() - oldpos.y;
PrevZ += _f_Z() - oldpos.z; PrevZ += _f_Z() - oldpos.z;
@ -3681,7 +3681,7 @@ void AActor::Tick ()
{ {
continue; continue;
} }
fixedvec3 pos = PosRelative(sec); fixedvec3 pos = _f_PosRelative(sec);
height = sec->floorplane.ZatPoint (pos); height = sec->floorplane.ZatPoint (pos);
if (_f_Z() > height) if (_f_Z() > height)
{ {
@ -3731,7 +3731,7 @@ void AActor::Tick ()
floorplane = P_FindFloorPlane(floorsector, _f_X(), _f_Y(), _f_floorz()); floorplane = P_FindFloorPlane(floorsector, _f_X(), _f_Y(), _f_floorz());
if (floorplane.c < STEEPSLOPE && if (floorplane.c < STEEPSLOPE &&
floorplane.ZatPoint (PosRelative(floorsector)) <= _f_floorz()) floorplane.ZatPoint (_f_PosRelative(floorsector)) <= _f_floorz())
{ {
const msecnode_t *node; const msecnode_t *node;
bool dopush = true; bool dopush = true;
@ -3743,7 +3743,7 @@ void AActor::Tick ()
const sector_t *sec = node->m_sector; const sector_t *sec = node->m_sector;
if (sec->floorplane.c >= STEEPSLOPE) if (sec->floorplane.c >= STEEPSLOPE)
{ {
if (floorplane.ZatPointF (PosRelative(node->m_sector)) >= Z() - MaxStepHeight) if (floorplane.ZatPointF (_f_PosRelative(node->m_sector)) >= Z() - MaxStepHeight)
{ {
dopush = false; dopush = false;
break; break;
@ -4517,7 +4517,7 @@ void AActor::AdjustFloorClip ()
// do the floorclipping instead of the terrain type. // do the floorclipping instead of the terrain type.
for (m = touching_sectorlist; m; m = m->m_tnext) for (m = touching_sectorlist; m; m = m->m_tnext)
{ {
fixedvec3 pos = PosRelative(m->m_sector); fixedvec3 pos = _f_PosRelative(m->m_sector);
sector_t *hsec = m->m_sector->GetHeightSec(); sector_t *hsec = m->m_sector->GetHeightSec();
if (hsec == NULL && m->m_sector->floorplane.ZatPoint (pos) == _f_Z()) if (hsec == NULL && m->m_sector->floorplane.ZatPoint (pos) == _f_Z())
{ {
@ -5684,7 +5684,7 @@ bool P_HitFloor (AActor *thing)
fixedvec3 pos; fixedvec3 pos;
for (m = thing->touching_sectorlist; m; m = m->m_tnext) for (m = thing->touching_sectorlist; m; m = m->m_tnext)
{ {
pos = thing->PosRelative(m->m_sector); pos = thing->_f_PosRelative(m->m_sector);
if (thing->_f_Z() == m->m_sector->floorplane.ZatPoint(pos.x, pos.y)) if (thing->_f_Z() == m->m_sector->floorplane.ZatPoint(pos.x, pos.y))
{ {
break; break;
@ -5729,7 +5729,7 @@ void P_CheckSplash(AActor *self, double distance)
// Explosion splashes never alert monsters. This is because A_Explode has // Explosion splashes never alert monsters. This is because A_Explode has
// a separate parameter for that so this would get in the way of proper // a separate parameter for that so this would get in the way of proper
// behavior. // behavior.
fixedvec3 pos = self->PosRelative(floorsec); fixedvec3 pos = self->_f_PosRelative(floorsec);
pos.z = self->_f_floorz(); pos.z = self->_f_floorz();
P_HitWater (self, floorsec, pos, false, false); P_HitWater (self, floorsec, pos, false, false);
} }
@ -6144,7 +6144,7 @@ AActor *P_SpawnPlayerMissile (AActor *source, double x, double y, double z,
// [XA] If MaxTargetRange is defined in the spawned projectile, use this as the // [XA] If MaxTargetRange is defined in the spawned projectile, use this as the
// maximum range for the P_AimLineAttack call later; this allows MaxTargetRange // maximum range for the P_AimLineAttack call later; this allows MaxTargetRange
// to function as a "maximum tracer-acquisition range" for seeker missiles. // to function as a "maximum tracer-acquisition range" for seeker missiles.
double linetargetrange = defaultobject->maxtargetrange > 0 ? FIXED2DBL(defaultobject->maxtargetrange*64) : 16*64.; double linetargetrange = defaultobject->maxtargetrange > 0 ? defaultobject->maxtargetrange*64 : 16*64.;
int i = 2; int i = 2;
do do
@ -6177,7 +6177,7 @@ AActor *P_SpawnPlayerMissile (AActor *source, double x, double y, double z,
z += source->Center() - source->Floorclip; z += source->Center() - source->Floorclip;
if (source->player != NULL) // Considering this is for player missiles, it better not be NULL. if (source->player != NULL) // Considering this is for player missiles, it better not be NULL.
{ {
z += ((FIXED2DBL(source->player->mo->AttackZOffset) - 4) * source->player->crouchfactor); z += ((source->player->mo->AttackZOffset - 4) * source->player->crouchfactor);
} }
else else
{ {
@ -6672,8 +6672,8 @@ void PrintMiscActorInfo(AActor *query)
for (flagi = 0; flagi <= 31; flagi++) for (flagi = 0; flagi <= 31; flagi++)
if (query->flags7 & ActorFlags7::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags7)); if (query->flags7 & ActorFlags7::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags7));
Printf("\nBounce flags: %x\nBounce factors: f:%f, w:%f", Printf("\nBounce flags: %x\nBounce factors: f:%f, w:%f",
query->BounceFlags.GetValue(), FIXED2DBL(query->bouncefactor), query->BounceFlags.GetValue(), query->bouncefactor,
FIXED2DBL(query->wallbouncefactor)); query->wallbouncefactor);
/*for (flagi = 0; flagi < 31; flagi++) /*for (flagi = 0; flagi < 31; flagi++)
if (query->BounceFlags & 1<<flagi) Printf(" %s", flagnamesb[flagi]);*/ if (query->BounceFlags & 1<<flagi) Printf(" %s", flagnamesb[flagi]);*/
Printf("\nRender style = %i:%s, alpha %f\nRender flags: %x", Printf("\nRender style = %i:%s, alpha %f\nRender flags: %x",

2
src/p_pspr.cpp
View file

@ -419,7 +419,7 @@ void P_BobWeapon (player_t *player, pspdef_t *psp, float *x, float *y)
{ {
float bobx = float(player->bob * Rangex); float bobx = float(player->bob * Rangex);
float boby = float(player->bob * Rangey); float boby = float(player->bob * Rangey);
switch (level.levelnum)//bobstyle) switch (bobstyle)
{ {
case AWeapon::BobNormal: case AWeapon::BobNormal:
*x = bobx * angle.Cos(); *x = bobx * angle.Cos();

2
src/p_sectors.cpp
View file

@ -1027,7 +1027,7 @@ fixed_t sector_t::NextLowestFloorAt(fixed_t x, fixed_t y, fixed_t z, int flags,
// //
//=========================================================================== //===========================================================================
fixed_t sector_t::GetFriction(int plane, fixed_t *pMoveFac) const double sector_t::GetFriction(int plane, double *pMoveFac) const
{ {
if (Flags & SECF_FRICTION) if (Flags & SECF_FRICTION)
{ {

4
src/p_sight.cpp
View file

@ -112,8 +112,8 @@ public:
void init(AActor * t1, AActor * t2, sector_t *startsector, SightTask *task, int flags) void init(AActor * t1, AActor * t2, sector_t *startsector, SightTask *task, int flags)
{ {
sightstart = t1->PosRelative(task->portalgroup); sightstart = t1->_f_PosRelative(task->portalgroup);
sightend = t2->PosRelative(task->portalgroup); sightend = t2->_f_PosRelative(task->portalgroup);
sightstart.z += t1->_f_height() - (t1->_f_height() >> 2); sightstart.z += t1->_f_height() - (t1->_f_height() >> 2);
startfrac = task->frac; startfrac = task->frac;

34
src/p_spec.cpp
View file

@ -1224,12 +1224,12 @@ void P_InitSectorSpecial(sector_t *sector, int special, bool nothinkers)
break; break;
case dSector_DoorRaiseIn5Mins: case dSector_DoorRaiseIn5Mins:
new DDoor (sector, DDoor::doorWaitRaise, 2*FRACUNIT, TICRATE*30/7, 5*60*TICRATE, 0); new DDoor (sector, DDoor::doorWaitRaise, 2*FRACUNIT, TICRATE*30/7, 0, 5*60*TICRATE);
break; break;
case dFriction_Low: case dFriction_Low:
sector->friction = FRICTION_LOW; sector->friction = FRICTION_LOW;
sector->movefactor = 0x269; sector->movefactor = 0x269/65536.;
sector->Flags |= SECF_FRICTION; sector->Flags |= SECF_FRICTION;
break; break;
@ -2076,7 +2076,7 @@ static void P_SpawnFriction(void)
} }
else else
{ {
length = P_AproxDistance(l->dx,l->dy)>>FRACBITS; length = int(l->Delta().Length());
} }
P_SetSectorFriction (l->args[0], length, false); P_SetSectorFriction (l->args[0], length, false);
@ -2088,14 +2088,14 @@ static void P_SpawnFriction(void)
void P_SetSectorFriction (int tag, int amount, bool alterFlag) void P_SetSectorFriction (int tag, int amount, bool alterFlag)
{ {
int s; int s;
fixed_t friction, movefactor; double friction, movefactor;
// An amount of 100 should result in a friction of // An amount of 100 should result in a friction of
// ORIG_FRICTION (0xE800) // ORIG_FRICTION (0xE800)
friction = (0x1EB8*amount)/0x80 + 0xD001; friction = ((0x1EB8 * amount) / 0x80 + 0xD001) / 65536.;
// killough 8/28/98: prevent odd situations // killough 8/28/98: prevent odd situations
friction = clamp(friction, 0, FRACUNIT); friction = clamp(friction, 0., 1.);
// The following check might seem odd. At the time of movement, // The following check might seem odd. At the time of movement,
// the move distance is multiplied by 'friction/0x10000', so a // the move distance is multiplied by 'friction/0x10000', so a
@ -2133,6 +2133,26 @@ void P_SetSectorFriction (int tag, int amount, bool alterFlag)
} }
} }
double FrictionToMoveFactor(double friction)
{
double movefactor;
// [RH] Twiddled these values so that velocity on ice (with
// friction 0xf900) is the same as in Heretic/Hexen.
if (friction >= ORIG_FRICTION) // ice
//movefactor = ((0x10092 - friction)*(0x70))/0x158;
movefactor = (((0x10092 - friction * 65536) * 1024) / 4352 + 568) / 65536.;
else
movefactor = (((friction*65536. - 0xDB34)*(0xA)) / 0x80) / 65536.;
// killough 8/28/98: prevent odd situations
if (movefactor < 1 / 2048.)
movefactor = 1 / 2048.;
return movefactor;
}
// //
// phares 3/12/98: End of friction effects // phares 3/12/98: End of friction effects
// //
@ -2314,7 +2334,7 @@ void DPusher::Tick ()
continue; continue;
sector_t *hsec = sec->GetHeightSec(); sector_t *hsec = sec->GetHeightSec();
fixedvec3 pos = thing->PosRelative(sec); fixedvec3 pos = thing->_f_PosRelative(sec);
DVector2 pushvel; DVector2 pushvel;
if (m_Type == p_wind) if (m_Type == p_wind)
{ {

23
src/p_spec.h
View file

@ -170,26 +170,7 @@ void P_PlayerInSpecialSector (player_t *player, sector_t * sector=NULL);
void P_PlayerOnSpecialFlat (player_t *player, int floorType); void P_PlayerOnSpecialFlat (player_t *player, int floorType);
void P_SectorDamage(int tag, int amount, FName type, PClassActor *protectClass, int flags); void P_SectorDamage(int tag, int amount, FName type, PClassActor *protectClass, int flags);
void P_SetSectorFriction (int tag, int amount, bool alterFlag); void P_SetSectorFriction (int tag, int amount, bool alterFlag);
double FrictionToMoveFactor(double friction);
inline fixed_t FrictionToMoveFactor(fixed_t friction)
{
fixed_t movefactor;
// [RH] Twiddled these values so that velocity on ice (with
// friction 0xf900) is the same as in Heretic/Hexen.
if (friction >= ORIG_FRICTION) // ice
// movefactor = ((0x10092 - friction)*(0x70))/0x158;
movefactor = ((0x10092 - friction) * 1024) / 4352 + 568;
else
movefactor = ((friction - 0xDB34)*(0xA))/0x80;
// killough 8/28/98: prevent odd situations
if (movefactor < 32)
movefactor = 32;
return movefactor;
}
void P_GiveSecret(AActor *actor, bool printmessage, bool playsound, int sectornum); void P_GiveSecret(AActor *actor, bool printmessage, bool playsound, int sectornum);
// //
@ -532,7 +513,7 @@ public:
}; };
DDoor (sector_t *sector); DDoor (sector_t *sector);
DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int topcountdown, int lightTag); DDoor (sector_t *sec, EVlDoor type, fixed_t speed, int delay, int lightTag, int topcountdown);
void Serialize (FArchive &arc); void Serialize (FArchive &arc);
void Tick (); void Tick ();

2
src/p_switch.cpp
View file

@ -140,7 +140,7 @@ bool P_CheckSwitchRange(AActor *user, line_t *line, int sideno, fixedvec3 *optpo
P_MakeDivline (line, &dll); P_MakeDivline (line, &dll);
fixedvec3 pos = optpos? *optpos : user->PosRelative(line); fixedvec3 pos = optpos? *optpos : user->_f_PosRelative(line);
dlu.x = pos.x; dlu.x = pos.x;
dlu.y = pos.y; dlu.y = pos.y;
dlu.dx = finecosine[user->_f_angle() >> ANGLETOFINESHIFT]; dlu.dx = finecosine[user->_f_angle() >> ANGLETOFINESHIFT];

10
src/p_terrain.cpp
View file

@ -488,15 +488,15 @@ static void ParseDamage (FScanner &sc, int keyword, void *fields)
static void ParseFriction (FScanner &sc, int keyword, void *fields) static void ParseFriction (FScanner &sc, int keyword, void *fields)
{ {
FTerrainDef *def = (FTerrainDef *)fields; FTerrainDef *def = (FTerrainDef *)fields;
fixed_t friction, movefactor; double friction, movefactor;
sc.MustGetFloat (); sc.MustGetFloat ();
// These calculations should match those in P_SetSectorFriction(). // These calculations should match those in P_SetSectorFriction().
// A friction of 1.0 is equivalent to ORIG_FRICTION. // A friction of 1.0 is equivalent to ORIG_FRICTION.
friction = (fixed_t)(0x1EB8*(sc.Float*100))/0x80 + 0xD001; friction = (0x1EB8*(sc.Float*100))/0x80 + 0xD001;
friction = clamp<fixed_t> (friction, 0, FRACUNIT); friction = clamp<double> (friction, 0, 65536.);
if (friction > ORIG_FRICTION) // ice if (friction > ORIG_FRICTION) // ice
movefactor = ((0x10092 - friction) * 1024) / 4352 + 568; movefactor = ((0x10092 - friction) * 1024) / 4352 + 568;
@ -506,8 +506,8 @@ static void ParseFriction (FScanner &sc, int keyword, void *fields)
if (movefactor < 32) if (movefactor < 32)
movefactor = 32; movefactor = 32;
def->Friction = friction; def->Friction = friction / 65536.;
def->MoveFactor = movefactor; def->MoveFactor = movefactor / 65536.;
} }
//========================================================================== //==========================================================================

4
src/p_terrain.h
View file

@ -115,8 +115,8 @@ struct FTerrainDef
FSoundID RightStepSound; FSoundID RightStepSound;
bool IsLiquid; bool IsLiquid;
bool AllowProtection; bool AllowProtection;
fixed_t Friction; double Friction;
fixed_t MoveFactor; double MoveFactor;
}; };
extern TArray<FSplashDef> Splashes; extern TArray<FSplashDef> Splashes;

51
src/p_things.cpp
View file

@ -670,7 +670,7 @@ void InitSpawnablesFromMapinfo()
} }
int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs, fixed_t zofs, angle_t angle, int flags, fixed_t heightoffset, fixed_t radiusoffset, angle_t pitch) int P_Thing_Warp(AActor *caller, AActor *reference, double xofs, double yofs, double zofs, DAngle angle, int flags, double heightoffset, double radiusoffset, DAngle pitch)
{ {
if (flags & WARPF_MOVEPTR) if (flags & WARPF_MOVEPTR)
{ {
@ -679,32 +679,33 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
caller = temp; caller = temp;
} }
fixedvec3 old = caller->_f_Pos(); DVector3 old = caller->Pos();
int oldpgroup = caller->Sector->PortalGroup; int oldpgroup = caller->Sector->PortalGroup;
zofs += FixedMul(reference->_f_height(), heightoffset); zofs += reference->Height * heightoffset;
if (!(flags & WARPF_ABSOLUTEANGLE)) if (!(flags & WARPF_ABSOLUTEANGLE))
{ {
angle += (flags & WARPF_USECALLERANGLE) ? caller->_f_angle() : reference->_f_angle(); angle += (flags & WARPF_USECALLERANGLE) ? caller->Angles.Yaw: reference->Angles.Yaw;
} }
const fixed_t rad = FixedMul(radiusoffset, reference->_f_radius()); const double rad = radiusoffset * reference->radius;
const angle_t fineangle = angle >> ANGLETOFINESHIFT; const double s = angle.Sin();
const double c = angle.Cos();
if (!(flags & WARPF_ABSOLUTEPOSITION)) if (!(flags & WARPF_ABSOLUTEPOSITION))
{ {
if (!(flags & WARPF_ABSOLUTEOFFSET)) if (!(flags & WARPF_ABSOLUTEOFFSET))
{ {
fixed_t xofs1 = xofs; double xofs1 = xofs;
// (borrowed from A_SpawnItemEx, assumed workable) // (borrowed from A_SpawnItemEx, assumed workable)
// in relative mode negative y values mean 'left' and positive ones mean 'right' // in relative mode negative y values mean 'left' and positive ones mean 'right'
// This is the inverse orientation of the absolute mode! // This is the inverse orientation of the absolute mode!
xofs = FixedMul(xofs1, finecosine[fineangle]) + FixedMul(yofs, finesine[fineangle]); xofs = xofs1 * c + yofs * s;
yofs = FixedMul(xofs1, finesine[fineangle]) - FixedMul(yofs, finecosine[fineangle]); yofs = xofs1 * s - yofs * c;
} }
if (flags & WARPF_TOFLOOR) if (flags & WARPF_TOFLOOR)
@ -713,30 +714,21 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
// now the caller's floorz should be appropriate for the assigned xy-position // now the caller's floorz should be appropriate for the assigned xy-position
// assigning position again with. // assigning position again with.
// extra unlink, link and environment calculation // extra unlink, link and environment calculation
caller->SetOrigin(reference->Vec3Offset( caller->SetOrigin(reference->Vec3Offset(xofs + rad * c, yofs + rad * s, 0.), true);
xofs + FixedMul(rad, finecosine[fineangle]), // The two-step process is important.
yofs + FixedMul(rad, finesine[fineangle]), caller->SetZ(caller->floorz + zofs);
0), true);
caller->_f_SetZ(caller->_f_floorz() + zofs);
} }
else else
{ {
caller->SetOrigin(reference->Vec3Offset( caller->SetOrigin(reference->Vec3Offset(xofs + rad * c, yofs + rad * s, zofs), true);
xofs + FixedMul(rad, finecosine[fineangle]),
yofs + FixedMul(rad, finesine[fineangle]),
zofs), true);
} }
} }
else // [MC] The idea behind "absolute" is meant to be "absolute". Override everything, just like A_SpawnItemEx's. else // [MC] The idea behind "absolute" is meant to be "absolute". Override everything, just like A_SpawnItemEx's.
{ {
caller->SetOrigin(xofs + rad * c, yofs + rad * s, zofs, true);
if (flags & WARPF_TOFLOOR) if (flags & WARPF_TOFLOOR)
{ {
caller->SetOrigin(xofs + FixedMul(rad, finecosine[fineangle]), yofs + FixedMul(rad, finesine[fineangle]), zofs, true); caller->SetZ(caller->floorz + zofs);
caller->_f_SetZ(caller->_f_floorz() + zofs);
}
else
{
caller->SetOrigin(xofs + FixedMul(rad, finecosine[fineangle]), yofs + FixedMul(rad, finesine[fineangle]), zofs, true);
} }
} }
@ -748,13 +740,13 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
} }
else else
{ {
caller->Angles.Yaw = ANGLE2DBL(angle); caller->Angles.Yaw = angle;
if (flags & WARPF_COPYPITCH) if (flags & WARPF_COPYPITCH)
caller->SetPitch(reference->Angles.Pitch, false); caller->SetPitch(reference->Angles.Pitch, false);
if (pitch) if (pitch != 0)
caller->SetPitch(caller->Angles.Pitch + ANGLE2DBL(pitch), false); caller->SetPitch(caller->Angles.Pitch + pitch, false);
if (flags & WARPF_COPYVELOCITY) if (flags & WARPF_COPYVELOCITY)
{ {
@ -765,6 +757,7 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
caller->Vel.Zero(); caller->Vel.Zero();
} }
#if 0 // needs fixing
// this is no fun with line portals // this is no fun with line portals
if (flags & WARPF_WARPINTERPOLATION) if (flags & WARPF_WARPINTERPOLATION)
{ {
@ -789,9 +782,11 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
{ {
caller->ClearInterpolation(); caller->ClearInterpolation();
} }
#endif
if ((flags & WARPF_BOB) && (reference->flags2 & MF2_FLOATBOB)) if ((flags & WARPF_BOB) && (reference->flags2 & MF2_FLOATBOB))
{ {
caller->_f_AddZ(reference->_f_GetBobOffset()); caller->AddZ(reference->GetBobOffset());
} }
} }
return true; return true;

14
src/p_user.cpp
View file

@ -648,9 +648,9 @@ void APlayerPawn::Serialize (FArchive &arc)
<< FlechetteType; << FlechetteType;
if (SaveVersion < 3829) if (SaveVersion < 3829)
{ {
GruntSpeed = 12*FRACUNIT; GruntSpeed = 12;
FallingScreamMinSpeed = 35*FRACUNIT; FallingScreamMinSpeed = 35;
FallingScreamMaxSpeed = 40*FRACUNIT; FallingScreamMaxSpeed = 40;
} }
else else
{ {
@ -1265,7 +1265,7 @@ bool APlayerPawn::ResetAirSupply (bool playgasp)
{ {
S_Sound (this, CHAN_VOICE, "*gasp", 1, ATTN_NORM); S_Sound (this, CHAN_VOICE, "*gasp", 1, ATTN_NORM);
} }
if (level.airsupply> 0 && player->mo->AirCapacity > 0) player->air_finished = level.time + FixedMul(level.airsupply, player->mo->AirCapacity); if (level.airsupply> 0 && player->mo->AirCapacity > 0) player->air_finished = level.time + int(level.airsupply * player->mo->AirCapacity);
else player->air_finished = INT_MAX; else player->air_finished = INT_MAX;
return wasdrowning; return wasdrowning;
} }
@ -1967,7 +1967,7 @@ void P_MovePlayer (player_t *player)
double fm, sm; double fm, sm;
movefactor = P_GetMoveFactor (mo, &friction); movefactor = P_GetMoveFactor (mo, &friction);
bobfactor = friction < ORIG_FRICTION ? movefactor : fORIG_FRICTION_FACTOR; bobfactor = friction < ORIG_FRICTION ? movefactor : ORIG_FRICTION_FACTOR;
if (!player->onground && !(player->mo->flags & MF_NOGRAVITY) && !player->mo->waterlevel) if (!player->onground && !(player->mo->flags & MF_NOGRAVITY) && !player->mo->waterlevel)
{ {
// [RH] allow very limited movement if not on ground. // [RH] allow very limited movement if not on ground.
@ -2618,8 +2618,8 @@ void P_PlayerThink (player_t *player)
// Player must be touching the floor // Player must be touching the floor
P_PlayerOnSpecialFlat(player, P_GetThingFloorType(player->mo)); P_PlayerOnSpecialFlat(player, P_GetThingFloorType(player->mo));
} }
if (player->mo->_f_velz() <= -player->mo->FallingScreamMinSpeed && if (player->mo->Vel.Z <= -player->mo->FallingScreamMinSpeed &&
player->mo->_f_velz() >= -player->mo->FallingScreamMaxSpeed && !player->morphTics && player->mo->Vel.Z >= -player->mo->FallingScreamMaxSpeed && !player->morphTics &&
player->mo->waterlevel == 0) player->mo->waterlevel == 0)
{ {
int id = S_FindSkinnedSound (player->mo, "*falling"); int id = S_FindSkinnedSound (player->mo, "*falling");

2
src/portal.cpp
View file

@ -156,6 +156,8 @@ static void BuildBlockmap()
void FLinePortalTraverse::AddLineIntercepts(int bx, int by) void FLinePortalTraverse::AddLineIntercepts(int bx, int by)
{ {
if (by < 0 || by >= bmapheight || bx < 0 || bx >= bmapwidth) return;
FPortalBlock &block = PortalBlockmap(bx, by); FPortalBlock &block = PortalBlockmap(bx, by);
for (unsigned i = 0; i<block.portallines.Size(); i++) for (unsigned i = 0; i<block.portallines.Size(); i++)

14
src/r_defs.h
View file

@ -624,7 +624,7 @@ struct sector_t
int GetFloorLight () const; int GetFloorLight () const;
int GetCeilingLight () const; int GetCeilingLight () const;
sector_t *GetHeightSec() const; sector_t *GetHeightSec() const;
fixed_t GetFriction(int plane = sector_t::floor, fixed_t *movefac = NULL) const; double GetFriction(int plane = sector_t::floor, double *movefac = NULL) const;
DInterpolation *SetInterpolation(int position, bool attach); DInterpolation *SetInterpolation(int position, bool attach);
@ -959,7 +959,7 @@ struct sector_t
// killough 8/28/98: friction is a sector property, not an mobj property. // killough 8/28/98: friction is a sector property, not an mobj property.
// these fields used to be in AActor, but presented performance problems // these fields used to be in AActor, but presented performance problems
// when processed as mobj properties. Fix is to make them sector properties. // when processed as mobj properties. Fix is to make them sector properties.
fixed_t friction, movefactor; double friction, movefactor;
int terrainnum[2]; int terrainnum[2];
@ -1445,27 +1445,27 @@ inline sector_t *P_PointInSector(const DVector2 &pos)
return P_PointInSubsector(FLOAT2FIXED(pos.X), FLOAT2FIXED(pos.Y))->sector; return P_PointInSubsector(FLOAT2FIXED(pos.X), FLOAT2FIXED(pos.Y))->sector;
} }
inline fixedvec3 AActor::PosRelative(int portalgroup) const inline fixedvec3 AActor::_f_PosRelative(int portalgroup) const
{ {
return __pos + Displacements.getOffset(Sector->PortalGroup, portalgroup); return __pos + Displacements.getOffset(Sector->PortalGroup, portalgroup);
} }
inline fixedvec3 AActor::PosRelative(const AActor *other) const inline fixedvec3 AActor::_f_PosRelative(const AActor *other) const
{ {
return __pos + Displacements.getOffset(Sector->PortalGroup, other->Sector->PortalGroup); return __pos + Displacements.getOffset(Sector->PortalGroup, other->Sector->PortalGroup);
} }
inline fixedvec3 AActor::PosRelative(sector_t *sec) const inline fixedvec3 AActor::_f_PosRelative(sector_t *sec) const
{ {
return __pos + Displacements.getOffset(Sector->PortalGroup, sec->PortalGroup); return __pos + Displacements.getOffset(Sector->PortalGroup, sec->PortalGroup);
} }
inline fixedvec3 AActor::PosRelative(line_t *line) const inline fixedvec3 AActor::_f_PosRelative(line_t *line) const
{ {
return __pos + Displacements.getOffset(Sector->PortalGroup, line->frontsector->PortalGroup); return __pos + Displacements.getOffset(Sector->PortalGroup, line->frontsector->PortalGroup);
} }
inline fixedvec3 PosRelative(const fixedvec3 &pos, line_t *line, sector_t *refsec = NULL) inline fixedvec3 _f_PosRelative(const fixedvec3 &pos, line_t *line, sector_t *refsec = NULL)
{ {
return pos + Displacements.getOffset(refsec->PortalGroup, line->frontsector->PortalGroup); return pos + Displacements.getOffset(refsec->PortalGroup, line->frontsector->PortalGroup);
} }

2
src/r_plane.cpp
View file

@ -1243,7 +1243,7 @@ void R_DrawSkyBoxes ()
viewx = viewpos.x; viewx = viewpos.x;
viewy = viewpos.y; viewy = viewpos.y;
viewz = viewpos.z; viewz = viewpos.z;
viewangle = savedangle + FLOAT2ANGLE(sky->PrevAngles.Yaw.Degrees) + FixedMul(r_TicFrac, sky->_f_angle() - FLOAT2ANGLE(sky->PrevAngles.Yaw.Degrees)); viewangle = savedangle + (sky->PrevAngles.Yaw + (sky->Angles.Yaw * r_TicFracF) - sky->PrevAngles.Yaw).BAMs();
R_CopyStackedViewParameters(); R_CopyStackedViewParameters();
} }

1
src/sc_man_scanner.re
View file

@ -193,7 +193,6 @@ std2:
/* other DECORATE top level keywords */ /* other DECORATE top level keywords */
'#include' { RET(TK_Include); } '#include' { RET(TK_Include); }
'fixed_t' { RET(TK_Fixed_t); } 'fixed_t' { RET(TK_Fixed_t); }
'angle_t' { RET(TK_Angle_t); }
L (L|D)* { RET(TK_Identifier); } L (L|D)* { RET(TK_Identifier); }

1
src/sc_man_tokens.h
View file

@ -112,7 +112,6 @@ xx(TK_Self, "'self'")
xx(TK_Stop, "'stop'") xx(TK_Stop, "'stop'")
xx(TK_Include, "'include'") xx(TK_Include, "'include'")
xx(TK_Fixed_t, "'fixed_t'") xx(TK_Fixed_t, "'fixed_t'")
xx(TK_Angle_t, "'angle_t'")
xx(TK_Is, "'is'") xx(TK_Is, "'is'")
xx(TK_Replaces, "'replaces'") xx(TK_Replaces, "'replaces'")

2
src/textures/textures.h
View file

@ -228,7 +228,7 @@ public:
int GetScaledWidth () { int foo = (Width << 17) / xScale; return (foo >> 1) + (foo & 1); } int GetScaledWidth () { int foo = (Width << 17) / xScale; return (foo >> 1) + (foo & 1); }
int GetScaledHeight () { int foo = (Height << 17) / yScale; return (foo >> 1) + (foo & 1); } int GetScaledHeight () { int foo = (Height << 17) / yScale; return (foo >> 1) + (foo & 1); }
int GetScaledHeight(double scale) { return GetScaledHeight(FLOAT2FIXED(scale)); } int GetScaledHeight(double scale) { int foo = (Height << 17) / FLOAT2FIXED(scale); return (foo >> 1) + (foo & 1); }
double GetScaledWidthDouble () { return (Width * 65536.) / xScale; } double GetScaledWidthDouble () { return (Width * 65536.) / xScale; }
double GetScaledHeightDouble () { return (Height * 65536.) / yScale; } double GetScaledHeightDouble () { return (Height * 65536.) / yScale; }
double GetScaleY() const { return FIXED2DBL(yScale); } double GetScaleY() const { return FIXED2DBL(yScale); }

3
src/thingdef/thingdef.h
View file

@ -326,9 +326,6 @@ int MatchString (const char *in, const char **strings);
#define PROP_DOUBLE_PARM(var, no) \ #define PROP_DOUBLE_PARM(var, no) \
double var = params[(no)+1].d; double var = params[(no)+1].d;
#define PROP_FIXED_PARM(var, no) \
fixed_t var = FLOAT2FIXED(params[(no)+1].d);
#define PROP_COLOR_PARM(var, no) \ #define PROP_COLOR_PARM(var, no) \
int var = params[(no)+1].i== 0? params[(no)+2].i : V_GetColor(NULL, params[(no)+2].s); int var = params[(no)+1].i== 0? params[(no)+2].i : V_GetColor(NULL, params[(no)+2].s);

640
src/thingdef/thingdef_codeptr.cpp
View file

File diff suppressed because it is too large Load diff

2
src/thingdef/thingdef_data.cpp
View file

@ -649,7 +649,7 @@ void InitThingdef()
symt.AddSymbol(new PField(NAME_Height, TypeFloat64, VARF_Native, myoffsetof(AActor,Height))); symt.AddSymbol(new PField(NAME_Height, TypeFloat64, VARF_Native, myoffsetof(AActor,Height)));
symt.AddSymbol(new PField(NAME_Radius, TypeFloat64, VARF_Native, myoffsetof(AActor,radius))); symt.AddSymbol(new PField(NAME_Radius, TypeFloat64, VARF_Native, myoffsetof(AActor,radius)));
symt.AddSymbol(new PField(NAME_ReactionTime,TypeSInt32, VARF_Native, myoffsetof(AActor,reactiontime))); symt.AddSymbol(new PField(NAME_ReactionTime,TypeSInt32, VARF_Native, myoffsetof(AActor,reactiontime)));
symt.AddSymbol(new PField(NAME_MeleeRange, TypeFixed, VARF_Native, myoffsetof(AActor,meleerange))); symt.AddSymbol(new PField(NAME_MeleeRange, TypeFloat64, VARF_Native, myoffsetof(AActor,meleerange)));
symt.AddSymbol(new PField(NAME_Speed, TypeFloat64, VARF_Native, myoffsetof(AActor,Speed))); symt.AddSymbol(new PField(NAME_Speed, TypeFloat64, VARF_Native, myoffsetof(AActor,Speed)));
symt.AddSymbol(new PField(NAME_Threshold, TypeSInt32, VARF_Native, myoffsetof(AActor,threshold))); symt.AddSymbol(new PField(NAME_Threshold, TypeSInt32, VARF_Native, myoffsetof(AActor,threshold)));
symt.AddSymbol(new PField(NAME_DefThreshold,TypeSInt32, VARF_Native, myoffsetof(AActor,DefThreshold))); symt.AddSymbol(new PField(NAME_DefThreshold,TypeSInt32, VARF_Native, myoffsetof(AActor,DefThreshold)));

4
src/thingdef/thingdef_parse.cpp
View file

@ -486,10 +486,6 @@ static void ParseNativeFunction(FScanner &sc, PClassActor *cls)
rets.Push(TypeFloat64); rets.Push(TypeFloat64);
break; break;
case TK_Angle_t:
rets.Push(TypeAngle);
break;
case TK_Fixed_t: case TK_Fixed_t:
rets.Push(TypeFixed); rets.Push(TypeFixed);
break; break;

46
src/thingdef/thingdef_properties.cpp
View file

@ -1,7 +1,7 @@
/* /*
** thingdef-properties.cpp ** thingdef-properties.cpp
** **
** Actor definitions - properties and flags handling ** Actor denitions - properties and flags handling
** **
**--------------------------------------------------------------------------- **---------------------------------------------------------------------------
** Copyright 2002-2007 Christoph Oelckers ** Copyright 2002-2007 Christoph Oelckers
@ -245,10 +245,10 @@ void HandleDeprecatedFlags(AActor *defaults, PClassActor *info, bool set, int in
defaults->Gravity = set ? 1. / 8 : 1.; defaults->Gravity = set ? 1. / 8 : 1.;
break; break;
case DEPF_SHORTMISSILERANGE: case DEPF_SHORTMISSILERANGE:
defaults->maxtargetrange = set? 896*FRACUNIT : 0; defaults->maxtargetrange = set? 896. : 0.;
break; break;
case DEPF_LONGMELEERANGE: case DEPF_LONGMELEERANGE:
defaults->meleethreshold = set? 196*FRACUNIT : 0; defaults->meleethreshold = set? 196. : 0.;
break; break;
case DEPF_QUARTERGRAVITY: case DEPF_QUARTERGRAVITY:
defaults->Gravity = set ? 1. / 4 : 1.; defaults->Gravity = set ? 1. / 4 : 1.;
@ -314,9 +314,9 @@ bool CheckDeprecatedFlags(const AActor *actor, PClassActor *info, int index)
case DEPF_LOWGRAVITY: case DEPF_LOWGRAVITY:
return actor->Gravity == 1./8; return actor->Gravity == 1./8;
case DEPF_SHORTMISSILERANGE: case DEPF_SHORTMISSILERANGE:
return actor->maxtargetrange == 896*FRACUNIT; return actor->maxtargetrange == 896.;
case DEPF_LONGMELEERANGE: case DEPF_LONGMELEERANGE:
return actor->meleethreshold == 196*FRACUNIT; return actor->meleethreshold == 196.;
case DEPF_QUARTERGRAVITY: case DEPF_QUARTERGRAVITY:
return actor->Gravity == 1./4; return actor->Gravity == 1./4;
case DEPF_FIRERESIST: case DEPF_FIRERESIST:
@ -936,7 +936,7 @@ DEFINE_PROPERTY(burnheight, F, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(maxtargetrange, F, Actor) DEFINE_PROPERTY(maxtargetrange, F, Actor)
{ {
PROP_FIXED_PARM(id, 0); PROP_DOUBLE_PARM(id, 0);
defaults->maxtargetrange = id; defaults->maxtargetrange = id;
} }
@ -945,7 +945,7 @@ DEFINE_PROPERTY(maxtargetrange, F, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(meleethreshold, F, Actor) DEFINE_PROPERTY(meleethreshold, F, Actor)
{ {
PROP_FIXED_PARM(id, 0); PROP_DOUBLE_PARM(id, 0);
defaults->meleethreshold = id; defaults->meleethreshold = id;
} }
@ -964,7 +964,7 @@ DEFINE_PROPERTY(meleedamage, I, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(meleerange, F, Actor) DEFINE_PROPERTY(meleerange, F, Actor)
{ {
PROP_FIXED_PARM(id, 0); PROP_DOUBLE_PARM(id, 0);
defaults->meleerange = id; defaults->meleerange = id;
} }
@ -1003,7 +1003,7 @@ DEFINE_PROPERTY(missileheight, F, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(pushfactor, F, Actor) DEFINE_PROPERTY(pushfactor, F, Actor)
{ {
PROP_FIXED_PARM(id, 0); PROP_DOUBLE_PARM(id, 0);
defaults->pushfactor = id; defaults->pushfactor = id;
} }
@ -1132,8 +1132,8 @@ DEFINE_PROPERTY(bouncetype, S, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(bouncefactor, F, Actor) DEFINE_PROPERTY(bouncefactor, F, Actor)
{ {
PROP_FIXED_PARM(id, 0); PROP_DOUBLE_PARM(id, 0);
defaults->bouncefactor = clamp<fixed_t>(id, 0, FRACUNIT); defaults->bouncefactor = clamp<double>(id, 0, 1);
} }
//========================================================================== //==========================================================================
@ -1141,8 +1141,8 @@ DEFINE_PROPERTY(bouncefactor, F, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(wallbouncefactor, F, Actor) DEFINE_PROPERTY(wallbouncefactor, F, Actor)
{ {
PROP_FIXED_PARM(id, 0); PROP_DOUBLE_PARM(id, 0);
defaults->wallbouncefactor = clamp<fixed_t>(id, 0, FRACUNIT); defaults->wallbouncefactor = clamp<double>(id, 0, 1);
} }
//========================================================================== //==========================================================================
@ -1310,7 +1310,7 @@ DEFINE_PROPERTY(fastspeed, F, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(radiusdamagefactor, F, Actor) DEFINE_PROPERTY(radiusdamagefactor, F, Actor)
{ {
PROP_FIXED_PARM(i, 0); PROP_DOUBLE_PARM(i, 0);
assert(info->IsKindOf(RUNTIME_CLASS(PClassActor))); assert(info->IsKindOf(RUNTIME_CLASS(PClassActor)));
static_cast<PClassActor *>(info)->RDFactor = i; static_cast<PClassActor *>(info)->RDFactor = i;
} }
@ -1350,7 +1350,7 @@ DEFINE_PROPERTY(gravity, F, Actor)
//========================================================================== //==========================================================================
DEFINE_PROPERTY(friction, F, Actor) DEFINE_PROPERTY(friction, F, Actor)
{ {
PROP_FIXED_PARM(i, 0); PROP_DOUBLE_PARM(i, 0);
if (i < 0) I_Error ("Friction must not be negative."); if (i < 0) I_Error ("Friction must not be negative.");
defaults->Friction = i; defaults->Friction = i;
@ -2093,9 +2093,9 @@ DEFINE_CLASS_PROPERTY(slotnumber, I, Weapon)
//========================================================================== //==========================================================================
DEFINE_CLASS_PROPERTY(slotpriority, F, Weapon) DEFINE_CLASS_PROPERTY(slotpriority, F, Weapon)
{ {
PROP_FIXED_PARM(i, 0); PROP_DOUBLE_PARM(i, 0);
assert(info->IsKindOf(RUNTIME_CLASS(PClassWeapon))); assert(info->IsKindOf(RUNTIME_CLASS(PClassWeapon)));
static_cast<PClassWeapon *>(info)->SlotPriority = i; static_cast<PClassWeapon *>(info)->SlotPriority = int(i*65536);
} }
//========================================================================== //==========================================================================
@ -2504,7 +2504,7 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, clearcolorset, I, PlayerPawn)
//========================================================================== //==========================================================================
DEFINE_CLASS_PROPERTY_PREFIX(player, attackzoffset, F, PlayerPawn) DEFINE_CLASS_PROPERTY_PREFIX(player, attackzoffset, F, PlayerPawn)
{ {
PROP_FIXED_PARM(z, 0); PROP_DOUBLE_PARM(z, 0);
defaults->AttackZOffset = z; defaults->AttackZOffset = z;
} }
@ -2522,7 +2522,7 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, jumpz, F, PlayerPawn)
//========================================================================== //==========================================================================
DEFINE_CLASS_PROPERTY_PREFIX(player, GruntSpeed, F, PlayerPawn) DEFINE_CLASS_PROPERTY_PREFIX(player, GruntSpeed, F, PlayerPawn)
{ {
PROP_FIXED_PARM(z, 0); PROP_DOUBLE_PARM(z, 0);
defaults->GruntSpeed = z; defaults->GruntSpeed = z;
} }
@ -2531,8 +2531,8 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, GruntSpeed, F, PlayerPawn)
//========================================================================== //==========================================================================
DEFINE_CLASS_PROPERTY_PREFIX(player, FallingScreamSpeed, FF, PlayerPawn) DEFINE_CLASS_PROPERTY_PREFIX(player, FallingScreamSpeed, FF, PlayerPawn)
{ {
PROP_FIXED_PARM(minz, 0); PROP_DOUBLE_PARM(minz, 0);
PROP_FIXED_PARM(maxz, 1); PROP_DOUBLE_PARM(maxz, 1);
defaults->FallingScreamMinSpeed = minz; defaults->FallingScreamMinSpeed = minz;
defaults->FallingScreamMaxSpeed = maxz; defaults->FallingScreamMaxSpeed = maxz;
} }
@ -2582,7 +2582,7 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, viewheight, F, PlayerPawn)
//========================================================================== //==========================================================================
DEFINE_CLASS_PROPERTY_PREFIX(player, userange, F, PlayerPawn) DEFINE_CLASS_PROPERTY_PREFIX(player, userange, F, PlayerPawn)
{ {
PROP_FIXED_PARM(z, 0); PROP_DOUBLE_PARM(z, 0);
defaults->UseRange = z; defaults->UseRange = z;
} }
@ -2591,7 +2591,7 @@ DEFINE_CLASS_PROPERTY_PREFIX(player, userange, F, PlayerPawn)
//========================================================================== //==========================================================================
DEFINE_CLASS_PROPERTY_PREFIX(player, aircapacity, F, PlayerPawn) DEFINE_CLASS_PROPERTY_PREFIX(player, aircapacity, F, PlayerPawn)
{ {
PROP_FIXED_PARM(z, 0); PROP_DOUBLE_PARM(z, 0);
defaults->AirCapacity = z; defaults->AirCapacity = z;
} }

12
src/zscript/vm.h
View file

@ -894,9 +894,7 @@ void VMDisasm(FILE *out, const VMOP *code, int codesize, const VMScriptFunction
#define PARAM_SOUND_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_INT); FSoundID x = param[p].i; #define PARAM_SOUND_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_INT); FSoundID x = param[p].i;
#define PARAM_COLOR_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_INT); PalEntry x; x.d = param[p].i; #define PARAM_COLOR_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_INT); PalEntry x; x.d = param[p].i;
#define PARAM_FLOAT_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_FLOAT); double x = param[p].f; #define PARAM_FLOAT_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_FLOAT); double x = param[p].f;
#define PARAM_FIXED_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_FLOAT); fixed_t x = FLOAT2FIXED(param[p].f); #define PARAM_ANGLE_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_FLOAT); DAngle x = param[p].f;
#define PARAM_ANGLE_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_FLOAT); angle_t x = FLOAT2ANGLE(param[p].f);
#define PARAM_DANGLE_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_FLOAT); DAngle x = param[p].f;
#define PARAM_STRING_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_STRING); FString x = param[p].s(); #define PARAM_STRING_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_STRING); FString x = param[p].s();
#define PARAM_STATE_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_POINTER && (param[p].atag == ATAG_STATE || param[p].a == NULL)); FState *x = (FState *)param[p].a; #define PARAM_STATE_AT(p,x) assert((p) < numparam); assert(param[p].Type == REGT_POINTER && (param[p].atag == ATAG_STATE || param[p].a == NULL)); FState *x = (FState *)param[p].a;
#define PARAM_POINTER_AT(p,x,type) assert((p) < numparam); assert(param[p].Type == REGT_POINTER); type *x = (type *)param[p].a; #define PARAM_POINTER_AT(p,x,type) assert((p) < numparam); assert(param[p].Type == REGT_POINTER); type *x = (type *)param[p].a;
@ -913,9 +911,7 @@ void VMDisasm(FILE *out, const VMOP *code, int codesize, const VMScriptFunction
#define PARAM_SOUND_OPT_AT(p,x) FSoundID x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_INT); x = FSoundID(param[p].i); } else #define PARAM_SOUND_OPT_AT(p,x) FSoundID x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_INT); x = FSoundID(param[p].i); } else
#define PARAM_COLOR_OPT_AT(p,x) PalEntry x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_INT); x.d = param[p].i; } else #define PARAM_COLOR_OPT_AT(p,x) PalEntry x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_INT); x.d = param[p].i; } else
#define PARAM_FLOAT_OPT_AT(p,x) double x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_FLOAT); x = param[p].f; } else #define PARAM_FLOAT_OPT_AT(p,x) double x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_FLOAT); x = param[p].f; } else
#define PARAM_FIXED_OPT_AT(p,x) fixed_t x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_FLOAT); x = FLOAT2FIXED(param[p].f); } else #define PARAM_ANGLE_OPT_AT(p,x) DAngle x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_FLOAT); x = param[p].f; } else
#define PARAM_ANGLE_OPT_AT(p,x) angle_t x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_FLOAT); x = FLOAT2ANGLE(param[p].f); } else
#define PARAM_DANGLE_OPT_AT(p,x) DAngle x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_FLOAT); x = param[p].f; } else
#define PARAM_STRING_OPT_AT(p,x) FString x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_STRING); x = param[p].s(); } else #define PARAM_STRING_OPT_AT(p,x) FString x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_STRING); x = param[p].s(); } else
#define PARAM_STATE_OPT_AT(p,x) FState *x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_POINTER && (param[p].atag == ATAG_STATE || param[p].a == NULL)); x = (FState *)param[p].a; } else #define PARAM_STATE_OPT_AT(p,x) FState *x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_POINTER && (param[p].atag == ATAG_STATE || param[p].a == NULL)); x = (FState *)param[p].a; } else
#define PARAM_POINTER_OPT_AT(p,x,type) type *x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_POINTER); x = (type *)param[p].a; } else #define PARAM_POINTER_OPT_AT(p,x,type) type *x; if ((p) < numparam && param[p].Type != REGT_NIL) { assert(param[p].Type == REGT_POINTER); x = (type *)param[p].a; } else
@ -931,9 +927,7 @@ void VMDisasm(FILE *out, const VMOP *code, int codesize, const VMScriptFunction
#define PARAM_SOUND(x) ++paramnum; PARAM_SOUND_AT(paramnum,x) #define PARAM_SOUND(x) ++paramnum; PARAM_SOUND_AT(paramnum,x)
#define PARAM_COLOR(x) ++paramnum; PARAM_COLOR_AT(paramnum,x) #define PARAM_COLOR(x) ++paramnum; PARAM_COLOR_AT(paramnum,x)
#define PARAM_FLOAT(x) ++paramnum; PARAM_FLOAT_AT(paramnum,x) #define PARAM_FLOAT(x) ++paramnum; PARAM_FLOAT_AT(paramnum,x)
#define PARAM_FIXED(x) ++paramnum; PARAM_FIXED_AT(paramnum,x)
#define PARAM_ANGLE(x) ++paramnum; PARAM_ANGLE_AT(paramnum,x) #define PARAM_ANGLE(x) ++paramnum; PARAM_ANGLE_AT(paramnum,x)
#define PARAM_DANGLE(x) ++paramnum; PARAM_DANGLE_AT(paramnum,x)
#define PARAM_STRING(x) ++paramnum; PARAM_STRING_AT(paramnum,x) #define PARAM_STRING(x) ++paramnum; PARAM_STRING_AT(paramnum,x)
#define PARAM_STATE(x) ++paramnum; PARAM_STATE_AT(paramnum,x) #define PARAM_STATE(x) ++paramnum; PARAM_STATE_AT(paramnum,x)
#define PARAM_POINTER(x,type) ++paramnum; PARAM_POINTER_AT(paramnum,x,type) #define PARAM_POINTER(x,type) ++paramnum; PARAM_POINTER_AT(paramnum,x,type)
@ -946,9 +940,7 @@ void VMDisasm(FILE *out, const VMOP *code, int codesize, const VMScriptFunction
#define PARAM_SOUND_OPT(x) ++paramnum; PARAM_SOUND_OPT_AT(paramnum,x) #define PARAM_SOUND_OPT(x) ++paramnum; PARAM_SOUND_OPT_AT(paramnum,x)
#define PARAM_COLOR_OPT(x) ++paramnum; PARAM_COLOR_OPT_AT(paramnum,x) #define PARAM_COLOR_OPT(x) ++paramnum; PARAM_COLOR_OPT_AT(paramnum,x)
#define PARAM_FLOAT_OPT(x) ++paramnum; PARAM_FLOAT_OPT_AT(paramnum,x) #define PARAM_FLOAT_OPT(x) ++paramnum; PARAM_FLOAT_OPT_AT(paramnum,x)
#define PARAM_FIXED_OPT(x) ++paramnum; PARAM_FIXED_OPT_AT(paramnum,x)
#define PARAM_ANGLE_OPT(x) ++paramnum; PARAM_ANGLE_OPT_AT(paramnum,x) #define PARAM_ANGLE_OPT(x) ++paramnum; PARAM_ANGLE_OPT_AT(paramnum,x)
#define PARAM_DANGLE_OPT(x) ++paramnum; PARAM_DANGLE_OPT_AT(paramnum,x)
#define PARAM_STRING_OPT(x) ++paramnum; PARAM_STRING_OPT_AT(paramnum,x) #define PARAM_STRING_OPT(x) ++paramnum; PARAM_STRING_OPT_AT(paramnum,x)
#define PARAM_STATE_OPT(x) ++paramnum; PARAM_STATE_OPT_AT(paramnum,x) #define PARAM_STATE_OPT(x) ++paramnum; PARAM_STATE_OPT_AT(paramnum,x)
#define PARAM_POINTER_OPT(x,type) ++paramnum; PARAM_POINTER_OPT_AT(paramnum,x,type) #define PARAM_POINTER_OPT(x,type) ++paramnum; PARAM_POINTER_OPT_AT(paramnum,x,type)

20
src/zscript/vmexec.h
View file

@ -220,16 +220,6 @@ begin:
GETADDR(PB,RC,X_READ_NIL); GETADDR(PB,RC,X_READ_NIL);
reg.f[a] = *(VM_SWORD *)ptr / 65536.0; reg.f[a] = *(VM_SWORD *)ptr / 65536.0;
NEXTOP; NEXTOP;
OP(LANG):
ASSERTF(a); ASSERTA(B); ASSERTKD(C);
GETADDR(PB,KC,X_READ_NIL);
reg.f[a] = (*(VM_UWORD *)ptr >> 1) * (180.0 / 0x40000000); // BAM -> deg
NEXTOP;
OP(LANG_R):
ASSERTF(a); ASSERTA(B); ASSERTD(C);
GETADDR(PB,RC,X_READ_NIL);
reg.f[a] = (*(VM_UWORD *)ptr >> 1) * (180.0 / 0x40000000);
NEXTOP;
OP(LBIT): OP(LBIT):
ASSERTD(a); ASSERTA(B); ASSERTD(a); ASSERTA(B);
GETADDR(PB,0,X_READ_NIL); GETADDR(PB,0,X_READ_NIL);
@ -336,16 +326,6 @@ begin:
GETADDR(PA,RC,X_WRITE_NIL); GETADDR(PA,RC,X_WRITE_NIL);
*(VM_SWORD *)ptr = (VM_SWORD)(reg.f[B] * 65536.0); *(VM_SWORD *)ptr = (VM_SWORD)(reg.f[B] * 65536.0);
NEXTOP; NEXTOP;
OP(SANG):
ASSERTA(a); ASSERTF(B); ASSERTKD(C);
GETADDR(PA,KC,X_WRITE_NIL);
*(VM_UWORD *)ptr = (VM_UWORD)(xs_CRoundToInt((reg.f[B]) * (0x40000000/90.))); // deg -> BAM
NEXTOP;
OP(SANG_R):
ASSERTA(a); ASSERTF(B); ASSERTD(C);
GETADDR(PA,RC,X_WRITE_NIL);
*(VM_UWORD *)ptr = (VM_UWORD)(xs_CRoundToInt((reg.f[B]) * (0x40000000/90.)));
NEXTOP;
OP(SBIT): OP(SBIT):
ASSERTA(a); ASSERTD(B); ASSERTA(a); ASSERTD(B);
GETADDR(PA,0,X_WRITE_NIL); GETADDR(PA,0,X_WRITE_NIL);

4
src/zscript/vmops.h
View file

@ -37,8 +37,6 @@ xx(LV, lv, RVRPKI), // load vector
xx(LV_R, lv, RVRPRI), xx(LV_R, lv, RVRPRI),
xx(LX, lx, RFRPKI), // load fixed point xx(LX, lx, RFRPKI), // load fixed point
xx(LX_R, lx, RFRPRI), xx(LX_R, lx, RFRPRI),
xx(LANG, lang, RFRPKI), // load angle
xx(LANG_R, lang, RFRPRI),
xx(LBIT, lbit, RIRPI8), // rA = !!(*rB & C) -- *rB is a byte xx(LBIT, lbit, RIRPI8), // rA = !!(*rB & C) -- *rB is a byte
@ -61,8 +59,6 @@ xx(SV, sv, RPRVKI), // store vector
xx(SV_R, sv, RPRVRI), xx(SV_R, sv, RPRVRI),
xx(SX, sx, RPRFKI), // store fixed point xx(SX, sx, RPRFKI), // store fixed point
xx(SX_R, sx, RPRFRI), xx(SX_R, sx, RPRFRI),
xx(SANG, sang, RPRFKI), // store angle
xx(SANG_R, sang, RPRFRI),
xx(SBIT, sbit, RPRII8), // *rA |= C if rB is true, *rA &= ~C otherwise xx(SBIT, sbit, RPRII8), // *rA |= C if rB is true, *rA &= ~C otherwise