zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-18 02:12:00 +00:00
Code Issues Projects Releases Packages Wiki Activity
gzdoom/src/p_mobj.cpp

8173 lines
204 KiB
C++
Raw Normal View History

- Implemented sv_singleplayerrespawn
2016-10-23 10:06:59 +00:00
// Emacs style mode select -*- C++ -*-
Normalize line endings
2016-03-01 15:47:10 +00:00
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
// Moving object handling. Spawn functions.
//
//-----------------------------------------------------------------------------
// HEADER FILES ------------------------------------------------------------
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
#include <float.h>
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "templates.h"
#include "i_system.h"
#include "m_random.h"
#include "doomdef.h"
#include "p_local.h"
#include "p_maputl.h"
#include "p_lnspec.h"
#include "p_effect.h"
#include "p_terrain.h"
#include "st_stuff.h"
#include "hu_stuff.h"
#include "s_sound.h"
#include "doomstat.h"
#include "v_video.h"
#include "c_cvars.h"
#include "c_dispatch.h"
#include "b_bot.h" //Added by MC:
#include "stats.h"
#include "a_sharedglobal.h"
#include "gi.h"
#include "sbar.h"
#include "p_acs.h"
#include "cmdlib.h"
#include "decallib.h"
#include "a_keys.h"
#include "p_conversation.h"
#include "g_game.h"
#include "teaminfo.h"
#include "r_data/r_translate.h"
#include "r_sky.h"
#include "g_level.h"
#include "d_event.h"
#include "colormatcher.h"
#include "v_palette.h"
#include "p_enemy.h"
#include "gstrings.h"
#include "r_data/colormaps.h"
#include "r_renderer.h"
#include "po_man.h"
#include "p_spec.h"
#include "p_checkposition.h"
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
#include "serializer.h"
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
#include "r_utility.h"
- started with cleanup and separation of DECORATE code. * everything related to scripting is now placed in a subdirectory 'scripting', which itself is separated into DECORATE, ZSCRIPT, the VM and code generation. * a few items have been moved to different headers so that the DECORATE parser definitions can mostly be kept local. The only exception at the moment is the flags interface on which 3 source files depend.
2016-10-12 17:22:33 +00:00
#include "thingdef.h"
- changed AInventory::HandlePickup to work iteratively instead of recursively. Two reasons for this: 1. if this has to be routed through the VM each recursion will cost 1000 bytes of stack space which simply is not good. 2. having the virtual function only care about the item itself but not the entire inventory chain is a lot less error prone for scripting. Since the scripting interface needs a separate caller function anyway this seemed like a good time to change it. The same will be done for the other chained inventory handlers as well.
2016-11-27 09:40:43 +00:00
#include "d_player.h"
- Moved all virtual function related template code to its own file because it depends on includes that cannot be done in dobject.h.
2016-11-11 23:33:40 +00:00
#include "virtual.h"
- refactored global sides array to be more VM friendly. - moved FLevelLocals to its own header to resolve some circular include conflicts.
2017-01-08 17:45:30 +00:00
#include "g_levellocals.h"
- scriptified the health items.
2017-01-15 00:02:38 +00:00
#include "a_morph.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
// MACROS ------------------------------------------------------------------
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
#define WATER_SINK_FACTOR 0.125
#define WATER_SINK_SMALL_FACTOR 0.25
#define WATER_SINK_SPEED 0.5
#define WATER_JUMP_SPEED 3.5
Normalize line endings
2016-03-01 15:47:10 +00:00
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
void G_PlayerReborn (int player);
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
static void PlayerLandedOnThing (AActor *mo, AActor *onmobj);
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
extern int BotWTG;
EXTERN_CVAR (Int, cl_rockettrails)
// PRIVATE DATA DEFINITIONS ------------------------------------------------
static FRandom pr_explodemissile ("ExplodeMissile");
FRandom pr_bounce ("Bounce");
static FRandom pr_reflect ("Reflect");
static FRandom pr_nightmarerespawn ("NightmareRespawn");
static FRandom pr_botspawnmobj ("BotSpawnActor");
static FRandom pr_spawnmapthing ("SpawnMapThing");
static FRandom pr_spawnpuff ("SpawnPuff");
static FRandom pr_spawnblood ("SpawnBlood");
static FRandom pr_splatter ("BloodSplatter");
static FRandom pr_takedamage ("TakeDamage");
static FRandom pr_splat ("FAxeSplatter");
static FRandom pr_ripperblood ("RipperBlood");
static FRandom pr_chunk ("Chunk");
static FRandom pr_checkmissilespawn ("CheckMissileSpawn");
static FRandom pr_spawnmissile ("SpawnMissile");
static FRandom pr_missiledamage ("MissileDamage");
static FRandom pr_multiclasschoice ("MultiClassChoice");
static FRandom pr_rockettrail("RocketTrail");
static FRandom pr_uniquetid("UniqueTID");
// PUBLIC DATA DEFINITIONS -------------------------------------------------
FRandom pr_spawnmobj ("SpawnActor");
CUSTOM_CVAR (Float, sv_gravity, 800.f, CVAR_SERVERINFO|CVAR_NOSAVE)
{
level.gravity = self;
}
CVAR (Bool, cl_missiledecals, true, CVAR_ARCHIVE)
CVAR (Bool, addrocketexplosion, false, CVAR_ARCHIVE)
CVAR (Int, cl_pufftype, 0, CVAR_ARCHIVE);
CVAR (Int, cl_bloodtype, 0, CVAR_ARCHIVE);
// CODE --------------------------------------------------------------------
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
IMPLEMENT_CLASS(AActor, false, true)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(AActor)
IMPLEMENT_POINTER(target)
IMPLEMENT_POINTER(lastenemy)
IMPLEMENT_POINTER(tracer)
IMPLEMENT_POINTER(goal)
IMPLEMENT_POINTER(LastLookActor)
IMPLEMENT_POINTER(Inventory)
IMPLEMENT_POINTER(LastHeard)
IMPLEMENT_POINTER(master)
IMPLEMENT_POINTER(Poisoner)
IMPLEMENT_POINTER(DamageFunc)
IMPLEMENT_POINTER(alternative)
- removed an assert from APowerMorph::EndEffect. With some recent changes to DestroyAllInventory it appears that the asserted condition no longer is true at this point when ending a game. - fixed: When replacing a tentative class, the pointers in the morph objects were not replaced. Instead of adding more ReplaceClassRef methods I chose to integrate this part into the PointerSubstitution mechanism and delete ReplaceClassRef entirely. The code had some oversights anyway that would have caused problems, now that non-actors can be created.
2016-11-30 23:05:23 +00:00
IMPLEMENT_POINTER(TeleFogSourceType)
IMPLEMENT_POINTER(TeleFogDestType)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
AActor::~AActor ()
{
// Please avoid calling the destructor directly (or through delete)!
// Use Destroy() instead.
}
- moved declaration of native fields into the respective class definitions. This bypasses a declaration in the script in favor of a simpler implementation. In order to work it is always necessary to have an offset table to map the variables to, but doing it fully on the native side only requires adding the type to the declaration.
2016-11-03 23:19:36 +00:00
extern FFlagDef InternalActorFlagDefs[];
extern FFlagDef ActorFlagDefs[];
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
DEFINE_FIELD(AActor, snext)
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
DEFINE_FIELD(AActor, player)
DEFINE_FIELD_NAMED(AActor, __Pos, pos)
DEFINE_FIELD_NAMED(AActor, __Pos.X, x)
DEFINE_FIELD_NAMED(AActor, __Pos.Y, y)
DEFINE_FIELD_NAMED(AActor, __Pos.Z, z)
DEFINE_FIELD(AActor, Prev)
DEFINE_FIELD(AActor, SpriteAngle)
DEFINE_FIELD(AActor, SpriteRotation)
DEFINE_FIELD(AActor, VisibleStartAngle)
DEFINE_FIELD(AActor, VisibleStartPitch)
DEFINE_FIELD(AActor, VisibleEndAngle)
DEFINE_FIELD(AActor, VisibleEndPitch)
DEFINE_FIELD_NAMED(AActor, Angles.Yaw, angle)
DEFINE_FIELD_NAMED(AActor, Angles.Pitch, pitch)
DEFINE_FIELD_NAMED(AActor, Angles.Roll, roll)
DEFINE_FIELD(AActor, Vel)
DEFINE_FIELD_NAMED(AActor, Vel.X, velx)
DEFINE_FIELD_NAMED(AActor, Vel.Y, vely)
DEFINE_FIELD_NAMED(AActor, Vel.Z, velz)
DEFINE_FIELD_NAMED(AActor, Vel.X, momx)
DEFINE_FIELD_NAMED(AActor, Vel.Y, momy)
DEFINE_FIELD_NAMED(AActor, Vel.Z, momz)
DEFINE_FIELD(AActor, Speed)
DEFINE_FIELD(AActor, FloatSpeed)
DEFINE_FIELD(AActor, sprite)
DEFINE_FIELD(AActor, frame)
DEFINE_FIELD(AActor, Scale)
DEFINE_FIELD_NAMED(AActor, Scale.X, scalex)
DEFINE_FIELD_NAMED(AActor, Scale.Y, scaley)
DEFINE_FIELD(AActor, RenderStyle)
DEFINE_FIELD(AActor, picnum)
DEFINE_FIELD(AActor, Alpha)
DEFINE_FIELD(AActor, fillcolor)
DEFINE_FIELD_NAMED(AActor, Sector, CurSector) // clashes with type 'sector'.
DEFINE_FIELD(AActor, subsector)
DEFINE_FIELD(AActor, ceilingz)
DEFINE_FIELD(AActor, floorz)
DEFINE_FIELD(AActor, dropoffz)
DEFINE_FIELD(AActor, floorsector)
DEFINE_FIELD(AActor, floorpic)
DEFINE_FIELD(AActor, floorterrain)
DEFINE_FIELD(AActor, ceilingsector)
DEFINE_FIELD(AActor, ceilingpic)
DEFINE_FIELD(AActor, Height)
DEFINE_FIELD(AActor, radius)
Ported RenderRadius and related code from gzdoom branch
2016-12-25 11:09:32 +00:00
DEFINE_FIELD(AActor, renderradius)
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
DEFINE_FIELD(AActor, projectilepassheight)
DEFINE_FIELD(AActor, tics)
DEFINE_FIELD_NAMED(AActor, state, curstate) // clashes with type 'state'.
DEFINE_FIELD_NAMED(AActor, DamageVal, Damage) // name differs for historic reasons
DEFINE_FIELD(AActor, projectileKickback)
DEFINE_FIELD(AActor, VisibleToTeam)
DEFINE_FIELD(AActor, special1)
DEFINE_FIELD(AActor, special2)
DEFINE_FIELD(AActor, specialf1)
DEFINE_FIELD(AActor, specialf2)
DEFINE_FIELD(AActor, weaponspecial)
DEFINE_FIELD(AActor, health)
DEFINE_FIELD(AActor, movedir)
DEFINE_FIELD(AActor, visdir)
DEFINE_FIELD(AActor, movecount)
DEFINE_FIELD(AActor, strafecount)
DEFINE_FIELD(AActor, target)
DEFINE_FIELD(AActor, master)
DEFINE_FIELD(AActor, tracer)
DEFINE_FIELD(AActor, LastHeard)
DEFINE_FIELD(AActor, lastenemy)
DEFINE_FIELD(AActor, LastLookActor)
DEFINE_FIELD(AActor, reactiontime)
DEFINE_FIELD(AActor, threshold)
DEFINE_FIELD(AActor, DefThreshold)
DEFINE_FIELD(AActor, SpawnPoint)
DEFINE_FIELD(AActor, SpawnAngle)
DEFINE_FIELD(AActor, StartHealth)
DEFINE_FIELD(AActor, WeaveIndexXY)
DEFINE_FIELD(AActor, WeaveIndexZ)
DEFINE_FIELD(AActor, skillrespawncount)
DEFINE_FIELD(AActor, args)
DEFINE_FIELD(AActor, Mass)
DEFINE_FIELD(AActor, special)
DEFINE_FIELD(AActor, tid)
DEFINE_FIELD(AActor, TIDtoHate)
DEFINE_FIELD(AActor, waterlevel)
DEFINE_FIELD(AActor, Score)
DEFINE_FIELD(AActor, accuracy)
DEFINE_FIELD(AActor, stamina)
DEFINE_FIELD(AActor, meleerange)
DEFINE_FIELD(AActor, PainThreshold)
DEFINE_FIELD(AActor, Gravity)
DEFINE_FIELD(AActor, Floorclip)
DEFINE_FIELD(AActor, DamageType)
DEFINE_FIELD(AActor, DamageTypeReceived)
DEFINE_FIELD(AActor, FloatBobPhase)
DEFINE_FIELD(AActor, RipperLevel)
DEFINE_FIELD(AActor, RipLevelMin)
DEFINE_FIELD(AActor, RipLevelMax)
DEFINE_FIELD(AActor, Species)
DEFINE_FIELD(AActor, alternative)
DEFINE_FIELD(AActor, goal)
DEFINE_FIELD(AActor, MinMissileChance)
DEFINE_FIELD(AActor, LastLookPlayerNumber)
DEFINE_FIELD(AActor, SpawnFlags)
DEFINE_FIELD(AActor, meleethreshold)
DEFINE_FIELD(AActor, maxtargetrange)
DEFINE_FIELD(AActor, bouncefactor)
DEFINE_FIELD(AActor, wallbouncefactor)
DEFINE_FIELD(AActor, bouncecount)
DEFINE_FIELD(AActor, Friction)
DEFINE_FIELD(AActor, FastChaseStrafeCount)
DEFINE_FIELD(AActor, pushfactor)
DEFINE_FIELD(AActor, lastpush)
DEFINE_FIELD(AActor, activationtype)
DEFINE_FIELD(AActor, lastbump)
DEFINE_FIELD(AActor, DesignatedTeam)
DEFINE_FIELD(AActor, BlockingMobj)
DEFINE_FIELD(AActor, BlockingLine)
DEFINE_FIELD(AActor, PoisonDamage)
DEFINE_FIELD(AActor, PoisonDamageType)
DEFINE_FIELD(AActor, PoisonDuration)
DEFINE_FIELD(AActor, PoisonPeriod)
DEFINE_FIELD(AActor, PoisonDamageReceived)
DEFINE_FIELD(AActor, PoisonDamageTypeReceived)
DEFINE_FIELD(AActor, PoisonDurationReceived)
DEFINE_FIELD(AActor, PoisonPeriodReceived)
DEFINE_FIELD(AActor, Poisoner)
DEFINE_FIELD_NAMED(AActor, Inventory, Inv) // clashes with type 'Inventory'.
DEFINE_FIELD(AActor, smokecounter)
DEFINE_FIELD(AActor, FriendPlayer)
DEFINE_FIELD(AActor, Translation)
DEFINE_FIELD(AActor, AttackSound)
DEFINE_FIELD(AActor, DeathSound)
DEFINE_FIELD(AActor, SeeSound)
DEFINE_FIELD(AActor, PainSound)
DEFINE_FIELD(AActor, ActiveSound)
DEFINE_FIELD(AActor, UseSound)
DEFINE_FIELD(AActor, BounceSound)
DEFINE_FIELD(AActor, WallBounceSound)
DEFINE_FIELD(AActor, CrushPainSound)
DEFINE_FIELD(AActor, MaxDropOffHeight)
DEFINE_FIELD(AActor, MaxStepHeight)
DEFINE_FIELD(AActor, PainChance)
DEFINE_FIELD(AActor, PainType)
DEFINE_FIELD(AActor, DeathType)
DEFINE_FIELD(AActor, DamageFactor)
DEFINE_FIELD(AActor, DamageMultiply)
DEFINE_FIELD(AActor, TeleFogSourceType)
DEFINE_FIELD(AActor, TeleFogDestType)
DEFINE_FIELD(AActor, SpawnState)
DEFINE_FIELD(AActor, SeeState)
DEFINE_FIELD(AActor, MeleeState)
DEFINE_FIELD(AActor, MissileState)
DEFINE_FIELD(AActor, ConversationRoot)
DEFINE_FIELD(AActor, Conversation)
DEFINE_FIELD(AActor, DecalGenerator)
- scriptified the particle fountains.
2017-01-13 18:29:54 +00:00
DEFINE_FIELD(AActor, fountaincolor)
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
DEFINE_FIELD(PClassActor, Obituary)
DEFINE_FIELD(PClassActor, HitObituary)
DEFINE_FIELD(PClassActor, DeathHeight)
DEFINE_FIELD(PClassActor, BurnHeight)
DEFINE_FIELD(PClassActor, BloodColor)
DEFINE_FIELD(PClassActor, GibHealth)
DEFINE_FIELD(PClassActor, WoundHealth)
DEFINE_FIELD(PClassActor, FastSpeed)
DEFINE_FIELD(PClassActor, RDFactor)
DEFINE_FIELD(PClassActor, CameraHeight)
DEFINE_FIELD(PClassActor, HowlSound)
DEFINE_FIELD(PClassActor, BloodType)
DEFINE_FIELD(PClassActor, BloodType2)
DEFINE_FIELD(PClassActor, BloodType3)
DEFINE_FIELD(PClassActor, DontHurtShooter)
DEFINE_FIELD(PClassActor, ExplosionRadius)
DEFINE_FIELD(PClassActor, ExplosionDamage)
DEFINE_FIELD(PClassActor, MeleeDamage)
DEFINE_FIELD(PClassActor, MeleeSound)
DEFINE_FIELD(PClassActor, MissileName)
DEFINE_FIELD(PClassActor, MissileHeight)
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor :: Serialize
//
//==========================================================================
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
#define A(a,b) ((a), (b), def->b)
void AActor::Serialize(FSerializer &arc)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
AActor *def = GetDefault();
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Super::Serialize(arc);
Normalize line endings
2016-03-01 15:47:10 +00:00
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
arc
.Sprite("sprite", sprite, &def->sprite)
A("pos", __Pos)
A("angles", Angles)
A("frame", frame)
A("scale", Scale)
A("renderstyle", RenderStyle)
A("renderflags", renderflags)
A("picnum", picnum)
A("floorpic", floorpic)
A("ceilingpic", ceilingpic)
A("tidtohate", TIDtoHate)
A("lastlookpn", LastLookPlayerNumber)
("lastlookactor", LastLookActor)
A("effects", effects)
- scriptified the particle fountains.
2017-01-13 18:29:54 +00:00
A("fountaincolor", fountaincolor)
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
A("alpha", Alpha)
A("fillcolor", fillcolor)
A("sector", Sector)
A("floorz", floorz)
A("ceilingz", ceilingz)
A("dropoffz", dropoffz)
A("floorsector", floorsector)
A("ceilingsector", ceilingsector)
A("radius", radius)
- fixed: RenderRadius needs to be serialized. - fixed: CustomBridge can be visible so it shouldn't be completely excluded from the render lists.
2016-12-25 13:35:35 +00:00
A("renderradius", renderradius)
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
A("height", Height)
A("ppassheight", projectilepassheight)
A("vel", Vel)
A("tics", tics)
A("state", state)
A("damage", DamageVal)
.Terrain("floorterrain", floorterrain, &def->floorterrain)
A("projectilekickback", projectileKickback)
A("flags", flags)
A("flags2", flags2)
A("flags3", flags3)
A("flags4", flags4)
A("flags5", flags5)
A("flags6", flags6)
A("flags7", flags7)
A("weaponspecial", weaponspecial)
A("special1", special1)
A("special2", special2)
A("specialf1", specialf1)
A("specialf2", specialf2)
A("health", health)
A("movedir", movedir)
A("visdir", visdir)
A("movecount", movecount)
A("strafecount", strafecount)
("target", target)
("lastenemy", lastenemy)
("lastheard", LastHeard)
A("reactiontime", reactiontime)
A("threshold", threshold)
A("player", player)
A("spawnpoint", SpawnPoint)
A("spawnangle", SpawnAngle)
A("starthealth", StartHealth)
A("skillrespawncount", skillrespawncount)
("tracer", tracer)
A("floorclip", Floorclip)
A("tid", tid)
A("special", special)
.Args("args", args, def->args, special)
A("accuracy", accuracy)
A("stamina", stamina)
("goal", goal)
A("waterlevel", waterlevel)
A("minmissilechance", MinMissileChance)
A("spawnflags", SpawnFlags)
("inventory", Inventory)
A("inventoryid", InventoryID)
A("floatbobphase", FloatBobPhase)
A("translation", Translation)
A("seesound", SeeSound)
A("attacksound", AttackSound)
A("paimsound", PainSound)
A("deathsound", DeathSound)
A("activesound", ActiveSound)
A("usesound", UseSound)
A("bouncesound", BounceSound)
A("wallbouncesound", WallBounceSound)
A("crushpainsound", CrushPainSound)
A("speed", Speed)
A("floatspeed", FloatSpeed)
A("mass", Mass)
A("painchance", PainChance)
A("spawnstate", SpawnState)
A("seestate", SeeState)
A("meleestate", MeleeState)
A("missilestate", MissileState)
A("maxdropoffheight", MaxDropOffHeight)
A("maxstepheight", MaxStepHeight)
A("bounceflags", BounceFlags)
A("bouncefactor", bouncefactor)
A("wallbouncefactor", wallbouncefactor)
A("bouncecount", bouncecount)
A("maxtargetrange", maxtargetrange)
A("meleethreshold", meleethreshold)
A("meleerange", meleerange)
A("damagetype", DamageType)
A("damagetypereceived", DamageTypeReceived)
A("paintype", PainType)
A("deathtype", DeathType)
A("gravity", Gravity)
A("fastchasestrafecount", FastChaseStrafeCount)
("master", master)
A("smokecounter", smokecounter)
("blockingmobj", BlockingMobj)
A("blockingline", BlockingLine)
A("visibletoteam", VisibleToTeam)
A("pushfactor", pushfactor)
A("species", Species)
A("score", Score)
A("designatedteam", DesignatedTeam)
A("lastpush", lastpush)
A("lastbump", lastbump)
A("painthreshold", PainThreshold)
A("damagefactor", DamageFactor)
A("damagemultiply", DamageMultiply)
A("waveindexxy", WeaveIndexXY)
A("weaveindexz", WeaveIndexZ)
A("pdmgreceived", PoisonDamageReceived)
A("pdurreceived", PoisonDurationReceived)
A("ppreceived", PoisonPeriodReceived)
("poisoner", Poisoner)
A("posiondamage", PoisonDamage)
A("poisonduration", PoisonDuration)
A("poisonperiod", PoisonPeriod)
A("poisondamagetype", PoisonDamageType)
A("poisondmgtypereceived", PoisonDamageTypeReceived)
A("conversationroot", ConversationRoot)
A("conversation", Conversation)
A("friendplayer", FriendPlayer)
A("telefogsourcetype", TeleFogSourceType)
A("telefogdesttype", TeleFogDestType)
A("ripperlevel", RipperLevel)
A("riplevelmin", RipLevelMin)
A("riplevelmax", RipLevelMax)
A("devthreshold", DefThreshold)
A("spriteangle", SpriteAngle)
A("spriterotation", SpriteRotation)
("alternative", alternative)
Updated to new save game code.
2016-09-18 20:07:08 +00:00
A("tag", Tag)
A("visiblestartangle",VisibleStartAngle)
A("visibleendangle",VisibleEndAngle)
A("visiblestartpitch",VisibleStartPitch)
A("visibleendpitch",VisibleEndPitch);
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
#undef A
Normalize line endings
2016-03-01 15:47:10 +00:00
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
//==========================================================================
//
// This must be done after the world is set up.
//
//==========================================================================
Tracer pointer is no longer a safe candidate for storing player morph pointers. Instead, actors must have a new, non-manipulatable pointer. This fixes the following circumstances: - Crashes occurred if a particular actor was a tracer to the player and the actor was not gone by the time the player unmorphs. - Failed unmorphs occur if tracer was manipulated through means like A_RearrangePointers, etc.
2016-09-01 18:49:58 +00:00
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
void AActor::PostSerialize()
{
- use msecnode_t's for the touching_renderlists instead of std::forward_list. - preparations for checking the proper sector to get a sprite's lighting info.
2016-12-26 10:58:08 +00:00
touching_sectorlist = nullptr;
touching_rendersectors = nullptr;
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
LinkToWorld(nullptr, false, Sector);
Normalize line endings
2016-03-01 15:47:10 +00:00
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
AddToHash();
if (player)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
if (playeringame[player - players] &&
player->cls != NULL &&
!(flags4 & MF4_NOSKIN) &&
state->sprite == GetDefaultByType(player->cls)->SpawnState->sprite)
{ // Give player back the skin
sprite = skins[player->userinfo.GetSkin()].sprite;
}
if (Speed == 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
Speed = GetDefault()->Speed;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
ClearInterpolation();
UpdateWaterLevel(false);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- moved new code to its proper location and started moving the replaced old archive code to a placeholder file for easy removal later.
2016-09-19 08:34:54 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
AActor::AActor () throw()
{
}
AActor::AActor (const AActor &other) throw()
: DThinker()
{
memcpy (&snext, &other.snext, (BYTE *)&this[1] - (BYTE *)&snext);
}
AActor &AActor::operator= (const AActor &other)
{
memcpy (&snext, &other.snext, (BYTE *)&this[1] - (BYTE *)&snext);
return *this;
}
//==========================================================================
//
// AActor::InStateSequence
//
// Checks whether the current state is in a contiguous sequence that
// starts with basestate
//
//==========================================================================
bool AActor::InStateSequence(FState * newstate, FState * basestate)
{
if (basestate == NULL) return false;
FState * thisstate = basestate;
do
{
if (newstate == thisstate) return true;
basestate = thisstate;
thisstate = thisstate->GetNextState();
}
while (thisstate == basestate+1);
return false;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, InStateSequence)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER(newstate, FState);
PARAM_POINTER(basestate, FState);
ACTION_RETURN_BOOL(self->InStateSequence(newstate, basestate));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor::GetTics
//
// Get the actual duration of the next state
// We are using a state flag now to indicate a state that should be
// accelerated in Fast mode or slowed in Slow mode.
//
//==========================================================================
int AActor::GetTics(FState * newstate)
{
int tics = newstate->GetTics();
- implemented State as an actual native struct, so that its fields can be accessed from scripts. - refactored state bitfield members into a flag word because the address of a bitfield cannot be taken, making such variables inaccessible to scripts. - actually use PNativeStruct for representing native structs defined in a script.
2016-11-21 20:34:34 +00:00
if (isFast() && newstate->GetFast())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return tics - (tics>>1);
}
- implemented State as an actual native struct, so that its fields can be accessed from scripts. - refactored state bitfield members into a flag word because the address of a bitfield cannot be taken, making such variables inaccessible to scripts. - actually use PNativeStruct for representing native structs defined in a script.
2016-11-21 20:34:34 +00:00
else if (isSlow() && newstate->GetSlow())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return tics<<1;
}
return tics;
}
//==========================================================================
//
// AActor::SetState
//
// Returns true if the mobj is still present.
//
//==========================================================================
bool AActor::SetState (FState *newstate, bool nofunction)
{
if (debugfile && player && (player->cheats & CF_PREDICTING))
fprintf (debugfile, "for pl %td: SetState while predicting!\n", player-players);
do
{
if (newstate == NULL)
{
state = NULL;
Destroy ();
return false;
}
int prevsprite, newsprite;
if (state != NULL)
{
prevsprite = state->sprite;
}
else
{
prevsprite = -1;
}
- added runtime checks for the state usage flags.
2016-11-14 23:18:57 +00:00
if (!(newstate->UseFlags & SUF_ACTOR))
{
auto so = FState::StaticFindStateOwner(newstate);
- added compile time checks for bad state links and state label references. - preserve a state's source line information for the postprocessing phase so that the checker can output more useful information. - added missing check for weapon psprites to DPSprite::SetState.
2016-11-15 10:21:08 +00:00
Printf(TEXTCOLOR_RED "State %s.%d in %s not flagged for use as an actor sprite\n", so->TypeName.GetChars(), int(newstate - so->OwnedStates), GetClass()->TypeName.GetChars());
- added runtime checks for the state usage flags.
2016-11-14 23:18:57 +00:00
state = nullptr;
Destroy();
return false;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
state = newstate;
tics = GetTics(newstate);
renderflags = (renderflags & ~RF_FULLBRIGHT) | ActorRenderFlags::FromInt (newstate->GetFullbright());
newsprite = newstate->sprite;
if (newsprite != SPR_FIXED)
{ // okay to change sprite and/or frame
if (!newstate->GetSameFrame())
{ // okay to change frame
frame = newstate->GetFrame();
}
if (newsprite != SPR_NOCHANGE)
{ // okay to change sprite
if (!(flags4 & MF4_NOSKIN) && newsprite == SpawnState->sprite)
{ // [RH] If the new sprite is the same as the original sprite, and
// this actor is attached to a player, use the player's skin's
// sprite. If a player is not attached, do not change the sprite
// unless it is different from the previous state's sprite; a
// player may have been attached, died, and respawned elsewhere,
// and we do not want to lose the skin on the body. If it wasn't
// for Dehacked, I would move sprite changing out of the states
// altogether, since actors rarely change their sprites after
// spawning.
if (player != NULL && skins != NULL)
{
sprite = skins[player->userinfo.GetSkin()].sprite;
}
else if (newsprite != prevsprite)
{
sprite = newsprite;
}
}
else
{
sprite = newsprite;
}
}
}
if (!nofunction)
{
FState *returned_state;
- changed action function interface so that callers can be identified directly, instead of guessing it from looking at the parameters. With arbitrary PSP layers the old method was no longer safe because the layer ID was not available in the action function.
2016-06-16 14:11:00 +00:00
FStateParamInfo stp = { newstate, STATE_Actor, PSP_WEAPON };
if (newstate->CallAction(this, this, &stp, &returned_state))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// Check whether the called action function resulted in destroying the actor
if (ObjectFlags & OF_EuthanizeMe)
{
return false;
}
if (returned_state != NULL)
{ // The action was an A_Jump-style function that wants to change the next state.
newstate = returned_state;
tics = 0; // make sure we loop and set the new state properly
continue;
}
}
}
newstate = newstate->GetNextState();
} while (tics == 0);
if (Renderer != NULL)
{
Renderer->StateChanged(this);
}
return true;
}
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetState)
{
PARAM_SELF_PROLOGUE(AActor);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
PARAM_POINTER(state, FState);
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
PARAM_BOOL_DEF(nofunction);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
ACTION_RETURN_BOOL(self->SetState(state, nofunction));
};
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: AddInventory
//
//============================================================================
void AActor::AddInventory (AInventory *item)
{
// Check if it's already attached to an actor
if (item->Owner != NULL)
{
// Is it attached to us?
if (item->Owner == this)
return;
// No, then remove it from the other actor first
item->Owner->RemoveInventory (item);
}
item->Owner = this;
item->Inventory = Inventory;
Inventory = item;
// Each item receives an unique ID when added to an actor's inventory.
// This is used by the DEM_INVUSE command to identify the item. Simply
// using the item's position in the list won't work, because ticcmds get
// run sometime in the future, so by the time it runs, the inventory
// might not be in the same state as it was when DEM_INVUSE was sent.
Inventory->InventoryID = InventoryID++;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, AddInventory)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(item, AInventory);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
self->AddInventory(item);
return 0;
}
- Added the 'GiveInventory' method to the actor. This will help cleaning up the item giving code. Returns a bool, in case the pickup failure might turn to be interesting in the future.
2016-04-21 13:28:51 +00:00
//============================================================================
//
// AActor :: GiveInventory
//
//============================================================================
bool AActor::GiveInventory(PClassInventory *type, int amount, bool givecheat)
{
bool result = true;
AWeapon *savedPendingWeap = player != NULL ? player->PendingWeapon : NULL;
bool hadweap = player != NULL ? player->ReadyWeapon != NULL : true;
AInventory *item;
if (!givecheat)
{
item = static_cast<AInventory *>(Spawn (type));
}
else
{
item = static_cast<AInventory *>(Spawn (type, Pos(), NO_REPLACE));
if (item == NULL) return false;
}
// This shouldn't count for the item statistics!
item->ClearCounters();
- Fixed a mistake in GiveInventory refactoring. 'give item' stopped working because commit 7b35f32f3de012ccb0ccabe9086cffddcfe0bd00 and 6aca7604eb37ba8e436261015603b4c9a2f1d311 didn't take account that give cheat with zero amount should not touch the item amount.
2016-05-01 15:07:39 +00:00
if (!givecheat || amount > 0)
- Added the 'GiveInventory' method to the actor. This will help cleaning up the item giving code. Returns a bool, in case the pickup failure might turn to be interesting in the future.
2016-04-21 13:28:51 +00:00
{
- scriptified BasicArmorBonus.
2017-01-18 19:23:13 +00:00
if (type->IsDescendantOf (PClass::FindActor(NAME_BasicArmorPickup)) || type->IsDescendantOf(PClass::FindActor(NAME_BasicArmorBonus)))
- Fixed a mistake in GiveInventory refactoring. 'give item' stopped working because commit 7b35f32f3de012ccb0ccabe9086cffddcfe0bd00 and 6aca7604eb37ba8e436261015603b4c9a2f1d311 didn't take account that give cheat with zero amount should not touch the item amount.
2016-05-01 15:07:39 +00:00
{
- scriptified BasicArmorBonus.
2017-01-18 19:23:13 +00:00
item->IntVar(NAME_SaveAmount) *= amount;
- Fixed a mistake in GiveInventory refactoring. 'give item' stopped working because commit 7b35f32f3de012ccb0ccabe9086cffddcfe0bd00 and 6aca7604eb37ba8e436261015603b4c9a2f1d311 didn't take account that give cheat with zero amount should not touch the item amount.
2016-05-01 15:07:39 +00:00
}
- Added the 'GiveInventory' method to the actor. This will help cleaning up the item giving code. Returns a bool, in case the pickup failure might turn to be interesting in the future.
2016-04-21 13:28:51 +00:00
else
- Fixed a mistake in GiveInventory refactoring. 'give item' stopped working because commit 7b35f32f3de012ccb0ccabe9086cffddcfe0bd00 and 6aca7604eb37ba8e436261015603b4c9a2f1d311 didn't take account that give cheat with zero amount should not touch the item amount.
2016-05-01 15:07:39 +00:00
{
if (!givecheat)
item->Amount = amount;
else
item->Amount = MIN (amount, item->MaxAmount);
}
- Added the 'GiveInventory' method to the actor. This will help cleaning up the item giving code. Returns a bool, in case the pickup failure might turn to be interesting in the future.
2016-04-21 13:28:51 +00:00
}
if (!item->CallTryPickup (this))
{
item->Destroy ();
result = false;
}
// If the item was a weapon, don't bring it up automatically
// unless the player was not already using a weapon.
// Don't bring it up automatically if this is called by the give cheat.
if (!givecheat && player != NULL && savedPendingWeap != NULL && hadweap)
{
player->PendingWeapon = savedPendingWeap;
}
return result;
}
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
DEFINE_ACTION_FUNCTION(AActor, GiveInventory)
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
{
PARAM_SELF_PROLOGUE(AActor);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
PARAM_CLASS(type, AInventory);
PARAM_INT(amount);
PARAM_BOOL_DEF(givecheat);
ACTION_RETURN_BOOL(self->GiveInventory(type, amount, givecheat));
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: RemoveInventory
//
//============================================================================
void AActor::RemoveInventory(AInventory *item)
{
AInventory *inv, **invp;
if (item != NULL && item->Owner != NULL) // can happen if the owner was destroyed by some action from an item's use state.
{
invp = &item->Owner->Inventory;
for (inv = *invp; inv != NULL; invp = &inv->Inventory, inv = *invp)
{
if (inv == item)
{
*invp = item->Inventory;
- partial scriptification of AInventory. - scriptification of CustomInventory.
2017-01-19 18:14:22 +00:00
IFVIRTUALPTR(item, AInventory, DetachFromOwner)
{
VMValue params[1] = { item };
GlobalVMStack.Call(func, params, 1, nullptr, 0, nullptr);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
item->Owner = NULL;
item->Inventory = NULL;
break;
}
}
}
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, RemoveInventory)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(item, AInventory);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
self->RemoveInventory(item);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: TakeInventory
//
//============================================================================
bool AActor::TakeInventory(PClassActor *itemclass, int amount, bool fromdecorate, bool notakeinfinite)
{
Added A_SetInventory. - Sets the absolute amount of an inventory actor. - Limits itself to the range [0, MaxAmount]. Setting beyondMax to true disregards the MaxAmount. Default is false.
2016-10-11 19:44:31 +00:00
amount = abs(amount);
Normalize line endings
2016-03-01 15:47:10 +00:00
AInventory *item = FindInventory(itemclass);
if (item == NULL)
return false;
if (!fromdecorate)
{
item->Amount -= amount;
if (item->Amount <= 0)
{
item->DepleteOrDestroy();
}
// It won't be used in non-decorate context, so return false here
return false;
}
bool result = false;
if (item->Amount > 0)
{
result = true;
}
// Do not take ammo if the "no take infinite/take as ammo depletion" flag is set
// and infinite ammo is on
if (notakeinfinite &&
((dmflags & DF_INFINITE_AMMO) || (player && player->cheats & CF_INFINITEAMMO)) &&
- scriptified the remains of AAmmo.
2017-01-18 13:18:17 +00:00
item->IsKindOf(PClass::FindActor(NAME_Ammo)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// Nothing to do here, except maybe res = false;? Would it make sense?
Added A_SetInventory. - Sets the absolute amount of an inventory actor. - Limits itself to the range [0, MaxAmount]. Setting beyondMax to true disregards the MaxAmount. Default is false.
2016-10-11 19:44:31 +00:00
result = false;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (!amount || amount>=item->Amount)
{
item->DepleteOrDestroy();
}
else item->Amount-=amount;
return result;
}
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
DEFINE_ACTION_FUNCTION(AActor, TakeInventory)
{
PARAM_SELF_PROLOGUE(AActor);
- fixed: The script wrapper for AActor::TakeInventory erroneously called RemoveInventory, not TakeInventory.
2017-01-20 19:04:57 +00:00
PARAM_CLASS_NOT_NULL(item, AInventory);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
PARAM_INT(amount);
PARAM_BOOL_DEF(fromdecorate);
PARAM_BOOL_DEF(notakeinfinite);
Fixed returning of value from TakeInventory() function Issuing take CCMD no longer causes assertion failure at src/scripting/vm/vmexec.h:662 assert(numret == C && "Number of parameters returned differs from what was expected by the caller")
2017-01-22 11:51:22 +00:00
ACTION_RETURN_BOOL(self->TakeInventory(item, amount, fromdecorate, notakeinfinite));
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: DestroyAllInventory
//
//============================================================================
void AActor::DestroyAllInventory ()
{
- rewrote AActor::DestroyAllInventory so that it clears the item's link to its owner and the owner's inventory list before destroying them. There have been reports about crashes in here with Linux that point to some of the code that gets called here doing unwanted things on the owner, so with these links cleared that should no longer be possible.
2016-10-06 06:50:46 +00:00
AInventory *inv = Inventory;
if (inv != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- rewrote AActor::DestroyAllInventory so that it clears the item's link to its owner and the owner's inventory list before destroying them. There have been reports about crashes in here with Linux that point to some of the code that gets called here doing unwanted things on the owner, so with these links cleared that should no longer be possible.
2016-10-06 06:50:46 +00:00
TArray<AInventory *> toDelete;
// Delete the list in a two stage approach.
// This is necessary because an item may destroy another item (e.g. sister weapons)
// which would break the list and leave parts of it undestroyed, maybe doing bad things later.
while (inv != nullptr)
{
toDelete.Push(inv);
AInventory *item = inv->Inventory;
inv->Inventory = nullptr;
inv->Owner = nullptr;
inv = item;
}
for (auto p : toDelete)
{
// the item may already have been deleted by another one, so check this here to avoid problems.
if (!(p->ObjectFlags & OF_EuthanizeMe))
{
p->Destroy();
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//============================================================================
//
// AActor :: FirstInv
//
// Returns the first item in this actor's inventory that has IF_INVBAR set.
//
//============================================================================
AInventory *AActor::FirstInv ()
{
if (Inventory == NULL)
{
return NULL;
}
if (Inventory->ItemFlags & IF_INVBAR)
{
return Inventory;
}
return Inventory->NextInv ();
}
//============================================================================
//
// AActor :: UseInventory
//
// Attempts to use an item. If the use succeeds, one copy of the item is
// removed from the inventory. If all copies are removed, then the item is
// destroyed.
//
//============================================================================
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
bool AActor::UseInventory (AInventory *item)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// No using items if you're dead.
if (health <= 0)
{
return false;
}
// Don't use it if you don't actually have any of it.
if (item->Amount <= 0 || (item->ObjectFlags & OF_EuthanizeMe))
{
return false;
}
- completed Heretic scriptification with the two remaining artifacts.
2016-11-25 17:41:00 +00:00
if (!item->CallUse (false))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return false;
}
if (dmflags2 & DF2_INFINITE_INVENTORY)
return true;
if (--item->Amount <= 0)
{
item->DepleteOrDestroy ();
}
return true;
}
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
DEFINE_ACTION_FUNCTION(AActor, UseInventory)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(item, AInventory);
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
ACTION_RETURN_BOOL(self->UseInventory(item));
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//===========================================================================
//
// AActor :: DropInventory
//
// Removes a single copy of an item and throws it out in front of the actor.
//
//===========================================================================
AInventory *AActor::DropInventory (AInventory *item)
{
- more exporting of AInventory.
2017-01-19 19:56:31 +00:00
AInventory *drop = nullptr;
IFVIRTUALPTR(item, AInventory, CreateTossable)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Fixed undefined behavior of DropInventory() See https://mantis.zdoom.org/view.php?id=93
2017-01-21 09:40:22 +00:00
VMValue params[1] = { (DObject*)item };
- more exporting of AInventory.
2017-01-19 19:56:31 +00:00
VMReturn ret((void**)&drop);
GlobalVMStack.Call(func, params, 1, &ret, 1, nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- more exporting of AInventory.
2017-01-19 19:56:31 +00:00
if (drop == nullptr) return NULL;
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
drop->SetOrigin(PosPlusZ(10.), false);
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
drop->Angles.Yaw = Angles.Yaw;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
drop->VelFromAngle(5.);
drop->Vel.Z = 1.;
drop->Vel += Vel;
Normalize line endings
2016-03-01 15:47:10 +00:00
drop->flags &= ~MF_NOGRAVITY; // Don't float
drop->ClearCounters(); // do not count for statistics again
return drop;
}
- scriptified Oracle, Programmer and Rebels.
2016-11-28 18:42:26 +00:00
DEFINE_ACTION_FUNCTION(AActor, DropInventory)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(item, AInventory);
- scriptified Oracle, Programmer and Rebels.
2016-11-28 18:42:26 +00:00
ACTION_RETURN_OBJECT(self->DropInventory(item));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: FindInventory
//
//============================================================================
AInventory *AActor::FindInventory (PClassActor *type, bool subclass)
{
AInventory *item;
if (type == NULL)
{
return NULL;
}
for (item = Inventory; item != NULL; item = item->Inventory)
{
if (!subclass)
{
if (item->GetClass() == type)
{
break;
}
}
else
{
if (item->IsKindOf(type))
{
break;
}
}
}
return item;
}
- removed the remaining native parts of ABasicArmor. - simplified some FindInventory calls using PClass::FindActor to call the variant taking a name directly.
2017-01-18 21:57:47 +00:00
AInventory *AActor::FindInventory (FName type, bool subclass)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- removed the remaining native parts of ABasicArmor. - simplified some FindInventory calls using PClass::FindActor to call the variant taking a name directly.
2017-01-18 21:57:47 +00:00
return FindInventory(PClass::FindActor(type), subclass);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- implemented pass-by-reference arguments - so far only for memory based variables. - changed Dehacked weapon function lookup to check the symbol table instead of directly referencing the VM functions. Once scriptified these pointers will no longer be available. - removed all special ATAGs from the VM. While well intentioned any pointer tagged with them is basically unusable because it'd trigger asserts all over the place. - scriptified A_Punch for testing pass-by-reference parameters and stack variables.
2016-11-19 00:23:56 +00:00
DEFINE_ACTION_FUNCTION(AActor, FindInventory)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AInventory);
PARAM_BOOL_DEF(subclass);
ACTION_RETURN_OBJECT(self->FindInventory(type, subclass));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: GiveInventoryType
//
//============================================================================
AInventory *AActor::GiveInventoryType (PClassActor *type)
{
AInventory *item = NULL;
if (type != NULL)
{
- added a no-parameter Spawn function for inventory items that never show on the map, because the coordinate and replacement parameters will always be 0 for them. - started converting g_hexen. Most importantly this removes CHolyWeave as it is just a specialized version of A_Weave with far more convoluted use of parameters.
2016-03-21 13:00:05 +00:00
item = static_cast<AInventory *>(Spawn (type));
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!item->CallTryPickup (this))
{
item->Destroy ();
return NULL;
}
}
return item;
}
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
DEFINE_ACTION_FUNCTION(AActor, GiveInventoryType)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AInventory);
ACTION_RETURN_OBJECT(self->GiveInventoryType(type));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: GiveAmmo
//
// Returns true if the ammo was added, false if not.
//
//============================================================================
- removed PClassAmmo. No need to maintain these clunky meta class for one single property. The overhead the mere existence of this class creates is far more than 100 spawned ammo items would cost. There is no need to serialize AAmmo::DropAmount, this value has no meaning on an already spawned item.
2017-01-12 10:44:33 +00:00
bool AActor::GiveAmmo (PClassInventory *type, int amount)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (type != NULL)
{
- added a no-parameter Spawn function for inventory items that never show on the map, because the coordinate and replacement parameters will always be 0 for them. - started converting g_hexen. Most importantly this removes CHolyWeave as it is just a specialized version of A_Weave with far more convoluted use of parameters.
2016-03-21 13:00:05 +00:00
AInventory *item = static_cast<AInventory *>(Spawn (type));
Normalize line endings
2016-03-01 15:47:10 +00:00
if (item)
{
item->Amount = amount;
item->flags |= MF_DROPPED;
if (!item->CallTryPickup (this))
{
item->Destroy ();
return false;
}
return true;
}
}
return false;
}
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
DEFINE_ACTION_FUNCTION(AActor, GiveAmmo)
{
PARAM_SELF_PROLOGUE(AActor);
- scriptified the remains of AAmmo.
2017-01-18 13:18:17 +00:00
PARAM_CLASS(type, AInventory);
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
PARAM_INT(amount);
ACTION_RETURN_BOOL(self->GiveAmmo(type, amount));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: ClearInventory
//
// Clears the inventory of a single actor.
//
//============================================================================
void AActor::ClearInventory()
{
// In case destroying an inventory item causes another to be destroyed
// (e.g. Weapons destroy their sisters), keep track of the pointer to
// the next inventory item rather than the next inventory item itself.
// For example, if a weapon is immediately followed by its sister, the
// next weapon we had tracked would be to the sister, so it is now
// invalid and we won't be able to find the complete inventory by
// following it.
//
// When we destroy an item, we leave invp alone, since the destruction
// process will leave it pointing to the next item we want to check. If
// we don't destroy an item, then we move invp to point to its Inventory
// pointer.
//
// It should be safe to assume that an item being destroyed will only
// destroy items further down in the chain, because if it was going to
// destroy something we already processed, we've already destroyed it,
// so it won't have anything to destroy.
AInventory **invp = &Inventory;
while (*invp != NULL)
{
AInventory *inv = *invp;
if (!(inv->ItemFlags & IF_UNDROPPABLE))
{
- fixed: AActor::ClearInventory should respect IF_KEEPDEPLETED for all items.
2017-01-15 17:58:17 +00:00
inv->DepleteOrDestroy();
- scriptified the weapon piece functions. - fixed: ClearInventory did not process depleted items properly. - changed HexenArmor from UNDROPPABLE to UNTOSSABLE because this allowed to remove some special handling in ClearInventory. The only other place which checks this flag also checks UNTOSSABLE.
2017-01-18 16:26:12 +00:00
if (!(inv->ObjectFlags & OF_EuthanizeMe)) invp = &inv->Inventory; // was only depleted so advance the pointer manually.
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
invp = &inv->Inventory;
}
}
Generalized the psprites implementation
2016-05-09 18:03:47 +00:00
if (player != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Generalized the psprites implementation
2016-05-09 18:03:47 +00:00
player->ReadyWeapon = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
player->PendingWeapon = WP_NOCHANGE;
}
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, ClearInventory)
{
PARAM_SELF_PROLOGUE(AActor);
self->ClearInventory();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: CopyFriendliness
//
// Makes this actor hate (or like) the same things another actor does.
//
//============================================================================
void AActor::CopyFriendliness (AActor *other, bool changeTarget, bool resetHealth)
{
level.total_monsters -= CountsAsKill();
TIDtoHate = other->TIDtoHate;
LastLookActor = other->LastLookActor;
LastLookPlayerNumber = other->LastLookPlayerNumber;
flags = (flags & ~MF_FRIENDLY) | (other->flags & MF_FRIENDLY);
flags3 = (flags3 & ~(MF3_NOSIGHTCHECK | MF3_HUNTPLAYERS)) | (other->flags3 & (MF3_NOSIGHTCHECK | MF3_HUNTPLAYERS));
flags4 = (flags4 & ~(MF4_NOHATEPLAYERS | MF4_BOSSSPAWNED)) | (other->flags4 & (MF4_NOHATEPLAYERS | MF4_BOSSSPAWNED));
FriendPlayer = other->FriendPlayer;
DesignatedTeam = other->DesignatedTeam;
if (changeTarget && other->target != NULL && !(other->target->flags3 & MF3_NOTARGET) && !(other->target->flags7 & MF7_NEVERTARGET))
{
// LastHeard must be set as well so that A_Look can react to the new target if called
LastHeard = target = other->target;
}
if (resetHealth) health = SpawnHealth();
level.total_monsters += CountsAsKill();
}
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
DEFINE_ACTION_FUNCTION(AActor, CopyFriendliness)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(other, AActor);
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
PARAM_BOOL_DEF(changetarget);
PARAM_BOOL_DEF(resethealth);
self->CopyFriendliness(other, changetarget, resethealth);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: ObtainInventory
//
// Removes the items from the other actor and puts them in this actor's
// inventory. The actor receiving the inventory must not have any items.
//
//============================================================================
void AActor::ObtainInventory (AActor *other)
{
assert (Inventory == NULL);
Inventory = other->Inventory;
InventoryID = other->InventoryID;
other->Inventory = NULL;
other->InventoryID = 0;
if (other->IsKindOf(RUNTIME_CLASS(APlayerPawn)) && this->IsKindOf(RUNTIME_CLASS(APlayerPawn)))
{
APlayerPawn *you = static_cast<APlayerPawn *>(other);
APlayerPawn *me = static_cast<APlayerPawn *>(this);
me->InvFirst = you->InvFirst;
me->InvSel = you->InvSel;
you->InvFirst = NULL;
you->InvSel = NULL;
}
AInventory *item = Inventory;
while (item != NULL)
{
item->Owner = this;
item = item->Inventory;
}
}
- scriptified A_FreezeDeath(Chunks).
2017-01-14 17:26:59 +00:00
DEFINE_ACTION_FUNCTION(AActor, ObtainInventory)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(other, AActor);
self->ObtainInventory(other);
return 0;
}
- scriptified the health items.
2017-01-15 00:02:38 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_GiveBody
//
// Returns false if the body isn't needed at all.
//
//---------------------------------------------------------------------------
bool P_GiveBody(AActor *actor, int num, int max)
{
if (actor->health <= 0 || (actor->player != NULL && actor->player->playerstate == PST_DEAD))
{ // Do not heal dead things.
return false;
}
player_t *player = actor->player;
num = clamp(num, -65536, 65536); // prevent overflows for bad values
if (player != NULL)
{
// Max is 0 by default, preserving default behavior for P_GiveBody()
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
// calls while supporting health pickups.
- scriptified the health items.
2017-01-15 00:02:38 +00:00
if (max <= 0)
{
max = static_cast<APlayerPawn*>(actor)->GetMaxHealth() + player->mo->stamina;
// [MH] First step in predictable generic morph effects
if (player->morphTics)
{
if (player->MorphStyle & MORPH_FULLHEALTH)
{
if (!(player->MorphStyle & MORPH_ADDSTAMINA))
{
max -= player->mo->stamina;
}
}
else // old health behaviour
{
max = MAXMORPHHEALTH;
if (player->MorphStyle & MORPH_ADDSTAMINA)
{
max += player->mo->stamina;
}
}
}
}
// [RH] For Strife: A negative body sets you up with a percentage
// of your full health.
if (num < 0)
{
num = max * -num / 100;
if (player->health < num)
{
player->health = num;
actor->health = num;
return true;
}
}
else if (num > 0)
{
if (player->health < max)
{
num = int(num * G_SkillProperty(SKILLP_HealthFactor));
if (num < 1) num = 1;
player->health += num;
if (player->health > max)
{
player->health = max;
}
actor->health = player->health;
return true;
}
}
}
else
{
// Parameter value for max is ignored on monsters, preserving original
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
// behaviour of health as well as on existing calls to P_GiveBody().
- scriptified the health items.
2017-01-15 00:02:38 +00:00
max = actor->SpawnHealth();
if (num < 0)
{
num = max * -num / 100;
if (actor->health < num)
{
actor->health = num;
return true;
}
}
else if (actor->health < max)
{
actor->health += num;
if (actor->health > max)
{
actor->health = max;
}
return true;
}
}
return false;
}
DEFINE_ACTION_FUNCTION(AActor, GiveBody)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(num);
PARAM_INT_DEF(max);
ACTION_RETURN_BOOL(P_GiveBody(self, num, max));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: CheckLocalView
//
// Returns true if this actor is local for the player. Here, local means the
// player is either looking out this actor's eyes, or this actor is the player
// and the player is looking out the eyes of something non-"sentient."
//
//============================================================================
bool AActor::CheckLocalView (int playernum) const
{
if (players[playernum].camera == this)
{
return true;
}
if (players[playernum].mo != this || players[playernum].camera == NULL)
{
return false;
}
if (players[playernum].camera->player == NULL &&
!(players[playernum].camera->flags3 & MF3_ISMONSTER))
{
return true;
}
return false;
}
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
DEFINE_ACTION_FUNCTION(AActor, CheckLocalView)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(cp);
ACTION_RETURN_BOOL(self->CheckLocalView(cp));
}
Updated to new save game code.
2016-09-18 20:07:08 +00:00
//============================================================================
//
// AActor :: IsInsideVisibleAngles
//
// Returns true if this actor is within viewing angle/pitch visibility.
//
//============================================================================
bool AActor::IsInsideVisibleAngles() const
{
// Don't bother masking if not wanted.
if (!(renderflags & RF_MASKROTATION))
return true;
if (players[consoleplayer].camera == nullptr)
return true;
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
DAngle anglestart = VisibleStartAngle;
DAngle angleend = VisibleEndAngle;
DAngle pitchstart = VisibleStartPitch;
DAngle pitchend = VisibleEndPitch;
Updated to new save game code.
2016-09-18 20:07:08 +00:00
if (anglestart > angleend)
{
DAngle temp = anglestart;
anglestart = angleend;
angleend = temp;
}
- fixed pitch comparison in visibility checking.
2016-09-24 07:42:35 +00:00
if (pitchstart > pitchend)
Updated to new save game code.
2016-09-18 20:07:08 +00:00
{
DAngle temp = pitchstart;
pitchstart = pitchend;
pitchend = temp;
}
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
Updated to new save game code.
2016-09-18 20:07:08 +00:00
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
AActor *mo = players[consoleplayer].camera;
Updated to new save game code.
2016-09-18 20:07:08 +00:00
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
if (mo != nullptr)
Updated to new save game code.
2016-09-18 20:07:08 +00:00
{
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
DVector3 diffang = ViewPos - Pos();
Updated to new save game code.
2016-09-18 20:07:08 +00:00
DAngle to = diffang.Angle();
if (!(renderflags & RF_ABSMASKANGLE))
to = deltaangle(Angles.Yaw, to);
- Don't use Normalized180() on angles. This could result in ranges being wrongly inverted. - Fixed properties not having the proper indices. - Use ViewPos-to-actor instead of measuring actor-to-actor. - Use the actual camera instead of the actor so camera textures can work.
2016-09-24 15:26:21 +00:00
if ((to >= anglestart && to <= angleend))
Updated to new save game code.
2016-09-18 20:07:08 +00:00
{
to = diffang.Pitch();
if (!(renderflags & RF_ABSMASKPITCH))
to = deltaangle(Angles.Pitch, to);
return !!(to >= pitchstart && to <= pitchend);
}
else return false;
}
return true;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: IsVisibleToPlayer
//
// Returns true if this actor should be seen by the console player.
//
//============================================================================
bool AActor::IsVisibleToPlayer() const
{
// [BB] Safety check. This should never be NULL. Nevertheless, we return true to leave the default ZDoom behavior unaltered.
if ( players[consoleplayer].camera == NULL )
return true;
if (VisibleToTeam != 0 && teamplay &&
(signed)(VisibleToTeam-1) != players[consoleplayer].userinfo.GetTeam() )
return false;
const player_t* pPlayer = players[consoleplayer].camera->player;
if (pPlayer && pPlayer->mo && GetClass()->VisibleToPlayerClass.Size() > 0)
{
bool visible = false;
for(unsigned int i = 0;i < GetClass()->VisibleToPlayerClass.Size();++i)
{
PClassPlayerPawn *cls = GetClass()->VisibleToPlayerClass[i];
if (cls && pPlayer->mo->GetClass()->IsDescendantOf(cls))
{
visible = true;
break;
}
}
if (!visible)
return false;
}
// [BB] Passed all checks.
return true;
}
//============================================================================
//
// AActor :: ConversationAnimation
//
// Plays a conversation-related animation:
// 0 = greeting
// 1 = "yes"
// 2 = "no"
//
//============================================================================
void AActor::ConversationAnimation (int animnum)
{
FState * state = NULL;
switch (animnum)
{
case 0:
state = FindState(NAME_Greetings);
break;
case 1:
state = FindState(NAME_Yes);
break;
case 2:
state = FindState(NAME_No);
break;
}
if (state != NULL) SetState(state);
}
//============================================================================
//
// AActor :: Touch
//
// Something just touched this actor. Normally used only for inventory items,
// but some Strife monsters also use it.
//
//============================================================================
void AActor::Touch (AActor *toucher)
{
}
- scriptified a_spectral.cpp. - consolidated A_Tracer and A_Tracer2. Note that this commit temporarily disables a few features in order to make it compile.
2016-11-28 11:55:33 +00:00
DEFINE_ACTION_FUNCTION(AActor, Touch)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(toucher, AActor);
- scriptified a_spectral.cpp. - consolidated A_Tracer and A_Tracer2. Note that this commit temporarily disables a few features in order to make it compile.
2016-11-28 11:55:33 +00:00
self->Touch(toucher);
return 0;
}
void AActor::CallTouch(AActor *toucher)
{
IFVIRTUAL(AActor, Touch)
{
VMValue params[2] = { (DObject*)this, toucher };
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 2, nullptr, 0, nullptr);
- scriptified a_spectral.cpp. - consolidated A_Tracer and A_Tracer2. Note that this commit temporarily disables a few features in order to make it compile.
2016-11-28 11:55:33 +00:00
}
else Touch(toucher);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//============================================================================
//
// AActor :: Grind
//
// Handles the an actor being crushed by a door, crusher or polyobject.
// Originally part of P_DoCrunch(), it has been made into its own actor
// function so that it could be called from a polyobject without hassle.
// Bool items is true if it should destroy() dropped items, false otherwise.
//============================================================================
bool AActor::Grind(bool items)
{
// crunch bodies to giblets
if ((flags & MF_CORPSE) && !(flags3 & MF3_DONTGIB) && (health <= 0))
{
FState * state = FindState(NAME_Crush);
// In Heretic and Chex Quest we don't change the actor's sprite, just its size.
if (state == NULL && gameinfo.dontcrunchcorpses)
{
flags &= ~MF_SOLID;
flags3 |= MF3_DONTGIB;
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
Height = 0;
- made AActor::radius a double. This means that all files in g_doom are now fully converted.
2016-03-20 14:04:13 +00:00
radius = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
return false;
}
bool isgeneric = false;
// ZDoom behavior differs from standard as crushed corpses cannot be raised.
// The reason for the change was originally because of a problem with players,
// see rh_log entry for February 21, 1999. Don't know if it is still relevant.
if (state == NULL // Only use the default crushed state if:
&& !(flags & MF_NOBLOOD) // 1. the monster bleeeds,
&& (i_compatflags & COMPATF_CORPSEGIBS) // 2. the compat setting is on,
&& player == NULL) // 3. and the thing isn't a player.
{
isgeneric = true;
state = FindState(NAME_GenericCrush);
if (state != NULL && (sprites[state->sprite].numframes <= 0))
state = NULL; // If one of these tests fails, do not use that state.
}
if (state != NULL && !(flags & MF_ICECORPSE))
{
if (this->flags4 & MF4_BOSSDEATH)
{
A_BossDeath(this);
}
flags &= ~MF_SOLID;
flags3 |= MF3_DONTGIB;
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
Height = 0;
- made AActor::radius a double. This means that all files in g_doom are now fully converted.
2016-03-20 14:04:13 +00:00
radius = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
SetState (state);
if (isgeneric) // Not a custom crush state, so colorize it appropriately.
{
S_Sound (this, CHAN_BODY, "misc/fallingsplat", 1, ATTN_IDLE);
PalEntry bloodcolor = GetBloodColor();
if (bloodcolor!=0) Translation = TRANSLATION(TRANSLATION_Blood, bloodcolor.a);
}
return false;
}
if (!(flags & MF_NOBLOOD))
{
if (this->flags4 & MF4_BOSSDEATH)
{
A_BossDeath(this);
}
PClassActor *i = PClass::FindActor("RealGibs");
if (i != NULL)
{
i = i->GetReplacement();
const AActor *defaults = GetDefaultByType (i);
if (defaults->SpawnState == NULL ||
sprites[defaults->SpawnState->sprite].numframes == 0)
{
i = NULL;
}
}
if (i == NULL)
{
// if there's no gib sprite don't crunch it.
flags &= ~MF_SOLID;
flags3 |= MF3_DONTGIB;
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
Height = 0;
- made AActor::radius a double. This means that all files in g_doom are now fully converted.
2016-03-20 14:04:13 +00:00
radius = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
return false;
}
AActor *gib = Spawn (i, Pos(), ALLOW_REPLACE);
if (gib != NULL)
{
gib->RenderStyle = RenderStyle;
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
gib->Alpha = Alpha;
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
gib->Height = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
gib->radius = 0;
PalEntry bloodcolor = GetBloodColor();
if (bloodcolor != 0)
gib->Translation = TRANSLATION(TRANSLATION_Blood, bloodcolor.a);
}
S_Sound (this, CHAN_BODY, "misc/fallingsplat", 1, ATTN_IDLE);
}
if (flags & MF_ICECORPSE)
{
tics = 1;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel.Zero();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (player)
{
flags |= MF_NOCLIP;
flags3 |= MF3_DONTGIB;
renderflags |= RF_INVISIBLE;
}
else
{
Destroy ();
}
return false; // keep checking
}
// killough 11/98: kill touchy things immediately
if (flags6 & MF6_TOUCHY && (flags6 & MF6_ARMED || IsSentient()))
{
flags6 &= ~MF6_ARMED; // Disarm
P_DamageMobj (this, NULL, NULL, health, NAME_Crush, DMG_FORCED); // kill object
return true; // keep checking
}
if (!(flags & MF_SOLID) || (flags & MF_NOCLIP))
{
return false;
}
if (!(flags & MF_SHOOTABLE))
{
return false; // assume it is bloody gibs or something
}
return true;
}
//============================================================================
//
// AActor :: Massacre
//
// Called by the massacre cheat to kill monsters. Returns true if the monster
// was killed and false if it was already dead.
//============================================================================
bool AActor::Massacre ()
{
int prevhealth;
if (health > 0)
{
- fixed: AActor::Masacre must restore the flag if it cannot kill the monster.
2016-10-01 10:08:07 +00:00
auto f = flags;
auto f2 = flags2;
Normalize line endings
2016-03-01 15:47:10 +00:00
flags |= MF_SHOOTABLE;
flags2 &= ~(MF2_DORMANT|MF2_INVULNERABLE);
do
{
prevhealth = health;
P_DamageMobj (this, NULL, NULL, TELEFRAG_DAMAGE, NAME_Massacre);
}
while (health != prevhealth && health > 0); //abort if the actor wasn't hurt.
- fixed: AActor::Masacre must restore the flag if it cannot kill the monster.
2016-10-01 10:08:07 +00:00
if (health > 0)
{
// restore flags if this did not kill the monster.
flags = f;
flags2 = f2;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
return health <= 0;
}
return false;
}
//----------------------------------------------------------------------------
//
// PROC P_ExplodeMissile
//
//----------------------------------------------------------------------------
void P_ExplodeMissile (AActor *mo, line_t *line, AActor *target)
{
if (mo->flags3 & MF3_EXPLOCOUNT)
{
if (++mo->threshold < mo->DefThreshold)
{
return;
}
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Zero();
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->effects = 0; // [RH]
mo->flags &= ~MF_SHOOTABLE;
- Fixed HITTARGET, HITMASTER, HITTRACER, crash and xdeath states being broken on bouncing actors that die/explode.
2017-01-27 16:21:22 +00:00
FState *nextstate = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
- Fixed HITTARGET, HITMASTER, HITTRACER, crash and xdeath states being broken on bouncing actors that die/explode.
2017-01-27 16:21:22 +00:00
if (target != nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (mo->flags7 & MF7_HITTARGET) mo->target = target;
if (mo->flags7 & MF7_HITMASTER) mo->master = target;
if (mo->flags7 & MF7_HITTRACER) mo->tracer = target;
- Fixed HITTARGET, HITMASTER, HITTRACER, crash and xdeath states being broken on bouncing actors that die/explode.
2017-01-27 16:21:22 +00:00
if ((target->flags & (MF_SHOOTABLE | MF_CORPSE)) || (target->flags6 & MF6_KILLED))
{
if (target->flags & MF_NOBLOOD) nextstate = mo->FindState(NAME_Crash);
if (nextstate == NULL) nextstate = mo->FindState(NAME_Death, NAME_Extreme);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (nextstate == NULL) nextstate = mo->FindState(NAME_Death);
if (line != NULL && line->special == Line_Horizon && !(mo->flags3 & MF3_SKYEXPLODE))
{
// [RH] Don't explode missiles on horizon lines.
mo->Destroy ();
return;
}
if (line != NULL && cl_missiledecals)
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector3 pos = mo->PosRelative(line);
int side = P_PointOnLineSidePrecise (pos, line);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (line->sidedef[side] == NULL)
side ^= 1;
if (line->sidedef[side] != NULL)
{
FDecalBase *base = mo->DecalGenerator;
if (base != NULL)
{
// Find the nearest point on the line, and stick a decal there
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector3 linepos;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double den, frac;
Normalize line endings
2016-03-01 15:47:10 +00:00
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
den = line->Delta().LengthSquared();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (den != 0)
{
- fixed the sound location calculations which got somewhat broken by the constant changes during the conversion.
2016-03-31 19:13:32 +00:00
frac = clamp<double>((mo->Pos().XY() - line->v1->fPos()) | line->Delta(), 0, den) / den;
Normalize line endings
2016-03-01 15:47:10 +00:00
- fixed the sound location calculations which got somewhat broken by the constant changes during the conversion.
2016-03-31 19:13:32 +00:00
linepos = DVector3(line->v1->fPos() + line->Delta() * frac, pos.Z);
Normalize line endings
2016-03-01 15:47:10 +00:00
F3DFloor * ffloor=NULL;
if (line->sidedef[side^1] != NULL)
{
sector_t * backsector = line->sidedef[side^1]->sector;
extsector_t::xfloor &xf = backsector->e->XFloor;
// find a 3D-floor to stick to
for(unsigned int i=0;i<xf.ffloors.Size();i++)
{
F3DFloor * rover=xf.ffloors[i];
if ((rover->flags&(FF_EXISTS|FF_SOLID|FF_RENDERSIDES))==(FF_EXISTS|FF_SOLID|FF_RENDERSIDES))
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (pos.Z <= rover->top.plane->ZatPoint(linepos) && pos.Z >= rover->bottom.plane->ZatPoint(linepos))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
ffloor = rover;
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
}
}
}
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DImpactDecal::StaticCreate(base->GetDecal(), linepos, line->sidedef[side], ffloor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
}
- split DObject::Destroy into the main method, a native OnDestroy and a scripted OnDestroy method and made the main method non-virtual This was done to ensure it can be properly overridden in scripts without causing problems when called during engine shutdown for the type and symbol objects the VM needs to work and to have the scripted version always run first. Since the scripted OnDestroy method never calls the native version - the native one is run after the scripted one - this can be simply skipped over during shutdown.
2017-01-12 21:49:18 +00:00
// play the sound before changing the state, so that AActor::OnDestroy can call S_RelinkSounds on it and the death state can override it.
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->DeathSound)
{
S_Sound (mo, CHAN_VOICE, mo->DeathSound, 1,
(mo->flags3 & MF3_FULLVOLDEATH) ? ATTN_NONE : ATTN_NORM);
}
mo->SetState (nextstate);
if (!(mo->ObjectFlags & OF_EuthanizeMe))
{
// The rest only applies if the missile actor still exists.
// [RH] Change render style of exploding rockets
if (mo->flags5 & MF5_DEHEXPLOSION)
{
if (deh.ExplosionStyle == 255)
{
if (addrocketexplosion)
{
mo->RenderStyle = STYLE_Add;
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
mo->Alpha = 1.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
mo->RenderStyle = STYLE_Translucent;
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
mo->Alpha = 0.6666;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
mo->RenderStyle = ERenderStyle(deh.ExplosionStyle);
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
mo->Alpha = deh.ExplosionAlpha;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
if (mo->flags4 & MF4_RANDOMIZE)
{
mo->tics -= (pr_explodemissile() & 3) * TICRATE / 35;
if (mo->tics < 1)
mo->tics = 1;
}
mo->flags &= ~MF_MISSILE;
}
}
- scriptified Hexen's lightning weapon.
2016-11-27 21:14:18 +00:00
DEFINE_ACTION_FUNCTION(AActor, ExplodeMissile)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER_DEF(line, line_t);
PARAM_OBJECT_DEF(target, AActor);
P_ExplodeMissile(self, line, target);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::PlayBounceSound(bool onfloor)
{
if (!onfloor && (BounceFlags & BOUNCE_NoWallSound))
{
return;
}
if (!(BounceFlags & BOUNCE_Quiet))
{
if (BounceFlags & BOUNCE_UseSeeSound)
{
S_Sound (this, CHAN_VOICE, SeeSound, 1, ATTN_IDLE);
}
else if (onfloor || WallBounceSound <= 0)
{
S_Sound (this, CHAN_VOICE, BounceSound, 1, ATTN_IDLE);
}
else
{
S_Sound (this, CHAN_VOICE, WallBounceSound, 1, ATTN_IDLE);
}
}
}
//----------------------------------------------------------------------------
//
// PROC P_FloorBounceMissile
//
// Returns true if the missile was destroyed
//----------------------------------------------------------------------------
bool AActor::FloorBounceMissile (secplane_t &plane)
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (Z() <= floorz && P_HitFloor (this))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// Landed in some sort of liquid
if (BounceFlags & BOUNCE_ExplodeOnWater)
{
if (flags & MF_MISSILE)
P_ExplodeMissile(this, NULL, NULL);
else
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
CallDie(NULL, NULL);
Normalize line endings
2016-03-01 15:47:10 +00:00
return true;
}
if (!(BounceFlags & BOUNCE_CanBounceWater))
{
Destroy ();
return true;
}
}
- replaced all direct access to sector plane coefficients with wrapper functions.
2016-03-29 10:40:41 +00:00
if (plane.fC() < 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // on ceiling
if (!(BounceFlags & BOUNCE_Ceilings))
return true;
}
else
{ // on floor
if (!(BounceFlags & BOUNCE_Floors))
return true;
}
// The amount of bounces is limited
if (bouncecount>0 && --bouncecount==0)
{
if (flags & MF_MISSILE)
P_ExplodeMissile(this, NULL, NULL);
else
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
CallDie(NULL, NULL);
Normalize line endings
2016-03-01 15:47:10 +00:00
return true;
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double dot = (Vel | plane.Normal()) * 2;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (BounceFlags & (BOUNCE_HereticType | BOUNCE_MBF))
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel -= plane.Normal() * dot;
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
AngleFromVel();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!(BounceFlags & BOUNCE_MBF)) // Heretic projectiles die, MBF projectiles don't.
{
flags |= MF_INBOUNCE;
SetState (FindState(NAME_Death));
flags &= ~MF_INBOUNCE;
return false;
}
- floatified AActor::bouncefactor and wallbouncefactor.
2016-03-24 19:43:35 +00:00
else Vel.Z *= bouncefactor;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else // Don't run through this for MBF-style bounces
{
// The reflected velocity keeps only about 70% of its original speed
- floatified AActor::bouncefactor and wallbouncefactor.
2016-03-24 19:43:35 +00:00
Vel = (Vel - plane.Normal() * dot) * bouncefactor;
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
AngleFromVel();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
PlayBounceSound(true);
// Set bounce state
if (BounceFlags & BOUNCE_UseBounceState)
{
FName names[2];
FState *bouncestate;
names[0] = NAME_Bounce;
- replaced all direct access to sector plane coefficients with wrapper functions.
2016-03-29 10:40:41 +00:00
names[1] = plane.fC() < 0 ? NAME_Ceiling : NAME_Floor;
Normalize line endings
2016-03-01 15:47:10 +00:00
bouncestate = FindState(2, names);
if (bouncestate != NULL)
{
SetState(bouncestate);
}
}
if (BounceFlags & BOUNCE_MBF) // Bring it to rest below a certain speed
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (fabs(Vel.Z) < Mass * GetGravity() / 64)
Vel.Z = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (BounceFlags & (BOUNCE_AutoOff|BOUNCE_AutoOffFloorOnly))
{
- replaced all direct access to sector plane coefficients with wrapper functions.
2016-03-29 10:40:41 +00:00
if (plane.fC() > 0 || (BounceFlags & BOUNCE_AutoOff))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// AutoOff only works when bouncing off a floor, not a ceiling (or in compatibility mode.)
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (!(flags & MF_NOGRAVITY) && (Vel.Z < 3))
Normalize line endings
2016-03-01 15:47:10 +00:00
BounceFlags &= ~BOUNCE_TypeMask;
}
}
return false;
}
//----------------------------------------------------------------------------
//
// FUNC P_FaceMobj
//
// Returns 1 if 'source' needs to turn clockwise, or 0 if 'source' needs
// to turn counter clockwise. 'delta' is set to the amount 'source'
// needs to turn.
//
//----------------------------------------------------------------------------
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
int P_FaceMobj (AActor *source, AActor *target, DAngle *delta)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
DAngle diff;
Normalize line endings
2016-03-01 15:47:10 +00:00
- renamed some functions and fixed a few more conversion errors.
2016-03-16 23:07:37 +00:00
diff = deltaangle(source->Angles.Yaw, source->AngleTo(target));
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
if (diff > 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
*delta = diff;
- renamed some functions and fixed a few more conversion errors.
2016-03-16 23:07:37 +00:00
return 1;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
*delta = -diff;
- renamed some functions and fixed a few more conversion errors.
2016-03-16 23:07:37 +00:00
return 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//----------------------------------------------------------------------------
//
// CanSeek
//
// Checks if a seeker missile can home in on its target
//
//----------------------------------------------------------------------------
bool AActor::CanSeek(AActor *target) const
{
if (target->flags5 & MF5_CANTSEEK) return false;
if ((flags2 & MF2_DONTSEEKINVISIBLE) &&
((target->flags & MF_SHADOW) ||
(target->renderflags & RF_INVISIBLE) ||
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
!target->RenderStyle.IsVisible(target->Alpha)
Normalize line endings
2016-03-01 15:47:10 +00:00
)
) return false;
return true;
}
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
DEFINE_ACTION_FUNCTION(AActor, CanSeek)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(target, AActor);
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
ACTION_RETURN_BOOL(self->CanSeek(target));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//----------------------------------------------------------------------------
//
// FUNC P_SeekerMissile
//
// The missile's tracer field must be the target. Returns true if
// target was tracked, false if not.
//
//----------------------------------------------------------------------------
- g_hexen almost done except for 3 things that require more extensive changes.
2016-03-21 21:20:10 +00:00
bool P_SeekerMissile (AActor *actor, double thresh, double turnMax, bool precise, bool usecurspeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
int dir;
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
DAngle delta;
Normalize line endings
2016-03-01 15:47:10 +00:00
AActor *target;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double speed;
Normalize line endings
2016-03-01 15:47:10 +00:00
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
speed = !usecurspeed ? actor->Speed : actor->VelToSpeed();
Normalize line endings
2016-03-01 15:47:10 +00:00
target = actor->tracer;
if (target == NULL || !actor->CanSeek(target))
{
return false;
}
if (!(target->flags & MF_SHOOTABLE))
{ // Target died
actor->tracer = NULL;
return false;
}
if (speed == 0)
{ // Technically, we're not seeking since our speed is 0, but the target *is* seekable.
return true;
}
dir = P_FaceMobj (actor, target, &delta);
if (delta > thresh)
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
delta /= 2;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (delta > turnMax)
{
delta = turnMax;
}
}
if (dir)
{ // Turn clockwise
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
actor->Angles.Yaw += delta;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{ // Turn counter clockwise
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
actor->Angles.Yaw -= delta;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (!precise)
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
actor->VelFromAngle(speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!(actor->flags3 & (MF3_FLOORHUGGER|MF3_CEILINGHUGGER)))
{
if (actor->Top() < target->Z() ||
target->Top() < actor->Z())
{ // Need to seek vertically
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
actor->Vel.Z = (target->Center() - actor->Center()) / actor->DistanceBySpeed(target, speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
else
{
- several fixes.
2016-03-16 21:29:35 +00:00
DAngle pitch = 0.;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!(actor->flags3 & (MF3_FLOORHUGGER|MF3_CEILINGHUGGER)))
{ // Need to seek vertically
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
double dist = MAX(1., actor->Distance2D(target));
Normalize line endings
2016-03-01 15:47:10 +00:00
// Aim at a player's eyes and at the middle of the actor for everything else.
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
double aimheight = target->Height/2;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (target->IsKindOf(RUNTIME_CLASS(APlayerPawn)))
{
aimheight = static_cast<APlayerPawn *>(target)->ViewHeight;
}
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
pitch = DVector2(dist, target->Z() + aimheight - actor->Center()).Angle();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed pitch calculation in P_SeekerMissile with SMF_PRECISE.
2016-04-04 21:07:21 +00:00
actor->Vel3DFromAngle(-pitch, speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return true;
}
//
// P_XYMovement
//
// Returns the actor's old floorz.
//
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
#define STOPSPEED (0x1000/65536.)
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
#define CARRYSTOPSPEED ((0x1000*32/3)/65536.)
Normalize line endings
2016-03-01 15:47:10 +00:00
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
double P_XYMovement (AActor *mo, DVector2 scroll)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
static int pushtime = 0;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
bool bForceSlide = !scroll.isZero();
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
DAngle Angle;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 ptry;
Normalize line endings
2016-03-01 15:47:10 +00:00
player_t *player;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 move;
Normalize line endings
2016-03-01 15:47:10 +00:00
const secplane_t * walkplane;
- replaced all uses of P_ThrustMobj with the already implemented AActor::Thrust method and deleted this function. - for quakes, making a distinction between circular and elliptic thrust is pointless, so the checks were removed and both paths consolidated. The elliptic code will do exactly the same for circles and there isn't even a performance difference.
2016-03-20 00:25:47 +00:00
static const double windTab[3] = { 5 / 32., 10 / 32., 25 / 32. };
Normalize line endings
2016-03-01 15:47:10 +00:00
int steps, step, totalsteps;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 start;
double Oldfloorz = mo->floorz;
double oldz = mo->Z();
Normalize line endings
2016-03-01 15:47:10 +00:00
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double maxmove = (mo->waterlevel < 1) || (mo->flags & MF_MISSILE) ||
- made player_t::crouchoffset and FPlayerStart's coordinates doubles and added a float version of divline_t so that I could complete the conversion of Hexen's game code. - consolidated the actor based damage factor code which was repeated multiple times in various damage inflicting functions.
2016-03-21 23:06:58 +00:00
(mo->player && mo->player->crouchoffset<-10) ? MAXMOVE : MAXMOVE/4;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->flags2 & MF2_WINDTHRUST && mo->waterlevel < 2 && !(mo->flags & MF_NOCLIP))
{
int special = mo->Sector->special;
switch (special)
{
case 40: case 41: case 42: // Wind_East
- replaced all uses of P_ThrustMobj with the already implemented AActor::Thrust method and deleted this function. - for quakes, making a distinction between circular and elliptic thrust is pointless, so the checks were removed and both paths consolidated. The elliptic code will do exactly the same for circles and there isn't even a performance difference.
2016-03-20 00:25:47 +00:00
mo->Thrust(0., windTab[special-40]);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case 43: case 44: case 45: // Wind_North
- replaced all uses of P_ThrustMobj with the already implemented AActor::Thrust method and deleted this function. - for quakes, making a distinction between circular and elliptic thrust is pointless, so the checks were removed and both paths consolidated. The elliptic code will do exactly the same for circles and there isn't even a performance difference.
2016-03-20 00:25:47 +00:00
mo->Thrust(90., windTab[special-43]);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case 46: case 47: case 48: // Wind_South
- replaced all uses of P_ThrustMobj with the already implemented AActor::Thrust method and deleted this function. - for quakes, making a distinction between circular and elliptic thrust is pointless, so the checks were removed and both paths consolidated. The elliptic code will do exactly the same for circles and there isn't even a performance difference.
2016-03-20 00:25:47 +00:00
mo->Thrust(270., windTab[special-46]);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
case 49: case 50: case 51: // Wind_West
- replaced all uses of P_ThrustMobj with the already implemented AActor::Thrust method and deleted this function. - for quakes, making a distinction between circular and elliptic thrust is pointless, so the checks were removed and both paths consolidated. The elliptic code will do exactly the same for circles and there isn't even a performance difference.
2016-03-20 00:25:47 +00:00
mo->Thrust(180., windTab[special-49]);
Normalize line endings
2016-03-01 15:47:10 +00:00
break;
}
}
// [RH] No need to clamp these now. However, wall running needs it so
// that large thrusts can't propel an actor through a wall, because wall
// running depends on the player's original movement continuing even after
// it gets blocked.
if ((mo->player != NULL && (i_compatflags & COMPATF_WALLRUN)) || (mo->waterlevel >= 1) ||
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
(mo->player != NULL && mo->player->crouchfactor < 0.75))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// preserve the direction instead of clamping x and y independently.
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double cx = mo->Vel.X == 0 ? 1. : clamp(mo->Vel.X, -maxmove, maxmove) / mo->Vel.X;
double cy = mo->Vel.Y == 0 ? 1. : clamp(mo->Vel.Y, -maxmove, maxmove) / mo->Vel.Y;
double fac = MIN(cx, cy);
Normalize line endings
2016-03-01 15:47:10 +00:00
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X *= fac;
mo->Vel.Y *= fac;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed: Actor velocity requires an upper limit to prevent uncontrolled accumulation, as can happen when multiple exploding and pushable objects overlap. The value 5000 was chosen because it is high enough to not occur under regular circumstances and small enough to prevent severe slowdowns. In the old fixed point code the lack of such a check just caused random overflows.
2016-08-31 07:18:59 +00:00
const double VELOCITY_THRESHOLD = 5000; // don't let it move faster than this. Fixed point overflowed at 32768 but that's too much to make this safe.
if (mo->Vel.LengthSquared() >= VELOCITY_THRESHOLD*VELOCITY_THRESHOLD)
{
mo->Vel.MakeResize(VELOCITY_THRESHOLD);
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
move = mo->Vel;
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Carrying sectors didn't work with low speeds in BOOM. This is
// because BOOM relied on the speed being fast enough to accumulate
// despite friction. If the speed is too low, then its movement will get
// cancelled, and it won't accumulate to the desired speed.
mo->flags4 &= ~MF4_SCROLLMOVE;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (fabs(scroll.X) > CARRYSTOPSPEED)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
scroll.X *= CARRYFACTOR;
mo->Vel.X += scroll.X;
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->flags4 |= MF4_SCROLLMOVE;
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (fabs(scroll.Y) > CARRYSTOPSPEED)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
scroll.Y *= CARRYFACTOR;
mo->Vel.Y += scroll.Y;
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->flags4 |= MF4_SCROLLMOVE;
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
move += scroll;
Normalize line endings
2016-03-01 15:47:10 +00:00
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (move.isZero())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (mo->flags & MF_SKULLFLY)
{
// the skull slammed into something
mo->flags &= ~MF_SKULLFLY;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Zero();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!(mo->flags2 & MF2_DORMANT))
{
if (mo->SeeState != NULL) mo->SetState (mo->SeeState);
else mo->SetIdle();
}
else
{
mo->SetIdle();
mo->tics = -1;
}
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
player = mo->player;
// [RH] Adjust player movement on sloped floors
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 startmove = move;
walkplane = P_CheckSlopeWalk (mo, move);
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Take smaller steps when moving faster than the object's size permits.
// Moving as fast as the object's "diameter" is bad because it could skip
// some lines because the actor could land such that it is just touching the
// line. For Doom to detect that the line is there, it needs to actually cut
// through the actor.
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
double maxmove = mo->radius - 1;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (maxmove <= 0)
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
{ // gibs can have radius 0, so don't divide by zero below!
maxmove = MAXMOVE;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
const double xspeed = fabs (move.X);
const double yspeed = fabs (move.Y);
Normalize line endings
2016-03-01 15:47:10 +00:00
steps = 1;
if (xspeed > yspeed)
{
if (xspeed > maxmove)
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
steps = int(1 + xspeed / maxmove);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
if (yspeed > maxmove)
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
steps = int(1 + yspeed / maxmove);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
// P_SlideMove needs to know the step size before P_CheckSlopeWalk
// because it also calls P_CheckSlopeWalk on its clipped steps.
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 onestep = startmove / steps;
Normalize line endings
2016-03-01 15:47:10 +00:00
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
start = mo->Pos();
Normalize line endings
2016-03-01 15:47:10 +00:00
step = 1;
totalsteps = steps;
// [RH] Instead of doing ripping damage each step, do it each tic.
// This makes it compatible with Heretic and Hexen, which only did
// one step for their missiles with ripping damage (excluding those
// that don't use P_XYMovement). It's also more intuitive since it
// makes the damage done dependant on the amount of time the projectile
// spends inside a target rather than on the projectile's size. The
// last actor ripped through is recorded so that if the projectile
// passes through more than one actor this tic, each one takes damage
// and not just the first one.
pushtime++;
FCheckPosition tm(!!(mo->flags2 & MF2_RIP));
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DAngle oldangle = mo->Angles.Yaw;
Normalize line endings
2016-03-01 15:47:10 +00:00
do
{
if (i_compatflags & COMPATF_WALLRUN) pushtime++;
tm.PushTime = pushtime;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
ptry = start + move * step / steps;
Normalize line endings
2016-03-01 15:47:10 +00:00
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 startvel = mo->Vel;
Normalize line endings
2016-03-01 15:47:10 +00:00
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
// killough 3/15/98: Allow objects to drop off
// [RH] If walking on a slope, stay on the slope
if (!P_TryMove (mo, ptry, true, walkplane, tm))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// blocked move
AActor *BlockingMobj = mo->BlockingMobj;
line_t *BlockingLine = mo->BlockingLine;
if (!(mo->flags & MF_MISSILE) && (mo->BounceFlags & BOUNCE_MBF)
&& (BlockingMobj != NULL ? P_BounceActor(mo, BlockingMobj, false) : P_BounceWall(mo)))
{
// Do nothing, relevant actions already done in the condition.
// This allows to avoid setting velocities to 0 in the final else of this series.
}
else if ((mo->flags2 & (MF2_SLIDE|MF2_BLASTED) || bForceSlide) && !(mo->flags&MF_MISSILE))
{ // try to slide along it
if (BlockingMobj == NULL)
{ // slide against wall
if (BlockingLine != NULL &&
mo->player && mo->waterlevel && mo->waterlevel < 3 &&
(mo->player->cmd.ucmd.forwardmove | mo->player->cmd.ucmd.sidemove) &&
mo->BlockingLine->sidedef[1] != NULL)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = WATER_JUMP_SPEED;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// If the blocked move executed any push specials that changed the
// actor's velocity, do not attempt to slide.
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (mo->Vel.XY() == startvel)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (player && (i_compatflags & COMPATF_WALLRUN))
{
// [RH] Here is the key to wall running: The move is clipped using its full speed.
// If the move is done a second time (because it was too fast for one move), it
// is still clipped against the wall at its full speed, so you effectively
// execute two moves in one tic.
- floatified P_TryMove and the sliding and bouncing code.
2016-03-27 11:29:58 +00:00
P_SlideMove (mo, mo->Vel, 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
P_SlideMove (mo, onestep, totalsteps);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (mo->Vel.XY().isZero())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
steps = 0;
}
else
{
if (!player || !(i_compatflags & COMPATF_WALLRUN))
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
move = mo->Vel;
onestep = move / steps;
P_CheckSlopeWalk (mo, move);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
start = mo->Pos().XY() - move * step / steps;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
steps = 0;
}
}
else
{ // slide against another actor
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DVector2 t;
t.X = 0, t.Y = onestep.Y;
walkplane = P_CheckSlopeWalk (mo, t);
if (P_TryMove (mo, mo->Pos() + t, true, walkplane, tm))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
t.X = onestep.X, t.Y = 0;
walkplane = P_CheckSlopeWalk (mo, t);
if (P_TryMove (mo, mo->Pos() + t, true, walkplane, tm))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = mo->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
if (player && player->mo == mo)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (mo->Vel.X == 0)
player->Vel.X = 0;
if (mo->Vel.Y == 0)
player->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
steps = 0;
}
}
else if (mo->flags & MF_MISSILE)
{
steps = 0;
if (BlockingMobj)
{
if (mo->BounceFlags & BOUNCE_Actors)
{
// Bounce test and code moved to P_BounceActor
if (!P_BounceActor(mo, BlockingMobj, false))
{ // Struck a player/creature
P_ExplodeMissile (mo, NULL, BlockingMobj);
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
// Struck a wall
if (P_BounceWall (mo))
{
mo->PlayBounceSound(false);
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
if (BlockingMobj && (BlockingMobj->flags2 & MF2_REFLECTIVE))
{
bool seeker = (mo->flags2 & MF2_SEEKERMISSILE) ? true : false;
// Don't change the angle if there's THRUREFLECT on the monster.
if (!(BlockingMobj->flags7 & MF7_THRUREFLECT))
{
- renamed some functions and fixed a few more conversion errors.
2016-03-16 23:07:37 +00:00
DAngle angle = BlockingMobj->AngleTo(mo);
Normalize line endings
2016-03-01 15:47:10 +00:00
bool dontReflect = (mo->AdjustReflectionAngle(BlockingMobj, angle));
// Change angle for deflection/reflection
if (!dontReflect)
{
bool tg = (mo->target != NULL);
bool blockingtg = (BlockingMobj->target != NULL);
if ((BlockingMobj->flags7 & MF7_AIMREFLECT) && (tg | blockingtg))
{
AActor *origin = tg ? mo->target : BlockingMobj->target;
//dest->x - source->x
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
DVector3 vect = mo->Vec3To(origin);
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
vect.Z += origin->Height / 2;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel = vect.Resized(mo->Speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
if ((BlockingMobj->flags7 & MF7_MIRRORREFLECT) && (tg | blockingtg))
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
mo->Angles.Yaw += 180.;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel *= -.5;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
mo->Angles.Yaw = angle;
mo->VelFromAngle(mo->Speed / 2);
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z *= -.5;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
else
{
goto explode;
}
}
if (mo->flags2 & MF2_SEEKERMISSILE)
{
mo->tracer = mo->target;
}
mo->target = BlockingMobj;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
explode:
// explode a missile
if (!(mo->flags3 & MF3_SKYEXPLODE))
{
if (tm.ceilingline &&
tm.ceilingline->backsector &&
tm.ceilingline->backsector->GetTexture(sector_t::ceiling) == skyflatnum &&
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
mo->Z() >= tm.ceilingline->backsector->ceilingplane.ZatPoint(mo->PosRelative(tm.ceilingline)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// Hack to prevent missiles exploding against the sky.
// Does not handle sky floors.
mo->Destroy ();
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// [RH] Don't explode on horizon lines.
if (mo->BlockingLine != NULL && mo->BlockingLine->special == Line_Horizon)
{
mo->Destroy ();
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
P_ExplodeMissile (mo, mo->BlockingLine, BlockingMobj);
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = mo->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
steps = 0;
}
}
else
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
if (mo->Pos().XY() != ptry)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// If the new position does not match the desired position, the player
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
// must have gone through a teleporter or portal.
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (mo->Vel.X == 0 && mo->Vel.Y == 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
// Stop moving right now if it was a regular teleporter.
Normalize line endings
2016-03-01 15:47:10 +00:00
step = steps;
}
else
{
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
// It was a portal, line-to-line or fogless teleporter, so the move should continue.
// For that we need to adjust the start point, and the movement vector.
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
DAngle anglediff = deltaangle(oldangle, mo->Angles.Yaw);
- fixed: When passing through a teleporter or portal that alters the angle, it is not sufficient that P_XYMovement adjusts the position in case a second P_TryMove call is needed, it must also change the precalculated movement vector.
2016-03-09 11:49:49 +00:00
if (anglediff != 0)
{
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
move = move.Rotated(anglediff);
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
oldangle = mo->Angles.Yaw;
- fixed: When passing through a teleporter or portal that alters the angle, it is not sufficient that P_XYMovement adjusts the position in case a second P_TryMove call is needed, it must also change the precalculated movement vector.
2016-03-09 11:49:49 +00:00
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
start = mo->Pos() - move * step / steps;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
} while (++step <= steps);
// Friction
if (player && player->mo == mo && player->cheats & CF_NOVELOCITY)
{ // debug option for no sliding at all
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = mo->Vel.Y = 0;
player->Vel.X = player->Vel.Y = 0;
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (mo->flags & (MF_MISSILE | MF_SKULLFLY))
{ // no friction for missiles
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->Z() > mo->floorz && !(mo->flags2 & MF2_ONMOBJ) &&
Normalize line endings
2016-03-01 15:47:10 +00:00
!mo->IsNoClip2() &&
(!(mo->flags2 & MF2_FLY) || !(mo->flags & MF_NOGRAVITY)) &&
!mo->waterlevel)
{ // [RH] Friction when falling is available for larger aircontrols
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (player != NULL && level.airfriction != 1.)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X *= level.airfriction;
mo->Vel.Y *= level.airfriction;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (player->mo == mo) // Not voodoo dolls
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
player->Vel.X *= level.airfriction;
player->Vel.Y *= level.airfriction;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// killough 8/11/98: add bouncers
// killough 9/15/98: add objects falling off ledges
// killough 11/98: only include bouncers hanging off ledges
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
if ((mo->flags & MF_CORPSE) || (mo->BounceFlags & BOUNCE_MBF && mo->Z() > mo->dropoffz) || (mo->flags6 & MF6_FALLING))
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Don't stop sliding if halfway off a step with some velocity
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
if (fabs(mo->Vel.X) > 0.25 || fabs(mo->Vel.Y) > 0.25)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (mo->floorz > mo->Sector->floorplane.ZatPoint(mo))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
if (mo->dropoffz != mo->floorz) // 3DMidtex or other special cases that must be excluded
Normalize line endings
2016-03-01 15:47:10 +00:00
{
unsigned i;
for(i=0;i<mo->Sector->e->XFloor.ffloors.Size();i++)
{
// Sliding around on 3D floors looks extremely bad so
// if the floor comes from one in the current sector stop sliding the corpse!
F3DFloor * rover=mo->Sector->e->XFloor.ffloors[i];
if (!(rover->flags&FF_EXISTS)) continue;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (rover->flags&FF_SOLID && rover->top.plane->ZatPoint(mo) == mo->floorz) break;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (i==mo->Sector->e->XFloor.ffloors.Size())
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
}
// killough 11/98:
// Stop voodoo dolls that have come to rest, despite any
// moving corresponding player:
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (fabs(mo->Vel.X) < STOPSPEED && fabs(mo->Vel.Y) < STOPSPEED
Normalize line endings
2016-03-01 15:47:10 +00:00
&& (!player || (player->mo != mo)
|| !(player->cmd.ucmd.forwardmove | player->cmd.ucmd.sidemove)))
{
// if in a walking frame, stop moving
// killough 10/98:
// Don't affect main player when voodoo dolls stop:
if (player && player->mo == mo && !(player->cheats & CF_PREDICTING))
{
player->mo->PlayIdle ();
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = mo->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->flags4 &= ~MF4_SCROLLMOVE;
// killough 10/98: kill any bobbing velocity too (except in voodoo dolls)
if (player && player->mo == mo)
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
player->Vel.X = player->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
// phares 3/17/98
// Friction will have been adjusted by friction thinkers for icy
// or muddy floors. Otherwise it was never touched and
// remained set at ORIG_FRICTION
//
// killough 8/28/98: removed inefficient thinker algorithm,
// instead using touching_sectorlist in P_GetFriction() to
// determine friction (and thus only when it is needed).
//
// killough 10/98: changed to work with new bobbing method.
// Reducing player velocity is no longer needed to reduce
// bobbing, so ice works much better now.
- floatified friction.
2016-03-24 21:50:03 +00:00
double friction = P_GetFriction (mo, NULL);
Normalize line endings
2016-03-01 15:47:10 +00:00
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X *= friction;
mo->Vel.Y *= friction;
Normalize line endings
2016-03-01 15:47:10 +00:00
// killough 10/98: Always decrease player bobbing by ORIG_FRICTION.
// This prevents problems with bobbing on ice, where it was not being
// reduced fast enough, leading to all sorts of kludges being developed.
if (player && player->mo == mo) // Not voodoo dolls
{
- floatified friction.
2016-03-24 21:50:03 +00:00
player->Vel.X *= ORIG_FRICTION;
player->Vel.Y *= ORIG_FRICTION;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
}
// Don't let the velocity become less than the smallest representable fixed point value.
if (fabs(mo->Vel.X) < MinVel) mo->Vel.X = 0;
if (fabs(mo->Vel.Y) < MinVel) mo->Vel.Y = 0;
if (player && player->mo == mo) // Not voodoo dolls
{
if (fabs(player->Vel.X) < MinVel) player->Vel.X = 0;
if (fabs(player->Vel.Y) < MinVel) player->Vel.Y = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
-floatified P_ExplodeMissile and P_XYMovement
2016-03-27 22:55:57 +00:00
return Oldfloorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// Move this to p_inter ***
void P_MonsterFallingDamage (AActor *mo)
{
int damage;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double vel;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!(level.flags2 & LEVEL2_MONSTERFALLINGDAMAGE))
return;
if (mo->floorsector->Flags & SECF_NOFALLINGDAMAGE)
return;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
vel = fabs(mo->Vel.Z);
if (vel > 35)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // automatic death
damage = TELEFRAG_DAMAGE;
}
else
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
damage = int((vel - 23)*6);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
damage = TELEFRAG_DAMAGE; // always kill 'em
P_DamageMobj (mo, NULL, NULL, damage, NAME_Falling);
}
//
// P_ZMovement
//
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
void P_ZMovement (AActor *mo, double oldfloorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double dist;
double delta;
double oldz = mo->Z();
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double grav = mo->GetGravity();
Normalize line endings
2016-03-01 15:47:10 +00:00
//
// check for smooth step up
//
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->player && mo->player->mo == mo && mo->Z() < mo->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
mo->player->viewheight -= mo->floorz - mo->Z();
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->player->deltaviewheight = mo->player->GetDeltaViewHeight();
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->AddZ(mo->Vel.Z);
Normalize line endings
2016-03-01 15:47:10 +00:00
//
// apply gravity
//
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->Z() > mo->floorz && !(mo->flags & MF_NOGRAVITY))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double startvelz = mo->Vel.Z;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->waterlevel == 0 || (mo->player &&
!(mo->player->cmd.ucmd.forwardmove | mo->player->cmd.ucmd.sidemove)))
{
// [RH] Double gravity only if running off a ledge. Coming down from
// an upward thrust (e.g. a jump) should not double it.
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (mo->Vel.Z == 0 && oldfloorz > mo->floorz && mo->Z() == oldfloorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z -= grav + grav;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z -= grav;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
if (mo->player == NULL)
{
if (mo->waterlevel >= 1)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double sinkspeed;
Normalize line endings
2016-03-01 15:47:10 +00:00
if ((mo->flags & MF_SPECIAL) && !(mo->flags3 & MF3_ISMONSTER))
{ // Pickup items don't sink if placed and drop slowly if dropped
sinkspeed = (mo->flags & MF_DROPPED) ? -WATER_SINK_SPEED / 8 : 0;
}
else
{
sinkspeed = -WATER_SINK_SPEED;
// If it's not a player, scale sinkspeed by its mass, with
// 100 being equivalent to a player.
if (mo->player == NULL)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
sinkspeed = sinkspeed * clamp(mo->Mass, 1, 4000) / 100;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (mo->Vel.Z < sinkspeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Dropping too fast, so slow down toward sinkspeed.
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z -= MAX(sinkspeed*2, -8.);
if (mo->Vel.Z > sinkspeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = sinkspeed;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
else if (mo->Vel.Z > sinkspeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Dropping too slow/going up, so trend toward sinkspeed.
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = startvelz + MAX(sinkspeed/3, -8.);
if (mo->Vel.Z < sinkspeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = sinkspeed;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
}
else
{
if (mo->waterlevel > 1)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double sinkspeed = -WATER_SINK_SPEED;
Normalize line endings
2016-03-01 15:47:10 +00:00
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (mo->Vel.Z < sinkspeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = (startvelz < sinkspeed) ? startvelz : sinkspeed;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = startvelz + ((mo->Vel.Z - startvelz) *
Normalize line endings
2016-03-01 15:47:10 +00:00
(mo->waterlevel == 1 ? WATER_SINK_SMALL_FACTOR : WATER_SINK_FACTOR));
}
}
}
}
// Hexen compatibility handling for floatbobbing. Ugh...
// Hexen yanked all items to the floor, except those being spawned at map start in the air.
// Those were kept at their original height.
// Do this only if the item was actually spawned by the map above ground to avoid problems.
- added two floating point special variables, because the two existing ones are integers and unusable for storing doubles.
2016-03-20 20:51:09 +00:00
if (mo->specialf1 > 0 && (mo->flags2 & MF2_FLOATBOB) && (ib_compatflags & BCOMPATF_FLOATBOB))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added two floating point special variables, because the two existing ones are integers and unusable for storing doubles.
2016-03-20 20:51:09 +00:00
mo->SetZ(mo->floorz + mo->specialf1);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//
// adjust height
//
if ((mo->flags & MF_FLOAT) && !(mo->flags2 & MF2_DORMANT) && mo->target)
{ // float down towards target if too close
if (!(mo->flags & (MF_SKULLFLY | MF_INFLOAT)))
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
dist = mo->Distance2D (mo->target);
delta = (mo->target->Center()) - mo->Z();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (delta < 0 && dist < -(delta*3))
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
mo->AddZ(-mo->FloatSpeed);
Normalize line endings
2016-03-01 15:47:10 +00:00
else if (delta > 0 && dist < (delta*3))
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
mo->AddZ(mo->FloatSpeed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->player && (mo->flags & MF_NOGRAVITY) && (mo->Z() > mo->floorz))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (!mo->IsNoClip2())
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
mo->AddZ(DAngle(360 / 80.f * level.maptime).Sin() / 8);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified friction.
2016-03-24 21:50:03 +00:00
mo->Vel.Z *= FRICTION_FLY;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (mo->waterlevel && !(mo->flags & MF_NOGRAVITY))
{
- floatified friction.
2016-03-24 21:50:03 +00:00
double friction = -1;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
// Check 3D floors -- might be the source of the waterlevel
for (auto rover : mo->Sector->e->XFloor.ffloors)
{
if (!(rover->flags & FF_EXISTS)) continue;
if (!(rover->flags & FF_SWIMMABLE)) continue;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (mo->Z() >= rover->top.plane->ZatPoint(mo) ||
mo->Center() < rover->bottom.plane->ZatPoint(mo))
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
continue;
friction = rover->model->GetFriction(rover->top.isceiling);
break;
}
- floatified friction.
2016-03-24 21:50:03 +00:00
if (friction < 0)
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
friction = mo->Sector->GetFriction(); // get real friction, even if from a terrain definition
- floatified friction.
2016-03-24 21:50:03 +00:00
mo->Vel.Z *= friction;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//
// clip movement
//
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->Z() <= mo->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Hit the floor
if ((!mo->player || !(mo->player->cheats & CF_PREDICTING)) &&
mo->Sector->SecActTarget != NULL &&
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
mo->Sector->floorplane.ZatPoint(mo) == mo->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // [RH] Let the sector do something to the actor
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
mo->Sector->TriggerSectorActions (mo, SECSPAC_HitFloor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed coordinate correctness issues with P_CheckFor3DFloor/CeilingHit.
2016-04-20 11:17:52 +00:00
P_CheckFor3DFloorHit(mo, mo->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Need to recheck this because the sector action might have
// teleported the actor so it is no longer below the floor.
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->Z() <= mo->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if ((mo->flags & MF_MISSILE) && !(mo->flags & MF_NOCLIP))
{
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
mo->SetZ(mo->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->BounceFlags & BOUNCE_Floors)
{
mo->FloorBounceMissile (mo->floorsector->floorplane);
/* if (!(mo->flags6 & MF6_CANJUMP)) */ return;
}
else if (mo->flags3 & MF3_NOEXPLODEFLOOR)
{
P_HitFloor (mo);
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
return;
}
else if (mo->flags3 & MF3_FLOORHUGGER)
{ // Floor huggers can go up steps
return;
}
else
{
if (mo->floorpic == skyflatnum && !(mo->flags3 & MF3_SKYEXPLODE))
{
// [RH] Just remove the missile without exploding it
// if this is a sky floor.
mo->Destroy ();
return;
}
P_HitFloor (mo);
P_ExplodeMissile (mo, NULL, NULL);
return;
}
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
else if (mo->BounceFlags & BOUNCE_MBF && mo->Vel.Z) // check for MBF-like bounce on non-missiles
Normalize line endings
2016-03-01 15:47:10 +00:00
{
mo->FloorBounceMissile(mo->floorsector->floorplane);
}
if (mo->flags3 & MF3_ISMONSTER) // Blasted mobj falling
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (mo->Vel.Z < -23)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
P_MonsterFallingDamage (mo);
}
}
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
mo->SetZ(mo->floorz);
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (mo->Vel.Z < 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
const double minvel = -8; // landing speed from a jump with normal gravity
Normalize line endings
2016-03-01 15:47:10 +00:00
// Spawn splashes, etc.
P_HitFloor (mo);
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (mo->DamageType == NAME_Ice && mo->Vel.Z < minvel)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
mo->tics = 1;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Zero();
Normalize line endings
2016-03-01 15:47:10 +00:00
return;
}
// Let the actor do something special for hitting the floor
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
if (mo->flags7 & MF7_SMASHABLE)
{
P_DamageMobj(mo, nullptr, nullptr, mo->health, NAME_Smash);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->player)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (mo->player->jumpTics < 0 || mo->Vel.Z < minvel)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // delay any jumping for a short while
mo->player->jumpTics = 7;
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (mo->Vel.Z < minvel && !(mo->flags & MF_NOGRAVITY))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// Squat down.
// Decrease viewheight for a moment after hitting the ground (hard),
// and utter appropriate sound.
PlayerLandedOnThing (mo, NULL);
}
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (mo->flags & MF_SKULLFLY)
{ // The skull slammed into something
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = -mo->Vel.Z;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
mo->Crash();
}
}
if (mo->flags2 & MF2_FLOORCLIP)
{
mo->AdjustFloorClip ();
}
- replaced ceilingz with a floating point variable, also in FCheckPosition.
2016-03-20 12:32:53 +00:00
if (mo->Top() > mo->ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // hit the ceiling
if ((!mo->player || !(mo->player->cheats & CF_PREDICTING)) &&
mo->Sector->SecActTarget != NULL &&
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
mo->Sector->ceilingplane.ZatPoint(mo) == mo->ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // [RH] Let the sector do something to the actor
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
mo->Sector->TriggerSectorActions (mo, SECSPAC_HitCeiling);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- fixed coordinate correctness issues with P_CheckFor3DFloor/CeilingHit.
2016-04-20 11:17:52 +00:00
P_CheckFor3DCeilingHit(mo, mo->ceilingz);
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Need to recheck this because the sector action might have
// teleported the actor so it is no longer above the ceiling.
- replaced ceilingz with a floating point variable, also in FCheckPosition.
2016-03-20 12:32:53 +00:00
if (mo->Top() > mo->ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
mo->SetZ(mo->ceilingz - mo->Height);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->BounceFlags & BOUNCE_Ceilings)
{ // ceiling bounce
mo->FloorBounceMissile (mo->ceilingsector->ceilingplane);
/*if (!(mo->flags6 & MF6_CANJUMP))*/ return;
}
if (mo->flags & MF_SKULLFLY)
{ // the skull slammed into something
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = -mo->Vel.Z;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (mo->Vel.Z > 0)
mo->Vel.Z = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
if ((mo->flags & MF_MISSILE) && !(mo->flags & MF_NOCLIP))
{
if (mo->flags3 & MF3_CEILINGHUGGER)
{
return;
}
if (mo->ceilingpic == skyflatnum && !(mo->flags3 & MF3_SKYEXPLODE))
{
mo->Destroy ();
return;
}
P_ExplodeMissile (mo, NULL, NULL);
return;
}
}
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
P_CheckFakeFloorTriggers (mo, oldz);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified P_ChangeSector.
2016-03-27 20:35:58 +00:00
void P_CheckFakeFloorTriggers (AActor *mo, double oldz, bool oldz_has_viewheight)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (mo->player && (mo->player->cheats & CF_PREDICTING))
{
return;
}
sector_t *sec = mo->Sector;
assert (sec != NULL);
if (sec == NULL)
{
return;
}
if (sec->heightsec != NULL && sec->SecActTarget != NULL)
{
sector_t *hs = sec->heightsec;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
double waterz = hs->floorplane.ZatPoint(mo);
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
double newz;
double viewheight;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->player != NULL)
{
viewheight = mo->player->viewheight;
}
else
{
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
viewheight = mo->Height;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if (oldz > waterz && mo->Z() <= waterz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Feet hit fake floor
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
sec->TriggerSectorActions (mo, SECSPAC_HitFakeFloor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
newz = mo->Z() + viewheight;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!oldz_has_viewheight)
{
oldz += viewheight;
}
if (oldz <= waterz && newz > waterz)
{ // View went above fake floor
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
sec->TriggerSectorActions (mo, SECSPAC_EyesSurface);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (oldz > waterz && newz <= waterz)
{ // View went below fake floor
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
sec->TriggerSectorActions (mo, SECSPAC_EyesDive);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (!(hs->MoreFlags & SECF_FAKEFLOORONLY))
{
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
waterz = hs->ceilingplane.ZatPoint(mo);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (oldz <= waterz && newz > waterz)
{ // View went above fake ceiling
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
sec->TriggerSectorActions (mo, SECSPAC_EyesAboveC);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (oldz > waterz && newz <= waterz)
{ // View went below fake ceiling
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
sec->TriggerSectorActions (mo, SECSPAC_EyesBelowC);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
}
//===========================================================================
//
// PlayerLandedOnThing
//
//===========================================================================
static void PlayerLandedOnThing (AActor *mo, AActor *onmobj)
{
bool grunted;
if (!mo->player)
return;
if (mo->player->mo == mo)
{
- converted g_strife to full floating point use, except the floor height changing stuff in A_LightGoesOut.
2016-03-22 11:42:27 +00:00
mo->player->deltaviewheight = mo->Vel.Z / 8.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (mo->player->cheats & CF_PREDICTING)
return;
P_FallingDamage (mo);
// [RH] only make noise if alive
if (!mo->player->morphTics && mo->health > 0)
{
grunted = false;
// Why should this number vary by gravity?
- floatified the remaining fixed point variables accessible through DECORATE. PROP_FIXED_PARAM is no longer used anywhere.
2016-03-24 22:50:29 +00:00
if (mo->health > 0 && mo->Vel.Z < -mo->player->mo->GruntSpeed)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
S_Sound (mo, CHAN_VOICE, "*grunt", 1, ATTN_NORM);
grunted = true;
}
if (onmobj != NULL || !Terrains[P_GetThingFloorType (mo)].IsLiquid)
{
if (!grunted || !S_AreSoundsEquivalent (mo, "*grunt", "*land"))
{
S_Sound (mo, CHAN_AUTO, "*land", 1, ATTN_NORM);
}
}
}
// mo->player->centering = true;
}
//
// P_NightmareRespawn
//
void P_NightmareRespawn (AActor *mobj)
{
- floatified some stuff in g_shared. Note: This commit does not handle z-spawn positions correctly.
2016-03-22 23:53:09 +00:00
double z;
Normalize line endings
2016-03-01 15:47:10 +00:00
AActor *mo;
AActor *info = mobj->GetDefault();
mobj->skillrespawncount++;
// spawn the new monster (assume the spawn will be good)
if (info->flags & MF_SPAWNCEILING)
z = ONCEILINGZ;
else if (info->flags2 & MF2_SPAWNFLOAT)
z = FLOATRANDZ;
else
z = ONFLOORZ;
// spawn it
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
mo = AActor::StaticSpawn(mobj->GetClass(), DVector3(mobj->SpawnPoint.X, mobj->SpawnPoint.Y, z), NO_REPLACE, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (z == ONFLOORZ)
{
- floatified some stuff in g_shared. Note: This commit does not handle z-spawn positions correctly.
2016-03-22 23:53:09 +00:00
mo->AddZ(mobj->SpawnPoint.Z);
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->Z() < mo->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Do not respawn monsters in the floor, even if that's where they
// started. The initial P_ZMovement() call would have put them on
// the floor right away, but we need them on the floor now so we
// can use P_CheckPosition() properly.
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
mo->SetZ(mo->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- replaced ceilingz with a floating point variable, also in FCheckPosition.
2016-03-20 12:32:53 +00:00
if (mo->Top() > mo->ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
mo->SetZ(mo->ceilingz- mo->Height);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else if (z == ONCEILINGZ)
{
- floatified some stuff in g_shared. Note: This commit does not handle z-spawn positions correctly.
2016-03-22 23:53:09 +00:00
mo->AddZ(-mobj->SpawnPoint.Z);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// If there are 3D floors, we need to find floor/ceiling again.
P_FindFloorCeiling(mo, FFCF_SAMESECTOR | FFCF_ONLY3DFLOORS | FFCF_3DRESTRICT);
if (z == ONFLOORZ)
{
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (mo->Z() < mo->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Do not respawn monsters in the floor, even if that's where they
// started. The initial P_ZMovement() call would have put them on
// the floor right away, but we need them on the floor now so we
// can use P_CheckPosition() properly.
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
mo->SetZ(mo->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- replaced ceilingz with a floating point variable, also in FCheckPosition.
2016-03-20 12:32:53 +00:00
if (mo->Top() > mo->ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Do the same for the ceiling.
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
mo->SetZ(mo->ceilingz - mo->Height);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
// something is occupying its position?
- floatified some stuff in g_shared. Note: This commit does not handle z-spawn positions correctly.
2016-03-22 23:53:09 +00:00
if (!P_CheckPosition(mo, mo->Pos(), true))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
//[GrafZahl] MF_COUNTKILL still needs to be checked here.
mo->ClearCounters();
mo->Destroy ();
return; // no respawn
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
z = mo->Z();
Normalize line endings
2016-03-01 15:47:10 +00:00
// inherit attributes from deceased one
- floatified some stuff in g_shared. Note: This commit does not handle z-spawn positions correctly.
2016-03-22 23:53:09 +00:00
mo->SpawnPoint = mobj->SpawnPoint;
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->SpawnAngle = mobj->SpawnAngle;
mo->SpawnFlags = mobj->SpawnFlags & ~MTF_DORMANT; // It wasn't dormant when it died, so it's not dormant now, either.
- several fixes.
2016-03-16 21:29:35 +00:00
mo->Angles.Yaw = (double)mobj->SpawnAngle;
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->HandleSpawnFlags ();
mo->reactiontime = 18;
mo->CopyFriendliness (mobj, false);
mo->Translation = mobj->Translation;
mo->skillrespawncount = mobj->skillrespawncount;
- floatified AActor::Prev plus the stuff using it. - rewrote some coordinate functions in AActor to use real float math instead of converting back and forth between float and fixed.
2016-03-25 15:25:25 +00:00
mo->Prev.Z = z; // Do not interpolate Z position if we changed it since spawning.
Normalize line endings
2016-03-01 15:47:10 +00:00
// spawn a teleport fog at old spot because of removal of the body?
- fixed some issues with teleport fog: * many calls didn't use TELEFOGHEIGHT, mostly those coming from external code submissions that never were tested on anything but Doom. Addressed by adding this value inside P_SpawnTeleportFog and making the distinction between projectiles and non-projectiles from P_Teleport also part of this function. * there were still a few places which spawned the teleport fog directly, skipping all the added features of P_SpawnTeleportFog.
2016-06-06 08:48:40 +00:00
P_SpawnTeleportFog(mobj, mobj->Pos(), true, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
// spawn a teleport fog at the new spot
- fixed some issues with teleport fog: * many calls didn't use TELEFOGHEIGHT, mostly those coming from external code submissions that never were tested on anything but Doom. Addressed by adding this value inside P_SpawnTeleportFog and making the distinction between projectiles and non-projectiles from P_Teleport also part of this function. * there were still a few places which spawned the teleport fog directly, skipping all the added features of P_SpawnTeleportFog.
2016-06-06 08:48:40 +00:00
P_SpawnTeleportFog(mobj, DVector3(mobj->SpawnPoint, z), false, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
// remove the old monster
mobj->Destroy ();
}
AActor *AActor::TIDHash[128];
//
// P_ClearTidHashes
//
// Clears the tid hashtable.
//
void AActor::ClearTIDHashes ()
{
memset(TIDHash, 0, sizeof(TIDHash));
}
//
// P_AddMobjToHash
//
// Inserts an mobj into the correct chain based on its tid.
// If its tid is 0, this function does nothing.
//
void AActor::AddToHash ()
{
if (tid == 0)
{
iprev = NULL;
inext = NULL;
return;
}
else
{
int hash = TIDHASH (tid);
inext = TIDHash[hash];
iprev = &TIDHash[hash];
TIDHash[hash] = this;
if (inext)
{
inext->iprev = &inext;
}
}
}
//
// P_RemoveMobjFromHash
//
// Removes an mobj from its hash chain.
//
void AActor::RemoveFromHash ()
{
if (tid != 0 && iprev)
{
*iprev = inext;
if (inext)
{
inext->iprev = iprev;
}
iprev = NULL;
inext = NULL;
}
tid = 0;
}
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
DEFINE_ACTION_FUNCTION(AActor, RemoveFromHash)
{
PARAM_SELF_PROLOGUE(AActor);
self->RemoveFromHash();
return 0;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, ChangeTid)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(tid);
self->RemoveFromHash();
self->tid = tid;
self->AddToHash();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// P_IsTIDUsed
//
// Returns true if there is at least one actor with the specified TID
// (dead or alive).
//
//==========================================================================
bool P_IsTIDUsed(int tid)
{
AActor *probe = AActor::TIDHash[tid & 127];
while (probe != NULL)
{
if (probe->tid == tid)
{
return true;
}
probe = probe->inext;
}
return false;
}
//==========================================================================
//
// P_FindUniqueTID
//
// Returns an unused TID. If start_tid is 0, then a random TID will be
// chosen. Otherwise, it will perform a linear search starting from
// start_tid. If limit is non-0, then it will not check more than <limit>
// number of TIDs. Returns 0 if no suitable TID was found.
//
//==========================================================================
int P_FindUniqueTID(int start_tid, int limit)
{
int tid;
if (start_tid != 0)
{ // Do a linear search.
if (start_tid > INT_MAX-limit+1)
{ // If 'limit+start_tid-1' overflows, clamp 'limit' to INT_MAX
limit = INT_MAX;
}
else
{
limit += start_tid-1;
}
for (tid = start_tid; tid <= limit; ++tid)
{
if (tid != 0 && !P_IsTIDUsed(tid))
{
return tid;
}
}
// Nothing free found.
return 0;
}
// Do a random search. To try and be a bit more performant, this
// actually does several linear searches. In the case of *very*
// dense TID usage, this could potentially perform worse than doing
// a complete linear scan starting at 1. However, you would need
// to use an absolutely ridiculous number of actors before this
// becomes a real concern.
if (limit == 0)
{
limit = INT_MAX;
}
for (int i = 0; i < limit; i += 5)
{
// Use a positive starting TID.
tid = pr_uniquetid.GenRand32() & INT_MAX;
tid = P_FindUniqueTID(tid == 0 ? 1 : tid, 5);
if (tid != 0)
{
return tid;
}
}
// Nothing free found.
return 0;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, FindUniqueTid)
{
PARAM_PROLOGUE;
PARAM_INT_DEF(start);
PARAM_INT_DEF(limit);
ACTION_RETURN_INT(P_FindUniqueTID(start, limit));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
CCMD(utid)
{
Printf("%d\n",
P_FindUniqueTID(argv.argc() > 1 ? atoi(argv[1]) : 0,
(argv.argc() > 2 && atoi(argv[2]) >= 0) ? atoi(argv[2]) : 0));
}
//==========================================================================
//
// AActor :: GetMissileDamage
//
// If the actor's damage amount is an expression, evaluate it and return
// the result. Otherwise, return ((random() & mask) + add) * damage.
//
//==========================================================================
int AActor::GetMissileDamage (int mask, int add)
{
- split Damage into two variables: DamageVal for the old constant and DamageFunc for the DECORATE function. The way this was done was a major headache inducer, requiring reconstruction of the function each time the value was changed and in general made actor damage a major hassle. There was a DECORATE wrapper to mimic the original behavior but this looked quite broken because it completely ignored the different semantics of both damage calculation types. It also made it impossible to determine if damage was a function or a value. This accessor has been reverted to what it should be, only returning the constant, which now is -1 for a damage function. I am sorry if this may break the odd mod out but a quick look over some DECORATE-heavy stuff showed that this was never combined in any of them so that accessing 'damage' in DECORATE code depended on an actual damage function. To get proper damage, a future commit will add a DECORATE function which calls AActor::GetMissileDamage.
2016-09-19 01:36:51 +00:00
if (DamageVal >= 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- split Damage into two variables: DamageVal for the old constant and DamageFunc for the DECORATE function. The way this was done was a major headache inducer, requiring reconstruction of the function each time the value was changed and in general made actor damage a major hassle. There was a DECORATE wrapper to mimic the original behavior but this looked quite broken because it completely ignored the different semantics of both damage calculation types. It also made it impossible to determine if damage was a function or a value. This accessor has been reverted to what it should be, only returning the constant, which now is -1 for a damage function. I am sorry if this may break the odd mod out but a quick look over some DECORATE-heavy stuff showed that this was never combined in any of them so that accessing 'damage' in DECORATE code depended on an actual damage function. To get proper damage, a future commit will add a DECORATE function which calls AActor::GetMissileDamage.
2016-09-19 01:36:51 +00:00
if (mask == 0)
{
return add * DamageVal;
}
else
{
return ((pr_missiledamage() & mask) + add) * DamageVal;
}
}
if (DamageFunc == nullptr)
{
// This should never happen
assert(false && "No damage function found");
Normalize line endings
2016-03-01 15:47:10 +00:00
return 0;
}
VMValue param = this;
- removed the second 'calculated' return value from the damage function call in GetMissileDamage as it is no longer needed or even code being generated for.
2016-11-06 09:28:01 +00:00
VMReturn result;
Normalize line endings
2016-03-01 15:47:10 +00:00
- removed the second 'calculated' return value from the damage function call in GetMissileDamage as it is no longer needed or even code being generated for.
2016-11-06 09:28:01 +00:00
int amount;
Normalize line endings
2016-03-01 15:47:10 +00:00
- removed the second 'calculated' return value from the damage function call in GetMissileDamage as it is no longer needed or even code being generated for.
2016-11-06 09:28:01 +00:00
result.IntAt(&amount);
Normalize line endings
2016-03-01 15:47:10 +00:00
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
if (GlobalVMStack.Call(DamageFunc, &param, 1, &result, 1) < 1)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // No results
return 0;
}
- split Damage into two variables: DamageVal for the old constant and DamageFunc for the DECORATE function. The way this was done was a major headache inducer, requiring reconstruction of the function each time the value was changed and in general made actor damage a major hassle. There was a DECORATE wrapper to mimic the original behavior but this looked quite broken because it completely ignored the different semantics of both damage calculation types. It also made it impossible to determine if damage was a function or a value. This accessor has been reverted to what it should be, only returning the constant, which now is -1 for a damage function. I am sorry if this may break the odd mod out but a quick look over some DECORATE-heavy stuff showed that this was never combined in any of them so that accessing 'damage' in DECORATE code depended on an actual damage function. To get proper damage, a future commit will add a DECORATE function which calls AActor::GetMissileDamage.
2016-09-19 01:36:51 +00:00
return amount;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
void AActor::Howl ()
{
FSoundID howl = GetClass()->HowlSound;
if (!S_IsActorPlayingSomething(this, CHAN_BODY, howl))
{
S_Sound (this, CHAN_BODY, howl, 1, ATTN_NORM);
}
}
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
DEFINE_ACTION_FUNCTION(AActor, Howl)
{
PARAM_SELF_PROLOGUE(AActor);
self->Howl();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
bool AActor::Slam (AActor *thing)
{
flags &= ~MF_SKULLFLY;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel.Zero();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (health > 0)
{
if (!(flags2 & MF2_DORMANT))
{
int dam = GetMissileDamage (7, 1);
int newdam = P_DamageMobj (thing, this, this, dam, NAME_Melee);
P_TraceBleed (newdam > 0 ? newdam : dam, thing, this);
// The charging monster may have died by the target's actions here.
if (health > 0)
{
if (SeeState != NULL) SetState (SeeState);
else SetIdle();
}
}
else
{
SetIdle();
tics = -1;
}
}
return false; // stop moving
}
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, Slam)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(thing, AActor);
ACTION_RETURN_BOOL(self->Slam(thing));
}
bool AActor::CallSlam(AActor *thing)
{
IFVIRTUAL(AActor, Slam)
{
VMValue params[2] = { (DObject*)this, thing };
VMReturn ret;
int retval;
ret.IntAt(&retval);
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 2, &ret, 1, nullptr);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
return !!retval;
}
else return Slam(thing);
}
- scriptified Hexen's Frost shards. - scriptified all SpecialMissileHit methods.
2016-11-27 20:41:04 +00:00
// This virtual method only exists on the script side.
Normalize line endings
2016-03-01 15:47:10 +00:00
int AActor::SpecialMissileHit (AActor *victim)
{
- scriptified Hexen's Frost shards. - scriptified all SpecialMissileHit methods.
2016-11-27 20:41:04 +00:00
IFVIRTUAL(AActor, SpecialMissileHit)
{
VMValue params[2] = { (DObject*)this, victim };
VMReturn ret;
int retval;
ret.IntAt(&retval);
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 2, &ret, 1, nullptr);
- scriptified Hexen's Frost shards. - scriptified all SpecialMissileHit methods.
2016-11-27 20:41:04 +00:00
return retval;
}
else return -1;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
bool AActor::AdjustReflectionAngle (AActor *thing, DAngle &angle)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (flags2 & MF2_DONTREFLECT) return true;
if (thing->flags7 & MF7_THRUREFLECT) return false;
// Change angle for reflection
if (thing->flags4&MF4_SHIELDREFLECT)
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
// Shield reflection (from the Centaur)
- g_hexen almost done except for 3 things that require more extensive changes.
2016-03-21 21:20:10 +00:00
if (absangle(angle, thing->Angles.Yaw) > 45)
Normalize line endings
2016-03-01 15:47:10 +00:00
return true; // Let missile explode
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
if (thing->flags7 & MF7_NOSHIELDREFLECT) return true;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (pr_reflect () < 128)
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
angle += 45;
Normalize line endings
2016-03-01 15:47:10 +00:00
else
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
angle -= 45;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (thing->flags4&MF4_DEFLECT)
{
// deflect (like the Heresiarch)
if(pr_reflect() < 128)
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
angle += 45;
Normalize line endings
2016-03-01 15:47:10 +00:00
else
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
angle -= 45;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
angle += ((pr_reflect() % 16) - 8);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//Always check for AIMREFLECT, no matter what else is checked above.
if (thing->flags7 & MF7_AIMREFLECT)
{
if (this->target != NULL)
{
A_Face(this, this->target);
}
else if (thing->target != NULL)
{
A_Face(this, thing->target);
}
}
return false;
}
- made AbsorbDamage work iteratively to avoid large stack use in the VM.
2017-01-16 00:16:11 +00:00
int AActor::AbsorbDamage(int damage, FName dmgtype)
{
for (AInventory *item = Inventory; item != nullptr; item = item->Inventory)
{
IFVIRTUALPTR(item, AInventory, AbsorbDamage)
{
- fixed compilation.
2017-01-16 09:23:26 +00:00
VMValue params[4] = { item, damage, dmgtype.GetIndex(), &damage };
- made AbsorbDamage work iteratively to avoid large stack use in the VM.
2017-01-16 00:16:11 +00:00
GlobalVMStack.Call(func, params, 4, nullptr, 0, nullptr);
}
}
return damage;
}
- scriptified APowerInvisibility. - changed AlterWeaponSprite so that it doesn't expose renderer internals to the script code.
2017-01-16 19:33:41 +00:00
void AActor::AlterWeaponSprite(visstyle_t *vis)
{
int changed = 0;
TArray<AInventory *> items;
// This needs to go backwards through the items but the list has no backlinks.
for (AInventory *item = Inventory; item != nullptr; item = item->Inventory)
{
items.Push(item);
}
for(int i=items.Size()-1;i>=0;i--)
{
IFVIRTUALPTR(items[i], AInventory, AlterWeaponSprite)
{
VMValue params[3] = { items[i], vis, &changed };
GlobalVMStack.Call(func, params, 3, nullptr, 0, nullptr);
}
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::PlayActiveSound ()
{
if (ActiveSound && !S_IsActorPlayingSomething (this, CHAN_VOICE, -1))
{
S_Sound (this, CHAN_VOICE, ActiveSound, 1,
(flags3 & MF3_FULLVOLACTIVE) ? ATTN_NONE : ATTN_IDLE);
}
}
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, PlayActiveSound)
{
PARAM_SELF_PROLOGUE(AActor);
self->PlayActiveSound();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
bool AActor::IsOkayToAttack (AActor *link)
{
if (!(player // Original AActor::IsOkayToAttack was only for players
// || (flags & MF_FRIENDLY) // Maybe let friendly monsters use the function as well?
|| (flags5 & MF5_SUMMONEDMONSTER) // AMinotaurFriend has its own version, generalized to other summoned monsters
|| (flags2 & MF2_SEEKERMISSILE))) // AHolySpirit and AMageStaffFX2 as well, generalized to other seeker missiles
{ // Normal monsters and other actors always return false.
return false;
}
// Standard things to eliminate: an actor shouldn't attack itself,
// or a non-shootable, dormant, non-player-and-non-monster actor.
if (link == this) return false;
if (!(link->player||(link->flags3 & MF3_ISMONSTER)))return false;
if (!(link->flags & MF_SHOOTABLE)) return false;
if (link->flags2 & MF2_DORMANT) return false;
// An actor shouldn't attack friendly actors. The reference depends
// on the type of actor: for a player's actor, itself; for a projectile,
// its target; and for a summoned minion, its tracer.
AActor * Friend = NULL;
if (player) Friend = this;
else if (flags5 & MF5_SUMMONEDMONSTER) Friend = tracer;
else if (flags2 & MF2_SEEKERMISSILE) Friend = target;
else if ((flags & MF_FRIENDLY) && FriendPlayer) Friend = players[FriendPlayer-1].mo;
// Friend checks
if (link == Friend) return false;
if (Friend == NULL) return false;
if (Friend->IsFriend(link)) return false;
if ((link->flags5 & MF5_SUMMONEDMONSTER) // No attack against minions on the same side
&& (link->tracer == Friend)) return false;
if (multiplayer && !deathmatch // No attack against fellow players in coop
&& link->player && Friend->player) return false;
if (((flags & link->flags) & MF_FRIENDLY) // No friendly infighting amongst minions
&& IsFriend(link)) return false;
// Now that all the actor checks are made, the line of sight can be checked
if (P_CheckSight (this, link))
{
// AMageStaffFX2::IsOkayToAttack had an extra check here, generalized with a flag,
// to only allow the check to succeed if the enemy was in a ~84<38> FOV of the player
if (flags3 & MF3_SCREENSEEKER)
{
- floatification of bot code.
2016-03-25 23:34:56 +00:00
DAngle angle = absangle(Friend->AngleTo(link), Friend->Angles.Yaw);
if (angle < 30 * (256./360.))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return true;
}
}
// Other actors are not concerned by this check
else return true;
}
// The sight check was failed, or the angle wasn't right for a screenseeker
return false;
}
void AActor::SetShade (DWORD rgb)
{
PalEntry *entry = (PalEntry *)&rgb;
fillcolor = rgb | (ColorMatcher.Pick (entry->r, entry->g, entry->b) << 24);
}
void AActor::SetShade (int r, int g, int b)
{
fillcolor = MAKEARGB(ColorMatcher.Pick (r, g, b), r, g, b);
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetShade)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(color);
self->SetShade(color);
return 0;
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
void AActor::SetPitch(DAngle p, bool interpolate, bool forceclamp)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (player != NULL || forceclamp)
{ // clamp the pitch we set
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
DAngle min, max;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (player != NULL)
{
min = player->MinPitch;
max = player->MaxPitch;
}
else
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
min = -89.;
max = 89.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
p = clamp(p, min, max);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
if (p != Angles.Pitch)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
Angles.Pitch = p;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (player != NULL && interpolate)
{
player->cheats |= CF_INTERPVIEW;
}
}
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
void AActor::SetAngle(DAngle ang, bool interpolate)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
if (ang != Angles.Yaw)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
Angles.Yaw = ang;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (player != NULL && interpolate)
{
player->cheats |= CF_INTERPVIEW;
}
}
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
void AActor::SetRoll(DAngle r, bool interpolate)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
if (r != Angles.Roll)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
Angles.Roll = r;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (player != NULL && interpolate)
{
player->cheats |= CF_INTERPVIEW;
}
}
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
DVector3 AActor::GetPortalTransition(double byoffset, sector_t **pSec)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
bool moved = false;
sector_t *sec = Sector;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double testz = Z() + byoffset;
DVector3 pos = Pos();
Normalize line endings
2016-03-01 15:47:10 +00:00
while (!sec->PortalBlocksMovement(sector_t::ceiling))
{
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
if (testz >= sec->GetPortalPlaneZ(sector_t::ceiling))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- wrap access to portal properties into sector_t:: member functions.
2016-04-19 09:35:28 +00:00
pos = PosRelative(sec->GetOppositePortalGroup(sector_t::ceiling));
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
sec = P_PointInSector(pos);
Normalize line endings
2016-03-01 15:47:10 +00:00
moved = true;
}
else break;
}
if (!moved)
{
while (!sec->PortalBlocksMovement(sector_t::floor))
{
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
if (testz < sec->GetPortalPlaneZ(sector_t::floor))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- wrap access to portal properties into sector_t:: member functions.
2016-04-19 09:35:28 +00:00
pos = PosRelative(sec->GetOppositePortalGroup(sector_t::floor));
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
sec = P_PointInSector(pos);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else break;
}
}
- some redesign of P_CheckSight to handle portals. Portal stuff not tested yet.
2016-03-07 20:58:34 +00:00
if (pSec) *pSec = sec;
Normalize line endings
2016-03-01 15:47:10 +00:00
return pos;
}
void AActor::CheckPortalTransition(bool islinked)
{
bool moved = false;
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
FLinkContext ctx;
Normalize line endings
2016-03-01 15:47:10 +00:00
while (!Sector->PortalBlocksMovement(sector_t::ceiling))
{
- fixed: It was not possible to step through a ceiling portal into the upper sector.
2016-05-20 11:10:42 +00:00
if (Z() >= Sector->GetPortalPlaneZ(sector_t::ceiling))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified AActor::Prev plus the stuff using it. - rewrote some coordinate functions in AActor to use real float math instead of converting back and forth between float and fixed.
2016-03-25 15:25:25 +00:00
DVector3 oldpos = Pos();
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
if (islinked && !moved) UnlinkFromWorld(&ctx);
- wrap access to portal properties into sector_t:: member functions.
2016-04-19 09:35:28 +00:00
SetXYZ(PosRelative(Sector->GetOppositePortalGroup(sector_t::ceiling)));
- floatified AActor::Prev plus the stuff using it. - rewrote some coordinate functions in AActor to use real float math instead of converting back and forth between float and fixed.
2016-03-25 15:25:25 +00:00
Prev = Pos() - oldpos;
Sector = P_PointInSector(Pos());
Normalize line endings
2016-03-01 15:47:10 +00:00
PrevPortalGroup = Sector->PortalGroup;
moved = true;
}
else break;
}
if (!moved)
{
while (!Sector->PortalBlocksMovement(sector_t::floor))
{
- wrap access to portal properties into sector_t:: member functions.
2016-04-19 09:35:28 +00:00
double portalz = Sector->GetPortalPlaneZ(sector_t::floor);
if (Z() < portalz && floorz < portalz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified AActor::Prev plus the stuff using it. - rewrote some coordinate functions in AActor to use real float math instead of converting back and forth between float and fixed.
2016-03-25 15:25:25 +00:00
DVector3 oldpos = Pos();
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
if (islinked && !moved) UnlinkFromWorld(&ctx);
- wrap access to portal properties into sector_t:: member functions.
2016-04-19 09:35:28 +00:00
SetXYZ(PosRelative(Sector->GetOppositePortalGroup(sector_t::floor)));
- floatified AActor::Prev plus the stuff using it. - rewrote some coordinate functions in AActor to use real float math instead of converting back and forth between float and fixed.
2016-03-25 15:25:25 +00:00
Prev = Pos() - oldpos;
Sector = P_PointInSector(Pos());
Normalize line endings
2016-03-01 15:47:10 +00:00
PrevPortalGroup = Sector->PortalGroup;
moved = true;
}
else break;
}
}
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
if (islinked && moved) LinkToWorld(&ctx);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//
// P_MobjThinker
//
void AActor::Tick ()
{
// [RH] Data for Heretic/Hexen scrolling sectors
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
static const SBYTE HexenCompatSpeeds[] = {-25, 0, -10, -5, 0, 5, 10, 0, 25 };
Normalize line endings
2016-03-01 15:47:10 +00:00
static const SBYTE HexenScrollies[24][2] =
{
{ 0, 1 }, { 0, 2 }, { 0, 4 },
{ -1, 0 }, { -2, 0 }, { -4, 0 },
{ 0, -1 }, { 0, -2 }, { 0, -4 },
{ 1, 0 }, { 2, 0 }, { 4, 0 },
{ 1, 1 }, { 2, 2 }, { 4, 4 },
{ -1, 1 }, { -2, 2 }, { -4, 4 },
{ -1, -1 }, { -2, -2 }, { -4, -4 },
{ 1, -1 }, { 2, -2 }, { 4, -4 }
};
static const BYTE HereticScrollDirs[4] = { 6, 9, 1, 4 };
static const BYTE HereticSpeedMuls[5] = { 5, 10, 25, 30, 35 };
AActor *onmo;
//assert (state != NULL);
if (state == NULL)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Printf("Actor of type %s at (%f,%f) left without a state\n", GetClass()->TypeName.GetChars(), X(), Y());
Normalize line endings
2016-03-01 15:47:10 +00:00
Destroy();
return;
}
// This is necessary to properly interpolate movement outside this function
// like from an ActorMover
ClearInterpolation();
if (flags5 & MF5_NOINTERACTION)
{
// only do the minimally necessary things here to save time:
// Check the time freezer
// apply velocity
// ensure that the actor is not linked into the blockmap
if (!(flags5 & MF5_NOTIMEFREEZE))
{
//Added by MC: Freeze mode.
if (bglobal.freeze || level.flags2 & LEVEL2_FROZEN)
{
// Boss cubes shouldn't be accelerated by timefreeze
if (flags6 & MF6_BOSSCUBE)
{
special2++;
}
return;
}
}
Fixed: Actors with NOINTERACTION shouldn't waste time continuously applying NOBLOCKMAP if it has it already and not moving.
2016-11-15 17:38:03 +00:00
if (!Vel.isZero() || !(flags & MF_NOBLOCKMAP))
{
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
FLinkContext ctx;
UnlinkFromWorld(&ctx);
Fixed: Actors with NOINTERACTION shouldn't waste time continuously applying NOBLOCKMAP if it has it already and not moving.
2016-11-15 17:38:03 +00:00
flags |= MF_NOBLOCKMAP;
SetXYZ(Vec3Offset(Vel));
CheckPortalTransition(false);
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
LinkToWorld(&ctx);
Fixed: Actors with NOINTERACTION shouldn't waste time continuously applying NOBLOCKMAP if it has it already and not moving.
2016-11-15 17:38:03 +00:00
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
AInventory * item = Inventory;
// Handle powerup effects here so that the order is controlled
// by the order in the inventory, not the order in the thinker table
while (item != NULL && item->Owner == this)
{
- more exporting of AInventory.
2017-01-19 19:56:31 +00:00
IFVIRTUALPTR(item, AInventory, DoEffect)
{
VMValue params[1] = { item };
GlobalVMStack.Call(func, params, 1, nullptr, 0, nullptr);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
item = item->Inventory;
}
if (flags & MF_UNMORPHED)
{
return;
}
if (!(flags5 & MF5_NOTIMEFREEZE))
{
// Boss cubes shouldn't be accelerated by timefreeze
if (flags6 & MF6_BOSSCUBE)
{
special2++;
}
//Added by MC: Freeze mode.
if (bglobal.freeze && !(player && player->Bot == NULL))
{
return;
}
// Apply freeze mode.
if ((level.flags2 & LEVEL2_FROZEN) && (player == NULL || player->timefreezer == 0))
{
return;
}
}
if (effects & FX_ROCKET)
{
if (++smokecounter == 4)
{
// add some smoke behind the rocket
smokecounter = 0;
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
AActor *th = Spawn("RocketSmokeTrail", Vec3Offset(-Vel), ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (th)
{
th->tics -= pr_rockettrail()&3;
if (th->tics < 1) th->tics = 1;
if (!(cl_rockettrails & 2)) th->renderflags |= RF_INVISIBLE;
}
}
}
else if (effects & FX_GRENADE)
{
if (++smokecounter == 8)
{
smokecounter = 0;
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
DAngle moveangle = Vel.Angle();
double xo = -moveangle.Cos() * radius * 2 + pr_rockettrail() / 64.;
double yo = -moveangle.Sin() * radius * 2 + pr_rockettrail() / 64.;
double zo = -Height * Vel.Z / 8. + Height * (2 / 3.);
AActor * th = Spawn("GrenadeSmokeTrail", Vec3Offset(xo, yo, zo), ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (th)
{
th->tics -= pr_rockettrail()&3;
if (th->tics < 1) th->tics = 1;
if (!(cl_rockettrails & 2)) th->renderflags |= RF_INVISIBLE;
}
}
}
- looks like the oldz parameter in UpdateWaterLevel is not needed at all...
2016-03-26 00:13:36 +00:00
double oldz = Z();
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Give the pain elemental vertical friction
// This used to be in APainElemental::Tick but in order to use
// A_PainAttack with other monsters it has to be here
if (flags4 & MF4_VFRICTION)
{
if (health >0)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (fabs (Vel.Z) < 0.25)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel.Z = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
flags4 &= ~MF4_VFRICTION;
}
else
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel.Z *= (0xe800 / 65536.);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
// [RH] Pulse in and out of visibility
if (effects & FX_VISIBILITYPULSE)
{
if (visdir > 0)
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha += 1/32.;
if (Alpha >= 1.)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha = 1.;
Normalize line endings
2016-03-01 15:47:10 +00:00
visdir = -1;
}
}
else
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha -= 1/32.;
if (Alpha <= 0.25)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha = 0.25;
Normalize line endings
2016-03-01 15:47:10 +00:00
visdir = 1;
}
}
}
else if (flags & MF_STEALTH)
{
// [RH] Fade a stealth monster in and out of visibility
RenderStyle.Flags &= ~STYLEF_Alpha1;
if (visdir > 0)
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha += 2./TICRATE;
if (Alpha > 1.)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha = 1.;
Normalize line endings
2016-03-01 15:47:10 +00:00
visdir = 0;
}
}
else if (visdir < 0)
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha -= 1.5/TICRATE;
if (Alpha < 0)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
visdir = 0;
}
}
}
if (bglobal.botnum && !demoplayback &&
((flags & (MF_SPECIAL|MF_MISSILE)) || (flags3 & MF3_ISMONSTER)))
{
- moved the bot support code from AActor::Tick to a subfunction in the bot sources. No need to pollute a main game file with this stuff.
2016-03-26 00:30:28 +00:00
bglobal.BotTick(this);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// [RH] Consider carrying sectors here
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
DVector2 cumm(0, 0);
- added polyobject serializer. - added sanity checks to prevent a savegame from being loaded with an incompatible map - refactored a few things to simplify serialization. - started work on main level serializer function.
2016-09-20 07:11:13 +00:00
if ((level.Scrolls.Size() != 0 || player != NULL) && !(flags & MF_NOCLIP) && !(flags & MF_NOSECTOR))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double height, waterheight; // killough 4/4/98: add waterheight
Normalize line endings
2016-03-01 15:47:10 +00:00
const msecnode_t *node;
int countx, county;
// killough 3/7/98: Carry things on floor
// killough 3/20/98: use new sector list which reflects true members
// killough 3/27/98: fix carrier bug
// killough 4/4/98: Underwater, carry things even w/o gravity
// Move objects only if on floor or underwater,
// non-floating, and clipped.
countx = county = 0;
for (node = touching_sectorlist; node; node = node->m_tnext)
{
sector_t *sec = node->m_sector;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
DVector2 scrollv;
Normalize line endings
2016-03-01 15:47:10 +00:00
- moved all 'sectorptr - &level.sectors[0]' constructs into a subfunction.
2017-01-07 19:02:25 +00:00
if (level.Scrolls.Size() > unsigned(sec->Index()))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- moved all 'sectorptr - &level.sectors[0]' constructs into a subfunction.
2017-01-07 19:02:25 +00:00
scrollv = level.Scrolls[sec->Index()];
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
scrollv.Zero();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (player != NULL)
{
int scrolltype = sec->special;
if (scrolltype >= Scroll_North_Slow &&
scrolltype <= Scroll_SouthWest_Fast)
{ // Hexen scroll special
scrolltype -= Scroll_North_Slow;
if (i_compatflags&COMPATF_RAVENSCROLL)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
scrollv.X -= HexenCompatSpeeds[HexenScrollies[scrolltype][0]+4] * (1. / (32 * CARRYFACTOR));
scrollv.Y += HexenCompatSpeeds[HexenScrollies[scrolltype][1]+4] * (1. / (32 * CARRYFACTOR));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
// Use speeds that actually match the scrolling textures!
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
scrollv.X -= HexenScrollies[scrolltype][0] * 0.5;
scrollv.Y += HexenScrollies[scrolltype][1] * 0.5;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else if (scrolltype >= Carry_East5 &&
scrolltype <= Carry_West35)
{ // Heretic scroll special
scrolltype -= Carry_East5;
BYTE dir = HereticScrollDirs[scrolltype / 5];
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double carryspeed = HereticSpeedMuls[scrolltype % 5] * (1. / (32 * CARRYFACTOR));
- fixed scroll speed calculation for Heretic.
2016-05-24 08:01:57 +00:00
if (scrolltype < 5 && !(i_compatflags&COMPATF_RAVENSCROLL))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// Use speeds that actually match the scrolling textures!
- fixed scroll speed calculation for Heretic.
2016-05-24 08:01:57 +00:00
carryspeed = (1 << ((scrolltype % 5) + 15)) / 65536.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
scrollv.X += carryspeed * ((dir & 3) - 1);
scrollv.Y += carryspeed * (((dir & 12) >> 2) - 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (scrolltype == dScroll_EastLavaDamage)
{ // Special Heretic scroll special
if (i_compatflags&COMPATF_RAVENSCROLL)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
scrollv.X += 28. / (32*CARRYFACTOR);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
// Use a speed that actually matches the scrolling texture!
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
scrollv.X += 12. / (32 * CARRYFACTOR);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else if (scrolltype == Scroll_StrifeCurrent)
{ // Strife scroll special
int anglespeed = tagManager.GetFirstSectorTag(sec) - 100;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double carryspeed = (anglespeed % 10) / (16 * CARRYFACTOR);
DAngle angle = ((anglespeed / 10) * 45.);
scrollv += angle.ToVector(carryspeed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (scrollv.isZero())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
continue;
}
sector_t *heightsec = sec->GetHeightSec();
if (flags & MF_NOGRAVITY && heightsec == NULL)
{
continue;
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
DVector3 pos = PosRelative(sec);
Normalize line endings
2016-03-01 15:47:10 +00:00
height = sec->floorplane.ZatPoint (pos);
- floatified p_scroll.cpp While testing this it became clear that with the higher precision of doubles it has to be avoided at all costs to compare an actor's z position with a value retrieved from ZatPoint to check if it is standing on a floor. There can be some minor variations, depending on what was done with this value. Added isAbove, isBelow and isAtZ checking methods to AActor which properly deal with the problem.
2016-03-28 19:04:46 +00:00
double height2 = sec->floorplane.ZatPoint(this);
if (isAbove(height))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (heightsec == NULL)
{
continue;
}
waterheight = heightsec->floorplane.ZatPoint (pos);
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (waterheight > height && Z() >= waterheight)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
continue;
}
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
cumm += scrollv;
if (scrollv.X) countx++;
if (scrollv.Y) county++;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// Some levels designed with Boom in mind actually want things to accelerate
// at neighboring scrolling sector boundaries. But it is only important for
// non-player objects.
if (player != NULL || !(i_compatflags & COMPATF_BOOMSCROLL))
{
if (countx > 1)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
cumm.X /= countx;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (county > 1)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
cumm.Y /= county;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
// [RH] If standing on a steep slope, fall down it
if ((flags & MF_SOLID) && !(flags & (MF_NOCLIP|MF_NOGRAVITY)) &&
!(flags & MF_NOBLOCKMAP) &&
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
Vel.Z <= 0 &&
floorz == Z())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
secplane_t floorplane;
// Check 3D floors as well
- floatification of p_3dfloors, p_3dmidtex and p_acs.cpp plus some leftovers. - removed all references to Doom specific headers from xs_Float.h and cmath.h.
2016-03-26 11:36:15 +00:00
floorplane = P_FindFloorPlane(floorsector, PosAtZ(floorz));
Normalize line endings
2016-03-01 15:47:10 +00:00
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (floorplane.fC() < STEEPSLOPE &&
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
floorplane.ZatPoint (PosRelative(floorsector)) <= floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
const msecnode_t *node;
bool dopush = true;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (floorplane.fC() > STEEPSLOPE*2/3)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
for (node = touching_sectorlist; node; node = node->m_tnext)
{
const sector_t *sec = node->m_sector;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (sec->floorplane.fC() >= STEEPSLOPE)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- looks like the oldz parameter in UpdateWaterLevel is not needed at all...
2016-03-26 00:13:36 +00:00
if (floorplane.ZatPoint(PosRelative(node->m_sector)) >= Z() - MaxStepHeight)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
dopush = false;
break;
}
}
}
}
if (dopush)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel += floorplane.Normal().XY();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
// [RH] Missiles moving perfectly vertical need some X/Y movement, or they
// won't hurt anything. Don't do this if damage is 0! That way, you can
// still have missiles that go straight up and down through actors without
// damaging anything.
// (for backwards compatibility this must check for lack of damage function, not for zero damage!)
- split Damage into two variables: DamageVal for the old constant and DamageFunc for the DECORATE function. The way this was done was a major headache inducer, requiring reconstruction of the function each time the value was changed and in general made actor damage a major hassle. There was a DECORATE wrapper to mimic the original behavior but this looked quite broken because it completely ignored the different semantics of both damage calculation types. It also made it impossible to determine if damage was a function or a value. This accessor has been reverted to what it should be, only returning the constant, which now is -1 for a damage function. I am sorry if this may break the odd mod out but a quick look over some DECORATE-heavy stuff showed that this was never combined in any of them so that accessing 'damage' in DECORATE code depended on an actual damage function. To get proper damage, a future commit will add a DECORATE function which calls AActor::GetMissileDamage.
2016-09-19 01:36:51 +00:00
if ((flags & MF_MISSILE) && Vel.X == 0 && Vel.Y == 0 && !IsZeroDamage())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel.X = MinVel;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// Handle X and Y velocities
BlockingMobj = NULL;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
double oldfloorz = P_XYMovement (this, cumm);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (ObjectFlags & OF_EuthanizeMe)
{ // actor was destroyed
return;
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
if (Vel.X == 0 && Vel.Y == 0) // Actors at rest
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (flags2 & MF2_BLASTED)
{ // Reset to not blasted when velocities are gone
flags2 &= ~MF2_BLASTED;
}
if ((flags6 & MF6_TOUCHY) && !IsSentient())
{ // Arm a mine which has come to rest
flags6 |= MF6_ARMED;
}
}
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (Vel.Z != 0 || BlockingMobj || Z() != floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Handle Z velocity and gravity
if (((flags2 & MF2_PASSMOBJ) || (flags & MF_SPECIAL)) && !(i_compatflags & COMPATF_NO_PASSMOBJ))
{
if (!(onmo = P_CheckOnmobj (this)))
{
P_ZMovement (this, oldfloorz);
flags2 &= ~MF2_ONMOBJ;
}
else
{
if (player)
{
- made AActor::gravity and FMapThing::gravity floats.
2016-03-20 23:51:19 +00:00
if (Vel.Z < level.gravity * Sector->gravity * (-1./100)// -655.36f)
Normalize line endings
2016-03-01 15:47:10 +00:00
&& !(flags&MF_NOGRAVITY))
{
PlayerLandedOnThing (this, onmo);
}
}
- converted g_strife to full floating point use, except the floor height changing stuff in A_LightGoesOut.
2016-03-22 11:42:27 +00:00
if (onmo->Top() - Z() <= MaxStepHeight)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (player && player->mo == this)
{
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
player->viewheight -= onmo->Top() - Z();
- converted g_strife to full floating point use, except the floor height changing stuff in A_LightGoesOut.
2016-03-22 11:42:27 +00:00
double deltaview = player->GetDeltaViewHeight();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (deltaview > player->deltaviewheight)
{
player->deltaviewheight = deltaview;
}
}
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
SetZ(onmo->Top());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// Check for MF6_BUMPSPECIAL
// By default, only players can activate things by bumping into them
// We trigger specials as long as we are on top of it and not just when
// we land on it. This could be considered as gravity making us continually
// bump into it, but it also avoids having to worry about walking on to
// something without dropping and not triggering anything.
if ((onmo->flags6 & MF6_BUMPSPECIAL) && ((player != NULL)
|| ((onmo->activationtype & THINGSPEC_MonsterTrigger) && (flags3 & MF3_ISMONSTER))
|| ((onmo->activationtype & THINGSPEC_MissileTrigger) && (flags & MF_MISSILE))
) && (level.maptime > onmo->lastbump)) // Leave the bumper enough time to go away
{
if (player == NULL || !(player->cheats & CF_PREDICTING))
{
if (P_ActivateThingSpecial(onmo, this))
onmo->lastbump = level.maptime + TICRATE;
}
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (Vel.Z != 0 && (BounceFlags & BOUNCE_Actors))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
P_BounceActor(this, onmo, true);
}
else
{
flags2 |= MF2_ONMOBJ;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
Vel.Z = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
Crash();
}
}
}
else
{
P_ZMovement (this, oldfloorz);
}
if (ObjectFlags & OF_EuthanizeMe)
return; // actor was destroyed
}
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
else if (Z() <= floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
Crash();
Fixed: Possible invalid processing for Crash states that immediately destroy the actor - Setting an actor's Crash state has the potential to destroy the actor if the Crash state has one or more 0-tic states that end with Stop. This was not taken into account when the object's Z velocity was 0, but it was under the floor anyway.
2016-10-16 02:14:34 +00:00
if (ObjectFlags & OF_EuthanizeMe)
return; // actor was destroyed
Normalize line endings
2016-03-01 15:47:10 +00:00
}
CheckPortalTransition(true);
- looks like the oldz parameter in UpdateWaterLevel is not needed at all...
2016-03-26 00:13:36 +00:00
UpdateWaterLevel ();
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Don't advance if predicting a player
if (player && (player->cheats & CF_PREDICTING))
{
return;
}
// Check for poison damage, but only once per PoisonPeriod tics (or once per second if none).
if (PoisonDurationReceived && (level.time % (PoisonPeriodReceived ? PoisonPeriodReceived : TICRATE) == 0))
{
P_DamageMobj(this, NULL, Poisoner, PoisonDamageReceived, PoisonDamageTypeReceived ? PoisonDamageTypeReceived : (FName)NAME_Poison, 0);
--PoisonDurationReceived;
// Must clear damage when duration is done, otherwise it
// could be added to with ADDITIVEPOISONDAMAGE.
if (!PoisonDurationReceived) PoisonDamageReceived = 0;
}
}
assert (state != NULL);
if (state == NULL)
{
Destroy();
return;
}
if (!CheckNoDelay())
return; // freed itself
// cycle through states, calling action functions at transitions
- added a new sector list to AActor that collects all portal-linked sectors the actor's center is in. (Inspired by Eternity's solution to the same problem.) This is for rendering the sprite properly in all areas the actor touches. The original thinglist is not sufficient for this and Boom's touching thinglist has other purposes and collects too much data. This new list will only get filled in when the actor is actually crossing a portal plane, for the normal sector thinglist will still be used. This piggybacks on the msecnode_t code which has been extended to be able to handle more than one list by passing the sector's membert pointers as parameters.
2016-04-17 21:48:04 +00:00
UpdateRenderSectorList();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (tics != -1)
{
// [RH] Use tics <= 0 instead of == 0 so that spawnstates
// of 0 tics work as expected.
if (--tics <= 0)
{
if (!SetState(state->GetNextState()))
return; // freed itself
}
}
else
{
int respawn_monsters = G_SkillProperty(SKILLP_Respawn);
// check for nightmare respawn
if (!(flags5 & MF5_ALWAYSRESPAWN))
{
if (!respawn_monsters || !(flags3 & MF3_ISMONSTER) || (flags2 & MF2_DORMANT) || (flags5 & MF5_NEVERRESPAWN))
return;
int limit = G_SkillProperty (SKILLP_RespawnLimit);
if (limit > 0 && skillrespawncount >= limit)
return;
}
movecount++;
if (movecount < respawn_monsters)
return;
if (level.time & 31)
return;
if (pr_nightmarerespawn() > 4)
return;
P_NightmareRespawn (this);
}
}
- added scriptable virtual overrides for PostBeginPlay, Tick, BeginPlay, Activate and Deactivate.
2016-11-21 13:59:17 +00:00
DEFINE_ACTION_FUNCTION(AActor, Tick)
{
PARAM_SELF_PROLOGUE(AActor);
self->Tick();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor :: CheckNoDelay
//
//==========================================================================
bool AActor::CheckNoDelay()
{
if ((flags7 & MF7_HANDLENODELAY) && !(flags2 & MF2_DORMANT))
{
flags7 &= ~MF7_HANDLENODELAY;
if (state->GetNoDelay())
{
// For immediately spawned objects with the NoDelay flag set for their
// Spawn state, explicitly call the current state's function.
FState *newstate;
- changed action function interface so that callers can be identified directly, instead of guessing it from looking at the parameters. With arbitrary PSP layers the old method was no longer safe because the layer ID was not available in the action function.
2016-06-16 14:11:00 +00:00
FStateParamInfo stp = { state, STATE_Actor, PSP_WEAPON };
if (state->CallAction(this, this, &stp, &newstate))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (ObjectFlags & OF_EuthanizeMe)
{
return false; // freed itself
}
if (newstate != NULL)
{
return SetState(newstate);
}
}
}
}
return true;
}
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
DEFINE_ACTION_FUNCTION(AActor, CheckNoDelay)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_BOOL(self->CheckNoDelay());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor :: CheckSectorTransition
//
// Fire off some sector triggers if the actor has changed sectors.
//
//==========================================================================
void AActor::CheckSectorTransition(sector_t *oldsec)
{
if (oldsec != Sector)
{
if (oldsec->SecActTarget != NULL)
{
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
oldsec->TriggerSectorActions(this, SECSPAC_Exit);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (Sector->SecActTarget != NULL)
{
int act = SECSPAC_Enter;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (Z() <= Sector->floorplane.ZatPoint(this))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
act |= SECSPAC_HitFloor;
}
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (Top() >= Sector->ceilingplane.ZatPoint(this))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
act |= SECSPAC_HitCeiling;
}
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (Sector->heightsec != NULL && Z() == Sector->heightsec->floorplane.ZatPoint(this))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
act |= SECSPAC_HitFakeFloor;
}
- fixed use of multiple sector actions in the same sector. The entire setup was quite broken with each item using its own activation result and the ones of the subsequent items in the list as the return value. This rendered the STANDSTILL check in the main function totally unpredictable because the value it depended on could come from any item in the list. Changed it so that the main dispatcher function is part of sector_t and does the stepping through the list iteratively instead of letting each item recursively call its successor and let this function decide for each item alone whether it should be removed. The broken setup also had the effect that any MusicChanger would trigger all following SecActEnter specials right on msp start.
2017-01-13 00:34:43 +00:00
Sector->TriggerSectorActions(this, act);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (Z() == floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed coordinate correctness issues with P_CheckFor3DFloor/CeilingHit.
2016-04-20 11:17:52 +00:00
P_CheckFor3DFloorHit(this, Z());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- replaced ceilingz with a floating point variable, also in FCheckPosition.
2016-03-20 12:32:53 +00:00
if (Top() == ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed coordinate correctness issues with P_CheckFor3DFloor/CeilingHit.
2016-04-20 11:17:52 +00:00
P_CheckFor3DCeilingHit(this, Top());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
//==========================================================================
//
// AActor::UpdateWaterLevel
//
// Returns true if actor should splash
//
//==========================================================================
- looks like the oldz parameter in UpdateWaterLevel is not needed at all...
2016-03-26 00:13:36 +00:00
bool AActor::UpdateWaterLevel (bool dosplash)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
BYTE lastwaterlevel = waterlevel;
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
double fh = -FLT_MAX;
Normalize line endings
2016-03-01 15:47:10 +00:00
bool reset=false;
waterlevel = 0;
if (Sector == NULL)
{
return false;
}
if (Sector->MoreFlags & SECF_UNDERWATER) // intentionally not SECF_UNDERWATERMASK
{
waterlevel = 3;
}
else
{
const sector_t *hsec = Sector->GetHeightSec();
if (hsec != NULL)
{
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
fh = hsec->floorplane.ZatPoint (this);
Normalize line endings
2016-03-01 15:47:10 +00:00
//if (hsec->MoreFlags & SECF_UNDERWATERMASK) // also check Boom-style non-swimmable sectors
{
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if (Z() < fh)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 1;
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if (Center() < fh)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 2;
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if ((player && Z() + player->viewheight <= fh) ||
(Top() <= fh))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 3;
}
}
}
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
else if (!(hsec->MoreFlags & SECF_FAKEFLOORONLY) && (Top() > hsec->ceilingplane.ZatPoint (this)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 3;
}
else
{
waterlevel = 0;
}
}
// even non-swimmable deep water must be checked here to do the splashes correctly
// But the water level must be reset when this function returns
if (!(hsec->MoreFlags&SECF_UNDERWATERMASK))
{
reset = true;
}
}
else
{
// Check 3D floors as well!
- looks like the oldz parameter in UpdateWaterLevel is not needed at all...
2016-03-26 00:13:36 +00:00
for(auto rover : Sector->e->XFloor.ffloors)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (!(rover->flags & FF_EXISTS)) continue;
- enable terrain splashes for non-solid non-swimmable 3D floors.
2017-01-29 17:46:35 +00:00
if (rover->flags & FF_SOLID) continue;
Normalize line endings
2016-03-01 15:47:10 +00:00
- enable terrain splashes for non-solid non-swimmable 3D floors.
2017-01-29 17:46:35 +00:00
reset = !(rover->flags & FF_SWIMMABLE);
if (reset && rover->alpha == 0) continue;
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
double ff_bottom=rover->bottom.plane->ZatPoint(this);
double ff_top=rover->top.plane->ZatPoint(this);
Normalize line endings
2016-03-01 15:47:10 +00:00
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if(ff_top <= Z() || ff_bottom > (Center())) continue;
Normalize line endings
2016-03-01 15:47:10 +00:00
fh=ff_top;
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if (Z() < fh)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 1;
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if (Center() < fh)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 2;
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
if ((player && Z() + player->viewheight <= fh) ||
(Top() <= fh))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
waterlevel = 3;
}
}
}
break;
}
}
}
// some additional checks to make deep sectors like Boom's splash without setting
// the water flags.
if (boomwaterlevel == 0 && waterlevel != 0 && dosplash)
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
P_HitWater(this, Sector, PosAtZ(fh), true);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
boomwaterlevel = waterlevel;
if (reset)
{
waterlevel = lastwaterlevel;
}
return false; // we did the splash ourselves
}
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
DEFINE_ACTION_FUNCTION(AActor, UpdateWaterLevel)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(splash);
ACTION_RETURN_BOOL(self->UpdateWaterLevel(splash));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// P_SpawnMobj
//
//==========================================================================
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
AActor *AActor::StaticSpawn (PClassActor *type, const DVector3 &pos, replace_t allowreplacement, bool SpawningMapThing)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (type == NULL)
{
I_Error ("Tried to spawn a class-less actor\n");
}
if (allowreplacement)
{
type = type->GetReplacement();
}
AActor *actor;
actor = static_cast<AActor *>(const_cast<PClassActor *>(type)->CreateNew ());
// Set default dialogue
actor->ConversationRoot = GetConversation(actor->GetClass()->TypeName);
if (actor->ConversationRoot != -1)
{
actor->Conversation = StrifeDialogues[actor->ConversationRoot];
}
else
{
actor->Conversation = NULL;
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
actor->SetXYZ(pos);
- added a new sector list to AActor that collects all portal-linked sectors the actor's center is in. (Inspired by Eternity's solution to the same problem.) This is for rendering the sprite properly in all areas the actor touches. The original thinglist is not sufficient for this and Boom's touching thinglist has other purposes and collects too much data. This new list will only get filled in when the actor is actually crossing a portal plane, for the normal sector thinglist will still be used. This piggybacks on the msecnode_t code which has been extended to be able to handle more than one list by passing the sector's membert pointers as parameters.
2016-04-17 21:48:04 +00:00
actor->OldRenderPos = { FLT_MAX, FLT_MAX, FLT_MAX };
Normalize line endings
2016-03-01 15:47:10 +00:00
actor->picnum.SetInvalid();
actor->health = actor->SpawnHealth();
// Actors with zero gravity need the NOGRAVITY flag set.
- made AActor::gravity and FMapThing::gravity floats.
2016-03-20 23:51:19 +00:00
if (actor->Gravity == 0) actor->flags |= MF_NOGRAVITY;
Normalize line endings
2016-03-01 15:47:10 +00:00
FRandom &rng = bglobal.m_Thinking ? pr_botspawnmobj : pr_spawnmobj;
if (actor->isFast() && actor->flags3 & MF3_ISMONSTER)
actor->reactiontime = 0;
if (actor->flags3 & MF3_ISMONSTER)
{
actor->LastLookPlayerNumber = rng() % MAXPLAYERS;
actor->TIDtoHate = 0;
}
// Set the state, but do not use SetState, because action
// routines can't be called yet. If the spawnstate has an action
// routine, it will not be called.
FState *st = actor->SpawnState;
actor->state = st;
actor->tics = st->GetTics();
actor->sprite = st->sprite;
actor->frame = st->GetFrame();
actor->renderflags = (actor->renderflags & ~RF_FULLBRIGHT) | ActorRenderFlags::FromInt (st->GetFullbright());
- use msecnode_t's for the touching_renderlists instead of std::forward_list. - preparations for checking the proper sector to get a sprite's lighting info.
2016-12-26 10:58:08 +00:00
actor->touching_sectorlist = nullptr; // NULL head of sector list // phares 3/13/98
actor->touching_rendersectors = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (G_SkillProperty(SKILLP_FastMonsters) && actor->GetClass()->FastSpeed >= 0)
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
actor->Speed = actor->GetClass()->FastSpeed;
Normalize line endings
2016-03-01 15:47:10 +00:00
// set subsector and/or block links
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
actor->LinkToWorld (nullptr, SpawningMapThing);
Normalize line endings
2016-03-01 15:47:10 +00:00
actor->ClearInterpolation();
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
actor->dropoffz = actor->floorz = actor->Sector->floorplane.ZatPoint(pos);
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
actor->ceilingz = actor->Sector->ceilingplane.ZatPoint(pos);
Normalize line endings
2016-03-01 15:47:10 +00:00
// The z-coordinate needs to be set once before calling P_FindFloorCeiling
// For FLOATRANDZ just use the floor here.
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
if (pos.Z == ONFLOORZ || pos.Z == FLOATRANDZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
actor->SetZ(actor->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
else if (pos.Z == ONCEILINGZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
actor->SetZ(actor->ceilingz - actor->Height);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (SpawningMapThing || !type->IsDescendantOf (RUNTIME_CLASS(APlayerPawn)))
{
// Check if there's something solid to stand on between the current position and the
// current sector's floor. For map spawns this must be delayed until after setting the
// z-coordinate.
if (!SpawningMapThing)
{
P_FindFloorCeiling(actor, FFCF_ONLYSPAWNPOS);
}
else
{
actor->floorsector = actor->Sector;
actor->floorpic = actor->floorsector->GetTexture(sector_t::floor);
actor->floorterrain = actor->floorsector->GetTerrain(sector_t::floor);
actor->ceilingsector = actor->Sector;
actor->ceilingpic = actor->ceilingsector->GetTexture(sector_t::ceiling);
}
}
else if (!(actor->flags5 & MF5_NOINTERACTION))
{
P_FindFloorCeiling (actor);
}
else
{
actor->floorpic = actor->Sector->GetTexture(sector_t::floor);
actor->floorterrain = actor->Sector->GetTerrain(sector_t::floor);
actor->floorsector = actor->Sector;
actor->ceilingpic = actor->Sector->GetTexture(sector_t::ceiling);
actor->ceilingsector = actor->Sector;
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
actor->SpawnPoint.X = pos.X;
actor->SpawnPoint.Y = pos.Y;
// do not copy Z!
Normalize line endings
2016-03-01 15:47:10 +00:00
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
if (pos.Z == ONFLOORZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
actor->SetZ(actor->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
else if (pos.Z == ONCEILINGZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
actor->SetZ(actor->ceilingz - actor->Height);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
else if (pos.Z == FLOATRANDZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
double space = actor->ceilingz - actor->Height - actor->floorz;
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (space > 48)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
space -= 40;
actor->SetZ( space * rng() / 256. + actor->floorz + 40);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
actor->SetZ(actor->floorz);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
else
{
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
actor->SpawnPoint.Z = (actor->Z() - actor->Sector->floorplane.ZatPoint(actor));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (actor->FloatBobPhase == (BYTE)-1) actor->FloatBobPhase = rng(); // Don't make everything bob in sync (unless deliberately told to do)
if (actor->flags2 & MF2_FLOORCLIP)
{
actor->AdjustFloorClip ();
}
else
{
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
actor->Floorclip = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- looks like the oldz parameter in UpdateWaterLevel is not needed at all...
2016-03-26 00:13:36 +00:00
actor->UpdateWaterLevel (false);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!SpawningMapThing)
{
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
actor->CallBeginPlay ();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (actor->ObjectFlags & OF_EuthanizeMe)
{
return NULL;
}
}
if (level.flags & LEVEL_NOALLIES && !actor->player)
{
actor->flags &= ~MF_FRIENDLY;
}
// [RH] Count monsters whenever they are spawned.
if (actor->CountsAsKill())
{
level.total_monsters++;
}
// [RH] Same, for items
if (actor->flags & MF_COUNTITEM)
{
level.total_items++;
}
// And for secrets
if (actor->flags5 & MF5_COUNTSECRET)
{
level.total_secrets++;
}
return actor;
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
DEFINE_ACTION_FUNCTION(AActor, Spawn)
{
PARAM_PROLOGUE;
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_CLASS_NOT_NULL(type, AActor);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
PARAM_FLOAT_DEF(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT_DEF(z);
PARAM_INT_DEF(flags);
ACTION_RETURN_OBJECT(AActor::StaticSpawn(type, DVector3(x, y, z), replace_t(flags)));
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
PClassActor *ClassForSpawn(FName classname)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
PClass *cls = PClass::FindClass(classname);
if (cls == NULL)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
I_Error("Attempt to spawn actor of unknown type '%s'\n", classname.GetChars());
}
if (!cls->IsKindOf(RUNTIME_CLASS(PClassActor)))
{
I_Error("Attempt to spawn non-actor of type '%s'\n", classname.GetChars());
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
return static_cast<PClassActor*>(cls);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
void AActor::LevelSpawned ()
{
if (tics > 0 && !(flags4 & MF4_SYNCHRONIZED))
{
tics = 1 + (pr_spawnmapthing() % tics);
}
// [RH] Clear MF_DROPPED flag if the default version doesn't have it set.
// (AInventory::BeginPlay() makes all inventory items spawn with it set.)
if (!(GetDefault()->flags & MF_DROPPED))
{
flags &= ~MF_DROPPED;
}
HandleSpawnFlags ();
}
void AActor::HandleSpawnFlags ()
{
if (SpawnFlags & MTF_AMBUSH)
{
flags |= MF_AMBUSH;
}
if (SpawnFlags & MTF_DORMANT)
{
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
CallDeactivate (NULL);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (SpawnFlags & MTF_STANDSTILL)
{
flags4 |= MF4_STANDSTILL;
}
if (SpawnFlags & MTF_FRIENDLY)
{
flags |= MF_FRIENDLY;
// Friendlies don't count as kills!
if (flags & MF_COUNTKILL)
{
flags &= ~MF_COUNTKILL;
level.total_monsters--;
}
}
if (SpawnFlags & MTF_SHADOW)
{
flags |= MF_SHADOW;
RenderStyle = STYLE_Translucent;
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
Alpha = 0.25;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else if (SpawnFlags & MTF_ALTSHADOW)
{
RenderStyle = STYLE_None;
}
if (SpawnFlags & MTF_SECRET)
{
if (!(flags5 & MF5_COUNTSECRET))
{
//Printf("Secret %s in sector %i!\n", GetTag(), Sector->sectornum);
flags5 |= MF5_COUNTSECRET;
level.total_secrets++;
}
}
}
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
DEFINE_ACTION_FUNCTION(AActor, HandleSpawnFlags)
{
PARAM_SELF_PROLOGUE(AActor);
self->HandleSpawnFlags();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::BeginPlay ()
{
// If the actor is spawned with the dormant flag set, clear it, and use
// the normal deactivation logic to make it properly dormant.
if (flags2 & MF2_DORMANT)
{
flags2 &= ~MF2_DORMANT;
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
CallDeactivate (NULL);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- added scriptable virtual overrides for PostBeginPlay, Tick, BeginPlay, Activate and Deactivate.
2016-11-21 13:59:17 +00:00
DEFINE_ACTION_FUNCTION(AActor, BeginPlay)
{
PARAM_SELF_PROLOGUE(AActor);
self->BeginPlay();
return 0;
}
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
void AActor::CallBeginPlay()
{
IFVIRTUAL(AActor, BeginPlay)
{
// Without the type cast this picks the 'void *' assignment...
VMValue params[1] = { (DObject*)this };
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 1, nullptr, 0, nullptr);
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
}
else BeginPlay();
}
- added scriptable virtual overrides for PostBeginPlay, Tick, BeginPlay, Activate and Deactivate.
2016-11-21 13:59:17 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::PostBeginPlay ()
{
if (Renderer != NULL)
{
Renderer->StateChanged(this);
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
PrevAngles = Angles;
Normalize line endings
2016-03-01 15:47:10 +00:00
flags7 |= MF7_HANDLENODELAY;
}
void AActor::MarkPrecacheSounds() const
{
SeeSound.MarkUsed();
AttackSound.MarkUsed();
PainSound.MarkUsed();
DeathSound.MarkUsed();
ActiveSound.MarkUsed();
UseSound.MarkUsed();
BounceSound.MarkUsed();
WallBounceSound.MarkUsed();
CrushPainSound.MarkUsed();
}
- scriptified ASoundSequence. - exported virtual Actor.MarkPrecacheSounds function.
2017-01-14 13:35:11 +00:00
DEFINE_ACTION_FUNCTION(AActor, MarkPrecacheSounds)
{
PARAM_SELF_PROLOGUE(AActor);
self->MarkPrecacheSounds();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
bool AActor::isFast()
{
if (flags5&MF5_ALWAYSFAST) return true;
if (flags5&MF5_NEVERFAST) return false;
return !!G_SkillProperty(SKILLP_FastMonsters);
}
bool AActor::isSlow()
{
return !!G_SkillProperty(SKILLP_SlowMonsters);
}
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
//===========================================================================
//
// Activate
//
//===========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::Activate (AActor *activator)
{
if ((flags3 & MF3_ISMONSTER) && (health > 0 || (flags & MF_ICECORPSE)))
{
if (flags2 & MF2_DORMANT)
{
flags2 &= ~MF2_DORMANT;
FState *state = FindState(NAME_Active);
if (state != NULL)
{
SetState(state);
}
else
{
tics = 1;
}
}
}
}
- added scriptable virtual overrides for PostBeginPlay, Tick, BeginPlay, Activate and Deactivate.
2016-11-21 13:59:17 +00:00
DEFINE_ACTION_FUNCTION(AActor, Activate)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(activator, AActor);
self->Activate(activator);
return 0;
}
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
void AActor::CallActivate(AActor *activator)
{
IFVIRTUAL(AActor, Activate)
{
// Without the type cast this picks the 'void *' assignment...
VMValue params[2] = { (DObject*)this, (DObject*)activator };
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 2, nullptr, 0, nullptr);
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
}
else Activate(activator);
}
//===========================================================================
//
// Deactivate
//
//===========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::Deactivate (AActor *activator)
{
if ((flags3 & MF3_ISMONSTER) && (health > 0 || (flags & MF_ICECORPSE)))
{
if (!(flags2 & MF2_DORMANT))
{
flags2 |= MF2_DORMANT;
FState *state = FindState(NAME_Inactive);
if (state != NULL)
{
SetState(state);
}
else
{
tics = -1;
}
}
}
}
- added scriptable virtual overrides for PostBeginPlay, Tick, BeginPlay, Activate and Deactivate.
2016-11-21 13:59:17 +00:00
DEFINE_ACTION_FUNCTION(AActor, Deactivate)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(activator, AActor);
self->Deactivate(activator);
return 0;
}
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
void AActor::CallDeactivate(AActor *activator)
{
IFVIRTUAL(AActor, Deactivate)
{
// Without the type cast this picks the 'void *' assignment...
VMValue params[2] = { (DObject*)this, (DObject*)activator };
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 2, nullptr, 0, nullptr);
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
}
else Deactivate(activator);
}
- added a new sector list to AActor that collects all portal-linked sectors the actor's center is in. (Inspired by Eternity's solution to the same problem.) This is for rendering the sprite properly in all areas the actor touches. The original thinglist is not sufficient for this and Boom's touching thinglist has other purposes and collects too much data. This new list will only get filled in when the actor is actually crossing a portal plane, for the normal sector thinglist will still be used. This piggybacks on the msecnode_t code which has been extended to be able to handle more than one list by passing the sector's membert pointers as parameters.
2016-04-17 21:48:04 +00:00
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
//===========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
//
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
// Destroy
Normalize line endings
2016-03-01 15:47:10 +00:00
//
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
//===========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
- split DObject::Destroy into the main method, a native OnDestroy and a scripted OnDestroy method and made the main method non-virtual This was done to ensure it can be properly overridden in scripts without causing problems when called during engine shutdown for the type and symbol objects the VM needs to work and to have the scripted version always run first. Since the scripted OnDestroy method never calls the native version - the native one is run after the scripted one - this can be simply skipped over during shutdown.
2017-01-12 21:49:18 +00:00
void AActor::OnDestroy ()
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added a new sector list to AActor that collects all portal-linked sectors the actor's center is in. (Inspired by Eternity's solution to the same problem.) This is for rendering the sprite properly in all areas the actor touches. The original thinglist is not sufficient for this and Boom's touching thinglist has other purposes and collects too much data. This new list will only get filled in when the actor is actually crossing a portal plane, for the normal sector thinglist will still be used. This piggybacks on the msecnode_t code which has been extended to be able to handle more than one list by passing the sector's membert pointers as parameters.
2016-04-17 21:48:04 +00:00
ClearRenderSectorList();
- fixed: The line portal links were not deleted when an actor was destroyed.
2016-05-11 07:58:03 +00:00
ClearRenderLineList();
- added a new sector list to AActor that collects all portal-linked sectors the actor's center is in. (Inspired by Eternity's solution to the same problem.) This is for rendering the sprite properly in all areas the actor touches. The original thinglist is not sufficient for this and Boom's touching thinglist has other purposes and collects too much data. This new list will only get filled in when the actor is actually crossing a portal plane, for the normal sector thinglist will still be used. This piggybacks on the msecnode_t code which has been extended to be able to handle more than one list by passing the sector's membert pointers as parameters.
2016-04-17 21:48:04 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] Destroy any inventory this actor is carrying
DestroyAllInventory ();
// [RH] Unlink from tid chain
RemoveFromHash ();
// unlink from sector and block lists
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
UnlinkFromWorld (nullptr);
Normalize line endings
2016-03-01 15:47:10 +00:00
flags |= MF_NOSECTOR|MF_NOBLOCKMAP;
// Transform any playing sound into positioned, non-actor sounds.
S_RelinkSound (this, NULL);
- split DObject::Destroy into the main method, a native OnDestroy and a scripted OnDestroy method and made the main method non-virtual This was done to ensure it can be properly overridden in scripts without causing problems when called during engine shutdown for the type and symbol objects the VM needs to work and to have the scripted version always run first. Since the scripted OnDestroy method never calls the native version - the native one is run after the scripted one - this can be simply skipped over during shutdown.
2017-01-12 21:49:18 +00:00
Super::OnDestroy();
Normalize line endings
2016-03-01 15:47:10 +00:00
}
//===========================================================================
//
// AdjustFloorClip
//
//===========================================================================
void AActor::AdjustFloorClip ()
{
if (flags3 & MF3_SPECIALFLOORCLIP)
{
return;
}
- floatification of p_enemy and p_interaction.cpp.
2016-03-26 19:59:35 +00:00
double oldclip = Floorclip;
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
double shallowestclip = INT_MAX;
Normalize line endings
2016-03-01 15:47:10 +00:00
const msecnode_t *m;
// possibly standing on a 3D-floor
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (Sector->e->XFloor.ffloors.Size() && Z() > Sector->floorplane.ZatPoint(this)) Floorclip = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH] clip based on shallowest floor player is standing on
// If the sector has a deep water effect, then let that effect
// do the floorclipping instead of the terrain type.
for (m = touching_sectorlist; m; m = m->m_tnext)
{
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
DVector3 pos = PosRelative(m->m_sector);
Normalize line endings
2016-03-01 15:47:10 +00:00
sector_t *hsec = m->m_sector->GetHeightSec();
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
if (hsec == NULL && m->m_sector->floorplane.ZatPoint (pos) == Z())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
double clip = Terrains[m->m_sector->GetTerrain(sector_t::floor)].FootClip;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (clip < shallowestclip)
{
shallowestclip = clip;
}
}
}
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
if (shallowestclip == INT_MAX)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
Floorclip = 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
Floorclip = shallowestclip;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- made AActor::floorclip a double.
2016-03-20 22:42:27 +00:00
if (player && player->mo == this && oldclip != Floorclip)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified viewheight variables and some related code.
2016-03-22 17:06:08 +00:00
player->viewheight -= (oldclip - Floorclip);
Normalize line endings
2016-03-01 15:47:10 +00:00
player->deltaviewheight = player->GetDeltaViewHeight();
}
}
- scriptified several trivial functions from a_action.cpp.
2016-11-01 15:32:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, AdjustFloorClip)
{
PARAM_SELF_PROLOGUE(AActor);
self->AdjustFloorClip();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//
// P_SpawnPlayer
// Called when a player is spawned on the level.
// Most of the player structure stays unchanged between levels.
//
EXTERN_CVAR (Bool, chasedemo)
- Implemented sv_singleplayerrespawn
2016-10-23 10:06:59 +00:00
EXTERN_CVAR(Bool, sv_singleplayerrespawn)
Normalize line endings
2016-03-01 15:47:10 +00:00
extern bool demonew;
APlayerPawn *P_SpawnPlayer (FPlayerStart *mthing, int playernum, int flags)
{
player_t *p;
APlayerPawn *mobj, *oldactor;
BYTE state;
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
DVector3 spawn;
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
DAngle SpawnAngle;
Normalize line endings
2016-03-01 15:47:10 +00:00
Add NULL mthing check to P_SpawnPlayer
2016-03-09 03:42:24 +00:00
if (mthing == NULL)
{
return NULL;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// not playing?
if ((unsigned)playernum >= (unsigned)MAXPLAYERS || !playeringame[playernum])
return NULL;
// Old lerp data needs to go
if (playernum == consoleplayer)
{
P_PredictionLerpReset();
}
p = &players[playernum];
if (p->cls == NULL)
{
// [GRB] Pick a class from player class list
if (PlayerClasses.Size () > 1)
{
int type;
if (!deathmatch || !multiplayer)
{
type = SinglePlayerClass[playernum];
}
else
{
type = p->userinfo.GetPlayerClassNum();
if (type < 0)
{
type = pr_multiclasschoice() % PlayerClasses.Size ();
}
}
p->CurrentPlayerClass = type;
}
else
{
p->CurrentPlayerClass = 0;
}
p->cls = PlayerClasses[p->CurrentPlayerClass].Type;
}
if (( dmflags2 & DF2_SAME_SPAWN_SPOT ) &&
( p->playerstate == PST_REBORN ) &&
( deathmatch == false ) &&
( gameaction != ga_worlddone ) &&
( p->mo != NULL ) &&
( !(p->mo->Sector->Flags & SECF_NORESPAWN) ) &&
( NULL != p->attacker ) && // don't respawn on damaging floors
( p->mo->Sector->damageamount < TELEFRAG_DAMAGE )) // this really should be a bit smarter...
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
spawn = p->mo->Pos();
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
SpawnAngle = p->mo->Angles.Yaw;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
spawn.X = mthing->pos.X;
spawn.Y = mthing->pos.Y;
Normalize line endings
2016-03-01 15:47:10 +00:00
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
// Allow full angular precision
- several fixes.
2016-03-16 21:29:35 +00:00
SpawnAngle = (double)mthing->angle;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (i_compatflags2 & COMPATF2_BADANGLES)
{
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
SpawnAngle += 0.01;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (GetDefaultByType(p->cls)->flags & MF_SPAWNCEILING)
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
spawn.Z = ONCEILINGZ;
Normalize line endings
2016-03-01 15:47:10 +00:00
else if (GetDefaultByType(p->cls)->flags2 & MF2_SPAWNFLOAT)
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
spawn.Z = FLOATRANDZ;
Normalize line endings
2016-03-01 15:47:10 +00:00
else
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
spawn.Z = ONFLOORZ;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
mobj = static_cast<APlayerPawn *>
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
(Spawn (p->cls, spawn, NO_REPLACE));
Normalize line endings
2016-03-01 15:47:10 +00:00
if (level.flags & LEVEL_USEPLAYERSTARTZ)
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
if (spawn.Z == ONFLOORZ)
- made player_t::crouchoffset and FPlayerStart's coordinates doubles and added a float version of divline_t so that I could complete the conversion of Hexen's game code. - consolidated the actor based damage factor code which was repeated multiple times in various damage inflicting functions.
2016-03-21 23:06:58 +00:00
mobj->AddZ(mthing->pos.Z);
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
else if (spawn.Z == ONCEILINGZ)
- made player_t::crouchoffset and FPlayerStart's coordinates doubles and added a float version of divline_t so that I could complete the conversion of Hexen's game code. - consolidated the actor based damage factor code which was repeated multiple times in various damage inflicting functions.
2016-03-21 23:06:58 +00:00
mobj->AddZ(-mthing->pos.Z);
Normalize line endings
2016-03-01 15:47:10 +00:00
P_FindFloorCeiling(mobj, FFCF_SAMESECTOR | FFCF_ONLY3DFLOORS | FFCF_3DRESTRICT);
}
mobj->FriendPlayer = playernum + 1; // [RH] players are their own friends
oldactor = p->mo;
p->mo = mobj;
mobj->player = p;
state = p->playerstate;
if (state == PST_REBORN || state == PST_ENTER)
{
G_PlayerReborn (playernum);
}
else if (oldactor != NULL && oldactor->player == p && !(flags & SPF_TEMPPLAYER))
{
// Move the voodoo doll's inventory to the new player.
mobj->ObtainInventory (oldactor);
FBehavior::StaticStopMyScripts (oldactor); // cancel all ENTER/RESPAWN scripts for the voodoo doll
}
// [GRB] Reset skin
p->userinfo.SkinNumChanged(R_FindSkin (skins[p->userinfo.GetSkin()].name, p->CurrentPlayerClass));
if (!(mobj->flags2 & MF2_DONTTRANSLATE))
{
// [RH] Be sure the player has the right translation
R_BuildPlayerTranslation (playernum);
// [RH] set color translations for player sprites
mobj->Translation = TRANSLATION(TRANSLATION_Players,playernum);
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
mobj->Angles.Yaw = SpawnAngle;
Use ViewRoll instead of CamRoll, and removed CamRoll entirely. Begin work on interpolation.
2016-04-25 18:27:27 +00:00
mobj->Angles.Pitch = mobj->Angles.Roll = 0.;
Normalize line endings
2016-03-01 15:47:10 +00:00
mobj->health = p->health;
// [RH] Set player sprite based on skin
if (!(mobj->flags4 & MF4_NOSKIN))
{
mobj->sprite = skins[p->userinfo.GetSkin()].sprite;
}
p->DesiredFOV = p->FOV = 90.f;
p->camera = p->mo;
p->playerstate = PST_LIVE;
p->refire = 0;
p->damagecount = 0;
p->bonuscount = 0;
p->morphTics = 0;
p->MorphedPlayerClass = 0;
p->MorphStyle = 0;
p->MorphExitFlash = NULL;
p->extralight = 0;
p->fixedcolormap = NOFIXEDCOLORMAP;
p->fixedlightlevel = -1;
p->viewheight = mobj->ViewHeight;
p->inconsistant = 0;
p->attacker = NULL;
p->spreecount = 0;
p->multicount = 0;
p->lastkilltime = 0;
p->BlendR = p->BlendG = p->BlendB = p->BlendA = 0.f;
p->mo->ResetAirSupply(false);
p->Uncrouch();
- several fixes.
2016-03-16 21:29:35 +00:00
p->MinPitch = p->MaxPitch = 0.; // will be filled in by PostBeginPlay()/netcode
Normalize line endings
2016-03-01 15:47:10 +00:00
p->MUSINFOactor = NULL;
p->MUSINFOtics = -1;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
p->Vel.Zero(); // killough 10/98: initialize bobbing to 0.
Normalize line endings
2016-03-01 15:47:10 +00:00
for (int ii = 0; ii < MAXPLAYERS; ++ii)
{
if (playeringame[ii] && players[ii].camera == oldactor)
{
players[ii].camera = mobj;
}
}
// [RH] Allow chasecam for demo watching
if ((demoplayback || demonew) && chasedemo)
p->cheats = CF_CHASECAM;
// setup gun psprite
if (!(flags & SPF_TEMPPLAYER))
{ // This can also start a script so don't do it for the dummy player.
P_SetupPsprites (p, !!(flags & SPF_WEAPONFULLYUP));
}
if (deathmatch)
{ // Give all cards in death match mode.
p->mo->GiveDeathmatchInventory ();
}
- Implemented sv_singleplayerrespawn
2016-10-23 10:06:59 +00:00
else if ((multiplayer || (level.flags2 & LEVEL2_ALLOWRESPAWN) || sv_singleplayerrespawn) && state == PST_REBORN && oldactor != NULL)
Normalize line endings
2016-03-01 15:47:10 +00:00
{ // Special inventory handling for respawning in coop
p->mo->FilterCoopRespawnInventory (oldactor);
}
if (oldactor != NULL)
{ // Remove any inventory left from the old actor. Coop handles
// it above, but the other modes don't.
oldactor->DestroyAllInventory();
}
// [BC] Handle temporary invulnerability when respawned
- eliminated the native PowerupGiver class. - scriptified the respawn invulnerability code into a virtual OnRespawn function for PlayerPawn so that custom effects can be implemented.
2017-01-17 23:11:04 +00:00
if (state == PST_REBORN || state == PST_ENTER)
{
IFVIRTUALPTR(p->mo, APlayerPawn, OnRespawn)
{
VMValue param = p->mo;
GlobalVMStack.Call(func, &param, 1, nullptr, 0);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (StatusBar != NULL && (playernum == consoleplayer || StatusBar->GetPlayer() == playernum))
{
StatusBar->AttachToPlayer (p);
}
if (multiplayer)
{
- fixed some issues with teleport fog: * many calls didn't use TELEFOGHEIGHT, mostly those coming from external code submissions that never were tested on anything but Doom. Addressed by adding this value inside P_SpawnTeleportFog and making the distinction between projectiles and non-projectiles from P_Teleport also part of this function. * there were still a few places which spawned the teleport fog directly, skipping all the added features of P_SpawnTeleportFog.
2016-06-06 08:48:40 +00:00
P_SpawnTeleportFog(mobj, mobj->Vec3Angle(20., mobj->Angles.Yaw, 0.), false, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// "Fix" for one of the starts on exec.wad MAP01: If you start inside the ceiling,
// drop down below it, even if that means sinking into the floor.
- replaced ceilingz with a floating point variable, also in FCheckPosition.
2016-03-20 12:32:53 +00:00
if (mobj->Top() > mobj->ceilingz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
mobj->SetZ(mobj->ceilingz - mobj->Height, false);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// [BC] Do script stuff
if (!(flags & SPF_TEMPPLAYER))
{
if (state == PST_ENTER || (state == PST_LIVE && !savegamerestore))
{
FBehavior::StaticStartTypedScripts (SCRIPT_Enter, p->mo, true);
}
else if (state == PST_REBORN)
{
assert (oldactor != NULL);
// before relocating all pointers to the player all sound targets
// pointing to the old actor have to be NULLed. Otherwise all
// monsters who last targeted this player will wake up immediately
// after the player has respawned.
AActor *th;
TThinkerIterator<AActor> it;
while ((th = it.Next()))
{
if (th->LastHeard == oldactor) th->LastHeard = NULL;
}
- refactored the global sectors array into a more VM friendly type and moved it into FLevelLocals.
2017-01-07 18:32:24 +00:00
for(auto &sec : level.sectors)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- refactored the global sectors array into a more VM friendly type and moved it into FLevelLocals.
2017-01-07 18:32:24 +00:00
if (sec.SoundTarget == oldactor) sec.SoundTarget = nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
DObject::StaticPointerSubstitution (oldactor, p->mo);
// PointerSubstitution() will also affect the bodyque, so undo that now.
for (int ii=0; ii < BODYQUESIZE; ++ii)
if (bodyque[ii] == p->mo)
bodyque[ii] = oldactor;
FBehavior::StaticStartTypedScripts (SCRIPT_Respawn, p->mo, true);
}
}
return mobj;
}
//
// P_SpawnMapThing
// The fields of the mapthing should
// already be in host byte order.
//
// [RH] position is used to weed out unwanted start spots
AActor *P_SpawnMapThing (FMapThing *mthing, int position)
{
PClassActor *i;
int mask;
AActor *mobj;
if (mthing->EdNum == 0 || mthing->EdNum == -1)
return NULL;
// find which type to spawn
FDoomEdEntry *mentry = mthing->info;
if (mentry == NULL)
{
// [RH] Don't die if the map tries to spawn an unknown thing
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
Printf("Unknown type %i at (%.1f, %.1f)\n",
mthing->EdNum, mthing->pos.X, mthing->pos.Y);
Normalize line endings
2016-03-01 15:47:10 +00:00
mentry = DoomEdMap.CheckKey(0);
if (mentry == NULL) // we need a valid entry for the rest of this function so if we can't find a default, let's exit right away.
{
return NULL;
}
}
if (mentry->Type == NULL && mentry->Special <= 0)
{
// has been explicitly set to not spawning anything.
return NULL;
}
// copy args to mapthing so that we have them in one place for the rest of this function
if (mentry->ArgsDefined > 0)
{
if (mentry->Type!= NULL) mthing->special = mentry->Special;
memcpy(mthing->args, mentry->Args, sizeof(mthing->args[0]) * mentry->ArgsDefined);
}
int pnum = -1;
if (mentry->Type == NULL)
{
switch (mentry->Special)
{
case SMT_DeathmatchStart:
{
// count deathmatch start positions
FPlayerStart start(mthing, 0);
deathmatchstarts.Push(start);
return NULL;
}
case SMT_PolyAnchor:
case SMT_PolySpawn:
case SMT_PolySpawnCrush:
case SMT_PolySpawnHurt:
{
polyspawns_t *polyspawn = new polyspawns_t;
polyspawn->next = polyspawns;
- floatified p_sight.cpp.
2016-03-28 14:22:21 +00:00
polyspawn->pos = mthing->pos;
Normalize line endings
2016-03-01 15:47:10 +00:00
polyspawn->angle = mthing->angle;
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
polyspawn->type = mentry->Special;
Normalize line endings
2016-03-01 15:47:10 +00:00
polyspawns = polyspawn;
if (mentry->Special != SMT_PolyAnchor)
po_NumPolyobjs++;
return NULL;
}
case SMT_Player1Start:
case SMT_Player2Start:
case SMT_Player3Start:
case SMT_Player4Start:
case SMT_Player5Start:
case SMT_Player6Start:
case SMT_Player7Start:
case SMT_Player8Start:
pnum = mentry->Special - SMT_Player1Start;
break;
// Sound sequence override will be handled later
default:
break;
}
}
if (pnum == -1 || (level.flags & LEVEL_FILTERSTARTS))
{
// check for appropriate game type
if (deathmatch)
{
mask = MTF_DEATHMATCH;
}
else if (multiplayer)
{
mask = MTF_COOPERATIVE;
}
else
{
mask = MTF_SINGLE;
}
if (!(mthing->flags & mask))
{
return NULL;
}
mask = G_SkillProperty(SKILLP_SpawnFilter);
if (!(mthing->SkillFilter & mask))
{
return NULL;
}
// Check class spawn masks. Now with player classes available
// this is enabled for all games.
if (!multiplayer)
{ // Single player
int spawnmask = players[consoleplayer].GetSpawnClass();
if (spawnmask != 0 && (mthing->ClassFilter & spawnmask) == 0)
{ // Not for current class
return NULL;
}
}
else if (!deathmatch)
{ // Cooperative
mask = 0;
for (int i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i])
{
int spawnmask = players[i].GetSpawnClass();
if (spawnmask != 0)
mask |= spawnmask;
else
mask = -1;
}
}
if (mask != -1 && (mthing->ClassFilter & mask) == 0)
{
return NULL;
}
}
}
if (pnum != -1)
{
// [RH] Only spawn spots that match position.
if (mthing->args[0] != position)
return NULL;
// save spots for respawning in network games
FPlayerStart start(mthing, pnum+1);
playerstarts[pnum] = start;
Fixed: In multiplayer, players could spawn at voodoo doll starts - This could happen in co-op games that did not have enough player starts for all the players spawning. Voodoo doll starts were not excluded from the set of possible starts as they should have been.
2016-03-07 16:53:51 +00:00
if (level.flags2 & LEVEL2_RANDOMPLAYERSTARTS)
{ // When using random player starts, all starts count
AllPlayerStarts.Push(start);
}
else
{ // When not using random player starts, later single player
// starts should override earlier ones, since the earlier
// ones are for voodoo dolls and not likely to be ideal for
// spawning regular players.
unsigned i;
for (i = 0; i < AllPlayerStarts.Size(); ++i)
{
if (AllPlayerStarts[i].type == pnum+1)
{
AllPlayerStarts[i] = start;
break;
}
}
if (i == AllPlayerStarts.Size())
{
AllPlayerStarts.Push(start);
}
}
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!deathmatch && !(level.flags2 & LEVEL2_RANDOMPLAYERSTARTS))
{
return P_SpawnPlayer(&start, pnum, (level.flags2 & LEVEL2_PRERAISEWEAPON) ? SPF_WEAPONFULLYUP : 0);
}
return NULL;
}
// [RH] sound sequence overriders
if (mentry->Type == NULL && mentry->Special == SMT_SSeqOverride)
{
int type = mthing->args[0];
if (type == 255) type = -1;
if (type > 63)
{
Printf ("Sound sequence %d out of range\n", type);
}
else
{
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
P_PointInSector (mthing->pos)->seqType = type;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
return NULL;
}
// [RH] If the thing's corresponding sprite has no frames, also map
// it to the unknown thing.
// Handle decorate replacements explicitly here
// to check for missing frames in the replacement object.
i = mentry->Type->GetReplacement();
const AActor *defaults = GetDefaultByType (i);
if (defaults->SpawnState == NULL ||
sprites[defaults->SpawnState->sprite].numframes == 0)
{
// We don't load mods for shareware games so we'll just ignore
// missing actors. Heretic needs this since the shareware includes
// the retail weapons in Deathmatch.
if (gameinfo.flags & GI_SHAREWARE)
return NULL;
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
Printf ("%s at (%.1f, %.1f) has no frames\n",
i->TypeName.GetChars(), mthing->pos.X, mthing->pos.Y);
Normalize line endings
2016-03-01 15:47:10 +00:00
i = PClass::FindActor("Unknown");
assert(i->IsKindOf(RUNTIME_CLASS(PClassActor)));
}
const AActor *info = GetDefaultByType (i);
// don't spawn keycards and players in deathmatch
if (deathmatch && info->flags & MF_NOTDMATCH)
return NULL;
// [RH] don't spawn extra weapons in coop if so desired
if (multiplayer && !deathmatch && (dmflags & DF_NO_COOP_WEAPON_SPAWN))
{
if (GetDefaultByType(i)->flags7 & MF7_WEAPONSPAWN)
{
if ((mthing->flags & (MTF_DEATHMATCH|MTF_SINGLE)) == MTF_DEATHMATCH)
return NULL;
}
}
// don't spawn any monsters if -nomonsters
if (((level.flags2 & LEVEL2_NOMONSTERS) || (dmflags & DF_NO_MONSTERS)) && info->flags3 & MF3_ISMONSTER )
{
return NULL;
}
// [RH] Other things that shouldn't be spawned depending on dmflags
if (deathmatch || alwaysapplydmflags)
{
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
// Fixme: This needs to be done differently, it's quite broken.
Normalize line endings
2016-03-01 15:47:10 +00:00
if (dmflags & DF_NO_HEALTH)
{
- added property definitions to the ZScript parser. This will allow defining custom properties for the default block in custom base classes. See 'Health' for an example. - support transient object member variables for information that does not need to be put in a savegame. - fixed: special initialization of objects needs to pass the proper defaults along, otherwise the parent classes will use their own, inappropriate one.
2017-01-15 15:55:30 +00:00
if (i->IsDescendantOf (PClass::FindActor(NAME_Health)))
Normalize line endings
2016-03-01 15:47:10 +00:00
return NULL;
if (i->TypeName == NAME_Berserk)
return NULL;
if (i->TypeName == NAME_Megasphere)
return NULL;
}
if (dmflags & DF_NO_ITEMS)
{
// if (i->IsDescendantOf (RUNTIME_CLASS(AArtifact)))
// return;
}
if (dmflags & DF_NO_ARMOR)
{
- no need to keep AArmor native, now that all child classes have been scriptified.
2017-01-18 22:46:19 +00:00
if (i->IsDescendantOf (PClass::FindActor(NAME_Armor)))
Normalize line endings
2016-03-01 15:47:10 +00:00
return NULL;
if (i->TypeName == NAME_Megasphere)
return NULL;
}
}
// spawn it
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
double sz;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (info->flags & MF_SPAWNCEILING)
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
sz = ONCEILINGZ;
Normalize line endings
2016-03-01 15:47:10 +00:00
else if (info->flags2 & MF2_SPAWNFLOAT)
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
sz = FLOATRANDZ;
Normalize line endings
2016-03-01 15:47:10 +00:00
else
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
sz = ONFLOORZ;
Normalize line endings
2016-03-01 15:47:10 +00:00
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
mobj = AActor::StaticSpawn (i, DVector3(mthing->pos, sz), NO_REPLACE, true);
Normalize line endings
2016-03-01 15:47:10 +00:00
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
if (sz == ONFLOORZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
mobj->AddZ(mthing->pos.Z);
Normalize line endings
2016-03-01 15:47:10 +00:00
if ((mobj->flags2 & MF2_FLOATBOB) && (ib_compatflags & BCOMPATF_FLOATBOB))
{
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
mobj->specialf1 = mthing->pos.Z;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
else if (sz == ONCEILINGZ)
mobj->AddZ(-mthing->pos.Z);
Normalize line endings
2016-03-01 15:47:10 +00:00
- floatified FMapThing, dropoffz and GetBobOffset
2016-03-23 11:21:52 +00:00
mobj->SpawnPoint = mthing->pos;
Normalize line endings
2016-03-01 15:47:10 +00:00
mobj->SpawnAngle = mthing->angle;
mobj->SpawnFlags = mthing->flags;
if (mthing->FloatbobPhase >= 0 && mthing->FloatbobPhase < 64) mobj->FloatBobPhase = mthing->FloatbobPhase;
- made AActor::gravity and FMapThing::gravity floats.
2016-03-20 23:51:19 +00:00
if (mthing->Gravity < 0) mobj->Gravity = -mthing->Gravity;
else if (mthing->Gravity > 0) mobj->Gravity *= mthing->Gravity;
- fixed: P_SpawnMapThing forced gravity instead of disabling it when being given Gravity = 0 from UDMF.
2016-11-23 13:32:18 +00:00
else
{
mobj->flags |= MF_NOGRAVITY;
mobj->Gravity = 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// For Hexen floatbob 'compatibility' we do not really want to alter the floorz.
- added two floating point special variables, because the two existing ones are integers and unusable for storing doubles.
2016-03-20 20:51:09 +00:00
if (mobj->specialf1 == 0 || !(mobj->flags2 & MF2_FLOATBOB) || !(ib_compatflags & BCOMPATF_FLOATBOB))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
P_FindFloorCeiling(mobj, FFCF_SAMESECTOR | FFCF_ONLY3DFLOORS | FFCF_3DRESTRICT);
}
// if the actor got args defined either in DECORATE or MAPINFO we must ignore the map's properties.
if (!(mobj->flags2 & MF2_ARGSDEFINED))
{
// [RH] Set the thing's special
mobj->special = mthing->special;
for(int j=0;j<5;j++) mobj->args[j]=mthing->args[j];
}
// [RH] Add ThingID to mobj and link it in with the others
mobj->tid = mthing->thingid;
mobj->AddToHash ();
- several fixes.
2016-03-16 21:29:35 +00:00
mobj->PrevAngles.Yaw = mobj->Angles.Yaw = (double)mthing->angle;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Check if this actor's mapthing has a conversation defined
if (mthing->Conversation > 0)
{
// Make sure that this does not partially overwrite the default dialogue settings.
int root = GetConversation(mthing->Conversation);
if (root != -1)
{
mobj->ConversationRoot = root;
mobj->Conversation = StrifeDialogues[mobj->ConversationRoot];
}
}
// Set various UDMF options
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
if (mthing->Alpha >= 0)
mobj->Alpha = mthing->Alpha;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mthing->RenderStyle != STYLE_Count)
mobj->RenderStyle = (ERenderStyle)mthing->RenderStyle;
- converted scale variables in AActor, FMapThing and skin to float.
2016-03-20 11:13:00 +00:00
if (mthing->Scale.X != 0)
mobj->Scale.X = mthing->Scale.X * mobj->Scale.X;
if (mthing->Scale.Y != 0)
- fixed typo in actor scale assignment when spawning.
2016-04-08 14:52:42 +00:00
mobj->Scale.Y = mthing->Scale.Y * mobj->Scale.Y;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mthing->pitch)
- several fixes.
2016-03-16 21:29:35 +00:00
mobj->Angles.Pitch = (double)mthing->pitch;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mthing->roll)
Use ViewRoll instead of CamRoll, and removed CamRoll entirely. Begin work on interpolation.
2016-04-25 18:27:27 +00:00
mobj->Angles.Roll = (double)mthing->roll;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mthing->score)
mobj->Score = mthing->score;
if (mthing->fillcolor)
mobj->fillcolor = mthing->fillcolor;
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
mobj->CallBeginPlay ();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!(mobj->ObjectFlags & OF_EuthanizeMe))
{
mobj->LevelSpawned ();
}
if (mthing->health > 0)
mobj->health *= mthing->health;
else
mobj->health = -mthing->health;
if (mthing->health == 0)
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
mobj->CallDie(NULL, NULL);
Normalize line endings
2016-03-01 15:47:10 +00:00
else if (mthing->health != 1)
mobj->StartHealth = mobj->health;
return mobj;
}
//
// GAME SPAWN FUNCTIONS
//
//
// P_SpawnPuff
//
- fixed some particle positioning errors.
2016-04-10 08:57:48 +00:00
AActor *P_SpawnPuff (AActor *source, PClassActor *pufftype, const DVector3 &pos1, DAngle hitdir, DAngle particledir, int updown, int flags, AActor *vict)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
AActor *puff;
- fixed some particle positioning errors.
2016-04-10 08:57:48 +00:00
DVector3 pos = pos1;
Normalize line endings
2016-03-01 15:47:10 +00:00
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (pufftype == nullptr) return nullptr;
- fixed some particle positioning errors.
2016-04-10 08:57:48 +00:00
if (!(flags & PF_NORANDOMZ)) pos.Z += pr_spawnpuff.Random2() / 64.;
puff = Spawn(pufftype, pos, ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (puff == NULL) return NULL;
if ((puff->flags4 & MF4_RANDOMIZE) && puff->tics > 0)
{
puff->tics -= pr_spawnpuff() & 3;
if (puff->tics < 1)
puff->tics = 1;
}
//Moved puff creation and target/master/tracer setting to here.
if (puff && vict)
{
if (puff->flags7 & MF7_HITTARGET) puff->target = vict;
if (puff->flags7 & MF7_HITMASTER) puff->master = vict;
if (puff->flags7 & MF7_HITTRACER) puff->tracer = vict;
}
// [BB] If the puff came from a player, set the target of the puff to this player.
if ( puff && (puff->flags5 & MF5_PUFFGETSOWNER))
puff->target = source;
- made adjustments to P_LineAttack and P_RailAttack to deal with altered angles by passing through a non-parallel portal. - fixed: P_FindFloorCeiling set the floorsector for a new ceilingheight. Note: P_DrawRailTrail still needs to be changed, at the moment rail trails through portals will not work correctly.
2016-03-06 20:58:36 +00:00
// Angle is the opposite of the hit direction (i.e. the puff faces the source.)
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
puff->Angles.Yaw = hitdir + 180;
Normalize line endings
2016-03-01 15:47:10 +00:00
// If a puff has a crash state and an actor was not hit,
// it will enter the crash state. This is used by the StrifeSpark
// and BlasterPuff.
FState *crashstate;
if (!(flags & PF_HITTHING) && (crashstate = puff->FindState(NAME_Crash)) != NULL)
{
puff->SetState (crashstate);
}
else if ((flags & PF_HITTHINGBLEED) && (crashstate = puff->FindState(NAME_Death, NAME_Extreme, true)) != NULL)
{
puff->SetState (crashstate);
}
else if ((flags & PF_MELEERANGE) && puff->MeleeState != NULL)
{
// handle the hard coded state jump of Doom's bullet puff
// in a more flexible manner.
puff->SetState (puff->MeleeState);
}
if (!(flags & PF_TEMPORARY))
{
if (cl_pufftype && updown != 3 && (puff->flags4 & MF4_ALLOWPARTICLES))
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
P_DrawSplash2 (32, pos, particledir, updown, 1);
Normalize line endings
2016-03-01 15:47:10 +00:00
puff->renderflags |= RF_INVISIBLE;
}
if ((flags & PF_HITTHING) && puff->SeeSound)
{ // Hit thing sound
S_Sound (puff, CHAN_BODY, puff->SeeSound, 1, ATTN_NORM);
}
else if (puff->AttackSound)
{
S_Sound (puff, CHAN_BODY, puff->AttackSound, 1, ATTN_NORM);
}
}
return puff;
}
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnPuff)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(pufftype, AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_ANGLE(hitdir);
PARAM_ANGLE(particledir);
PARAM_INT(updown);
PARAM_INT_DEF(flags);
PARAM_OBJECT_DEF(victim, AActor);
ACTION_RETURN_OBJECT(P_SpawnPuff(self, pufftype, DVector3(x, y, z), hitdir, particledir, updown, flags, victim));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// P_SpawnBlood
//
//---------------------------------------------------------------------------
- fixed: the random offset that gets used when spawning blood applies to both sprites and particles, not just sprites.
2016-04-07 12:14:44 +00:00
void P_SpawnBlood (const DVector3 &pos1, DAngle dir, int damage, AActor *originator)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
AActor *th;
PalEntry bloodcolor = originator->GetBloodColor();
PClassActor *bloodcls = originator->GetBloodType();
- fixed: the random offset that gets used when spawning blood applies to both sprites and particles, not just sprites.
2016-04-07 12:14:44 +00:00
DVector3 pos = pos1;
pos.Z += pr_spawnblood.Random2() / 64.;
Normalize line endings
2016-03-01 15:47:10 +00:00
int bloodtype = cl_bloodtype;
if (bloodcls != NULL && !(GetDefaultByType(bloodcls)->flags4 & MF4_ALLOWPARTICLES))
bloodtype = 0;
if (bloodcls != NULL)
{
- fixed: the random offset that gets used when spawning blood applies to both sprites and particles, not just sprites.
2016-04-07 12:14:44 +00:00
th = Spawn(bloodcls, pos, NO_REPLACE); // GetBloodType already performed the replacement
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
th->Vel.Z = 2;
- floatified p_sight.cpp.
2016-03-28 14:22:21 +00:00
th->Angles.Yaw = dir;
Normalize line endings
2016-03-01 15:47:10 +00:00
// [NG] Applying PUFFGETSOWNER to the blood will make it target the owner
if (th->flags5 & MF5_PUFFGETSOWNER) th->target = originator;
if (gameinfo.gametype & GAME_DoomChex)
{
th->tics -= pr_spawnblood() & 3;
if (th->tics < 1)
th->tics = 1;
}
// colorize the blood
if (bloodcolor != 0 && !(th->flags2 & MF2_DONTTRANSLATE))
{
th->Translation = TRANSLATION(TRANSLATION_Blood, bloodcolor.a);
}
// Moved out of the blood actor so that replacing blood is easier
if (gameinfo.gametype & GAME_DoomStrifeChex)
{
if (gameinfo.gametype == GAME_Strife)
{
if (damage > 13)
{
FState *state = th->FindState(NAME_Spray);
if (state != NULL)
{
th->SetState (state);
goto statedone;
}
}
else damage += 2;
}
int advance = 0;
if (damage <= 12 && damage >= 9)
{
advance = 1;
}
else if (damage < 9)
{
advance = 2;
}
PClassActor *cls = th->GetClass();
while (cls != RUNTIME_CLASS(AActor))
{
int checked_advance = advance;
if (cls->OwnsState(th->SpawnState))
{
for (; checked_advance > 0; --checked_advance)
{
// [RH] Do not set to a state we do not own.
if (cls->OwnsState(th->SpawnState + checked_advance))
{
th->SetState(th->SpawnState + checked_advance);
goto statedone;
}
}
}
// We can safely assume the ParentClass is of type PClassActor
// since we stop when we see the Actor base class.
cls = static_cast<PClassActor *>(cls->ParentClass);
}
}
statedone:
if (!(bloodtype <= 1)) th->renderflags |= RF_INVISIBLE;
}
if (bloodtype >= 1)
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
P_DrawSplash2 (40, pos, dir, 2, bloodcolor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnBlood)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_ANGLE(dir);
PARAM_INT(damage);
P_SpawnBlood(DVector3(x, y, z), dir, damage, self);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// PROC P_BloodSplatter
//
//---------------------------------------------------------------------------
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
void P_BloodSplatter (const DVector3 &pos, AActor *originator, DAngle hitangle)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
PalEntry bloodcolor = originator->GetBloodColor();
PClassActor *bloodcls = originator->GetBloodType(1);
int bloodtype = cl_bloodtype;
if (bloodcls != NULL && !(GetDefaultByType(bloodcls)->flags4 & MF4_ALLOWPARTICLES))
bloodtype = 0;
if (bloodcls != NULL)
{
AActor *mo;
- made adjustments to P_LineAttack and P_RailAttack to deal with altered angles by passing through a non-parallel portal. - fixed: P_FindFloorCeiling set the floorsector for a new ceilingheight. Note: P_DrawRailTrail still needs to be changed, at the moment rail trails through portals will not work correctly.
2016-03-06 20:58:36 +00:00
mo = Spawn(bloodcls, pos, NO_REPLACE); // GetBloodType already performed the replacement
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->target = originator;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = pr_splatter.Random2 () / 64.;
mo->Vel.Y = pr_splatter.Random2() / 64.;
mo->Vel.Z = 3;
Normalize line endings
2016-03-01 15:47:10 +00:00
// colorize the blood!
if (bloodcolor!=0 && !(mo->flags2 & MF2_DONTTRANSLATE))
{
mo->Translation = TRANSLATION(TRANSLATION_Blood, bloodcolor.a);
}
if (!(bloodtype <= 1)) mo->renderflags |= RF_INVISIBLE;
}
if (bloodtype >= 1)
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
P_DrawSplash2 (40, pos, hitangle-180., 2, bloodcolor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//===========================================================================
//
// P_BloodSplatter2
//
//===========================================================================
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
void P_BloodSplatter2 (const DVector3 &pos, AActor *originator, DAngle hitangle)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
PalEntry bloodcolor = originator->GetBloodColor();
PClassActor *bloodcls = originator->GetBloodType(2);
int bloodtype = cl_bloodtype;
if (bloodcls != NULL && !(GetDefaultByType(bloodcls)->flags4 & MF4_ALLOWPARTICLES))
bloodtype = 0;
- fixed some particle positioning errors.
2016-04-10 08:57:48 +00:00
DVector2 add;
add.X = (pr_splat() - 128) / 32.;
add.Y = (pr_splat() - 128) / 32.;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (bloodcls != NULL)
{
AActor *mo;
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
mo = Spawn (bloodcls, pos + add, NO_REPLACE); // GetBloodType already performed the replacement
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->target = originator;
// colorize the blood!
if (bloodcolor != 0 && !(mo->flags2 & MF2_DONTTRANSLATE))
{
mo->Translation = TRANSLATION(TRANSLATION_Blood, bloodcolor.a);
}
if (!(bloodtype <= 1)) mo->renderflags |= RF_INVISIBLE;
}
if (bloodtype >= 1)
{
- fixed some particle positioning errors.
2016-04-10 08:57:48 +00:00
P_DrawSplash2(40, pos + add, hitangle - 180., 2, bloodcolor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, BloodSplatter)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_ANGLE(dir);
PARAM_BOOL_DEF(axe);
if (axe) P_BloodSplatter2(DVector3(x, y, z), self, dir);
else P_BloodSplatter(DVector3(x, y, z), self, dir);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// PROC P_RipperBlood
//
//---------------------------------------------------------------------------
void P_RipperBlood (AActor *mo, AActor *bleeder)
{
PalEntry bloodcolor = bleeder->GetBloodColor();
PClassActor *bloodcls = bleeder->GetBloodType();
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
double xo = pr_ripperblood.Random2() / 16.;
double yo = pr_ripperblood.Random2() / 16.;
double zo = pr_ripperblood.Random2() / 16.;
DVector3 pos = mo->Vec3Offset(xo, yo, zo);
Normalize line endings
2016-03-01 15:47:10 +00:00
int bloodtype = cl_bloodtype;
if (bloodcls != NULL && !(GetDefaultByType(bloodcls)->flags4 & MF4_ALLOWPARTICLES))
bloodtype = 0;
if (bloodcls != NULL)
{
AActor *th;
th = Spawn (bloodcls, pos, NO_REPLACE); // GetBloodType already performed the replacement
// [NG] Applying PUFFGETSOWNER to the blood will make it target the owner
if (th->flags5 & MF5_PUFFGETSOWNER) th->target = bleeder;
if (gameinfo.gametype == GAME_Heretic)
th->flags |= MF_NOGRAVITY;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
th->Vel.X = mo->Vel.X / 2;
th->Vel.Y = mo->Vel.Y / 2;
Normalize line endings
2016-03-01 15:47:10 +00:00
th->tics += pr_ripperblood () & 3;
// colorize the blood!
if (bloodcolor!=0 && !(th->flags2 & MF2_DONTTRANSLATE))
{
th->Translation = TRANSLATION(TRANSLATION_Blood, bloodcolor.a);
}
if (!(bloodtype <= 1)) th->renderflags |= RF_INVISIBLE;
}
if (bloodtype >= 1)
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
P_DrawSplash2(28, pos, bleeder->AngleTo(mo) + 180., 0, bloodcolor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//---------------------------------------------------------------------------
//
// FUNC P_GetThingFloorType
//
//---------------------------------------------------------------------------
int P_GetThingFloorType (AActor *thing)
{
if (thing->floorterrain >= 0)
{
return thing->floorterrain;
}
else
{
return thing->Sector->GetTerrain(sector_t::floor);
}
}
- scriptified Hexen's Bloodscourge and Serpent. - merged the FrontBlock searcher for the Bloodscourge into RoughMonsterSearch. This also fixes the bug that the searcher was not initialized properly for the MageBoss.
2016-11-27 23:49:10 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetFloorTerrain)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_POINTER(&Terrains[P_GetThingFloorType(self)]);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_HitWater
//
// Returns true if hit liquid and splashed, false if not.
//---------------------------------------------------------------------------
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
bool P_HitWater (AActor * thing, sector_t * sec, const DVector3 &pos, bool checkabove, bool alert, bool force)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (thing->flags3 & MF3_DONTSPLASH)
return false;
if (thing->player && (thing->player->cheats & CF_PREDICTING))
return false;
AActor *mo = NULL;
FSplashDef *splash;
int terrainnum;
sector_t *hsec = NULL;
// don't splash above the object
if (checkabove)
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
double compare_z = thing->Center();
Normalize line endings
2016-03-01 15:47:10 +00:00
// Missiles are typically small and fast, so they might
// end up submerged by the move that calls P_HitWater.
if (thing->flags & MF_MISSILE)
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
compare_z -= thing->Vel.Z;
if (pos.Z > compare_z)
Normalize line endings
2016-03-01 15:47:10 +00:00
return false;
}
#if 0 // needs some rethinking before activation
// This avoids spawning splashes on invisible self referencing sectors.
// For network consistency do this only in single player though because
// it is not guaranteed that all players have GL nodes loaded.
if (!multiplayer && thing->subsector->sector != thing->subsector->render_sector)
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
double zs = thing->subsector->sector->floorplane.ZatPoint(pos);
double zr = thing->subsector->render_sector->floorplane.ZatPoint(pos);
Normalize line endings
2016-03-01 15:47:10 +00:00
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
if (zs > zr && thing->Z() >= zs) return false;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
#endif
// 'force' means, we want this sector's terrain, no matter what.
if (!force)
{
for (unsigned int i = 0; i<sec->e->XFloor.ffloors.Size(); i++)
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
F3DFloor * rover = sec->e->XFloor.ffloors[i];
if (!(rover->flags & FF_EXISTS)) continue;
double planez = rover->top.plane->ZatPoint(pos);
if (pos.Z > planez - 0.5 && pos.Z < planez + 0.5) // allow minor imprecisions
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- enable terrain splashes for non-solid non-swimmable 3D floors.
2017-01-29 17:46:35 +00:00
if ((rover->flags & (FF_SOLID | FF_SWIMMABLE)) || rover->alpha > 0)
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
{
terrainnum = rover->model->GetTerrain(rover->top.isceiling);
goto foundone;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
planez = rover->bottom.plane->ZatPoint(pos);
if (planez < pos.Z && !(planez < thing->floorz)) return false;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
hsec = sec->GetHeightSec();
if (force || hsec == NULL || !(hsec->MoreFlags & SECF_CLIPFAKEPLANES))
{
terrainnum = sec->GetTerrain(sector_t::floor);
}
else
{
terrainnum = hsec->GetTerrain(sector_t::floor);
}
foundone:
int splashnum = Terrains[terrainnum].Splash;
bool smallsplash = false;
const secplane_t *plane;
if (splashnum == -1)
return Terrains[terrainnum].IsLiquid;
// don't splash when touching an underwater floor
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
if (thing->waterlevel >= 1 && pos.Z <= thing->floorz) return Terrains[terrainnum].IsLiquid;
Normalize line endings
2016-03-01 15:47:10 +00:00
plane = hsec != NULL? &sec->heightsec->floorplane : &sec->floorplane;
// Don't splash for living things with small vertical velocities.
// There are levels where the constant splashing from the monsters gets extremely annoying
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
if (((thing->flags3&MF3_ISMONSTER || thing->player) && thing->Vel.Z >= -6) && !force)
Normalize line endings
2016-03-01 15:47:10 +00:00
return Terrains[terrainnum].IsLiquid;
splash = &Splashes[splashnum];
// Small splash for small masses
if (thing->Mass < 10)
smallsplash = true;
if (smallsplash && splash->SmallSplash)
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
mo = Spawn (splash->SmallSplash, pos, ALLOW_REPLACE);
- floatified the sector plane movers and removed some of the ZatPoint conversion cruft.
2016-03-30 07:41:46 +00:00
if (mo) mo->Floorclip += splash->SmallSplashClip;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
if (splash->SplashChunk)
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
mo = Spawn (splash->SplashChunk, pos, ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
mo->target = thing;
if (splash->ChunkXVelShift != 255)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.X = (pr_chunk.Random2() << splash->ChunkXVelShift) / 65536.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (splash->ChunkYVelShift != 255)
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Y = (pr_chunk.Random2() << splash->ChunkYVelShift) / 65536.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
mo->Vel.Z = splash->ChunkBaseZVel + (pr_chunk() << splash->ChunkZVelShift) / 65536.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (splash->SplashBase)
{
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
mo = Spawn (splash->SplashBase, pos, ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (thing->player && !splash->NoAlert && alert)
{
P_NoiseAlert (thing, thing, true);
}
}
if (mo)
{
S_Sound (mo, CHAN_ITEM, smallsplash ?
splash->SmallSplashSound : splash->NormalSplashSound,
1, ATTN_IDLE);
}
else
{
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
S_Sound (pos, CHAN_ITEM, smallsplash ?
Normalize line endings
2016-03-01 15:47:10 +00:00
splash->SmallSplashSound : splash->NormalSplashSound,
1, ATTN_IDLE);
}
// Don't let deep water eat missiles
return plane == &sec->floorplane ? Terrains[terrainnum].IsLiquid : false;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, HitWater)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_POINTER_NOT_NULL(sec, sector_t);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL_DEF(checkabove);
PARAM_BOOL_DEF(alert);
PARAM_BOOL_DEF(force);
ACTION_RETURN_BOOL(P_HitWater(self, sec, DVector3(x, y, z), checkabove, alert, force));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_HitFloor
//
// Returns true if hit liquid and splashed, false if not.
//---------------------------------------------------------------------------
bool P_HitFloor (AActor *thing)
{
const msecnode_t *m;
// killough 11/98: touchy objects explode on impact
// Allow very short drops to be safe, so that a touchy can be summoned without exploding.
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
if (thing->flags6 & MF6_TOUCHY && ((thing->flags6 & MF6_ARMED) || thing->IsSentient()) && thing->Vel.Z < -5)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
thing->flags6 &= ~MF6_ARMED; // Disarm
P_DamageMobj (thing, NULL, NULL, thing->health, NAME_Crush, DMG_FORCED); // kill object
return false;
}
if (thing->flags3 & MF3_DONTSPLASH)
return false;
// don't splash if landing on the edge above water/lava/etc....
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
DVector3 pos;
Normalize line endings
2016-03-01 15:47:10 +00:00
for (m = thing->touching_sectorlist; m; m = m->m_tnext)
{
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
pos = thing->PosRelative(m->m_sector);
if (thing->Z() == m->m_sector->floorplane.ZatPoint(pos))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
break;
}
// Check 3D floors
for(unsigned int i=0;i<m->m_sector->e->XFloor.ffloors.Size();i++)
{
F3DFloor * rover = m->m_sector->e->XFloor.ffloors[i];
if (!(rover->flags & FF_EXISTS)) continue;
if (rover->flags & (FF_SOLID|FF_SWIMMABLE))
{
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
if (rover->top.plane->ZatPoint(pos) == thing->Z())
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- made adjustments to P_LineAttack and P_RailAttack to deal with altered angles by passing through a non-parallel portal. - fixed: P_FindFloorCeiling set the floorsector for a new ceilingheight. Note: P_DrawRailTrail still needs to be changed, at the moment rail trails through portals will not work correctly.
2016-03-06 20:58:36 +00:00
return P_HitWater (thing, m->m_sector, pos);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
}
if (m == NULL || m->m_sector->GetHeightSec() != NULL)
{
return false;
}
- made adjustments to P_LineAttack and P_RailAttack to deal with altered angles by passing through a non-parallel portal. - fixed: P_FindFloorCeiling set the floorsector for a new ceilingheight. Note: P_DrawRailTrail still needs to be changed, at the moment rail trails through portals will not work correctly.
2016-03-06 20:58:36 +00:00
return P_HitWater (thing, m->m_sector, pos);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
DEFINE_ACTION_FUNCTION(AActor, HitFloor)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_BOOL(P_HitFloor(self));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// P_CheckSplash
//
// Checks for splashes caused by explosions
//
//---------------------------------------------------------------------------
- converted most of g_heretic to float.
2016-03-20 15:51:42 +00:00
void P_CheckSplash(AActor *self, double distance)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
sector_t *floorsec;
- more floatification of p_map, plus some stuff used in those functions.
2016-03-27 00:06:54 +00:00
self->Sector->LowestFloorAt(self, &floorsec);
- conversion of floorz to double.
2016-03-20 18:52:35 +00:00
if (self->Z() <= self->floorz + distance && self->floorsector == floorsec && self->Sector->GetHeightSec() == NULL && floorsec->heightsec == NULL)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// 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
// behavior.
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
DVector3 pos = self->PosRelative(floorsec);
pos.Z = self->floorz;
- parameter rework of several spawning functions.
2016-03-23 12:31:12 +00:00
P_HitWater (self, floorsec, pos, false, false);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
//---------------------------------------------------------------------------
//
// FUNC P_CheckMissileSpawn
//
// Returns true if the missile is at a valid spawn point, otherwise
// explodes it and returns false.
//
//---------------------------------------------------------------------------
- made AActor::radius a double. This means that all files in g_doom are now fully converted.
2016-03-20 14:04:13 +00:00
bool P_CheckMissileSpawn (AActor* th, double maxdist)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// [RH] Don't decrement tics if they are already less than 1
if ((th->flags4 & MF4_RANDOMIZE) && th->tics > 0)
{
th->tics -= pr_checkmissilespawn() & 3;
if (th->tics < 1)
th->tics = 1;
}
if (maxdist > 0)
{
// move a little forward so an angle can be computed if it immediately explodes
- made AActor::radius a double. This means that all files in g_doom are now fully converted.
2016-03-20 14:04:13 +00:00
DVector3 advance = th->Vel;
double maxsquared = maxdist*maxdist;
Normalize line endings
2016-03-01 15:47:10 +00:00
// Keep halving the advance vector until we get something less than maxdist
// units away, since we still want to spawn the missile inside the shooter.
do
{
advance *= 0.5f;
}
- made AActor::radius a double. This means that all files in g_doom are now fully converted.
2016-03-20 14:04:13 +00:00
while (advance.XY().LengthSquared() >= maxsquared);
th->SetXYZ(th->Pos() + advance);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
FCheckPosition tm(!!(th->flags2 & MF2_RIP));
// killough 8/12/98: for non-missile objects (e.g. grenades)
//
// [GZ] MBF excludes non-missile objects from the P_TryMove test
// and subsequent potential P_ExplodeMissile call. That is because
// in MBF, a projectile is not an actor with the MF_MISSILE flag
// but an actor with either or both the MF_MISSILE and MF_BOUNCES
// flags, and a grenade is identified by not having MF_MISSILE.
// Killough wanted grenades not to explode directly when spawned,
// therefore they can be fired safely even when humping a wall as
// they will then just drop on the floor at their shooter's feet.
//
// However, ZDoom does allow non-missiles to be shot as well, so
// Killough's check for non-missiles is inadequate here. So let's
// replace it by a check for non-missile and MBF bounce type.
// This should allow MBF behavior where relevant without altering
// established ZDoom behavior for crazy stuff like a cacodemon cannon.
bool MBFGrenade = (!(th->flags & MF_MISSILE) || (th->BounceFlags & BOUNCE_MBF));
// killough 3/15/98: no dropoff (really = don't care for missiles)
- floatified P_TryMove and the sliding and bouncing code.
2016-03-27 11:29:58 +00:00
if (!(P_TryMove (th, th->Pos(), false, NULL, tm, true)))
Normalize line endings
2016-03-01 15:47:10 +00:00
{
// [RH] Don't explode ripping missiles that spawn inside something
if (th->BlockingMobj == NULL || !(th->flags2 & MF2_RIP) || (th->BlockingMobj->flags5 & MF5_DONTRIP))
{
- address bad use of pitch in A_CustomMissile. This function calculated everything correctly but ultimately set the vertical velocity wrong. Most importantly this meant that the actual velocity vector and actor pitch - if CMF_SAVEPITCH was used - did not match. Since this bug has been present since the pitch parameter was added, this deprecates A_CustomMissile and replaces it with a properly implemented A_SpawnProjectile function and handling the compatibility case with a new flag and a scripted wrapper function. All internal uses of A_CustomMissile have been replaced as well.
2016-12-24 13:46:34 +00:00
// If this is a monster spawned by A_SpawnProjectile subtract it from the counter.
Normalize line endings
2016-03-01 15:47:10 +00:00
th->ClearCounters();
// [RH] Don't explode missiles that spawn on top of horizon lines
if (th->BlockingLine != NULL && th->BlockingLine->special == Line_Horizon)
{
th->Destroy ();
}
else if (MBFGrenade && th->BlockingLine != NULL)
{
P_BounceWall(th);
}
else
{
P_ExplodeMissile (th, NULL, th->BlockingMobj);
}
return false;
}
}
th->ClearInterpolation();
return true;
}
- scriptified a_hereticmisc.cpp.
2016-11-18 20:34:06 +00:00
DEFINE_ACTION_FUNCTION(AActor, CheckMissileSpawn)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(add);
ACTION_RETURN_BOOL(P_CheckMissileSpawn(self, add));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_PlaySpawnSound
//
// Plays a missiles spawn sound. Location depends on the
// MF_SPAWNSOUNDSOURCE flag.
//
//---------------------------------------------------------------------------
void P_PlaySpawnSound(AActor *missile, AActor *spawner)
{
if (missile->SeeSound != 0)
{
if (!(missile->flags & MF_SPAWNSOUNDSOURCE))
{
S_Sound (missile, CHAN_VOICE, missile->SeeSound, 1, ATTN_NORM);
}
else if (spawner != NULL)
{
S_Sound (spawner, CHAN_WEAPON, missile->SeeSound, 1, ATTN_NORM);
}
else
{
// If there is no spawner use the spawn position.
// But not in a silenced sector.
if (!(missile->Sector->Flags & SECF_SILENT))
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
S_Sound (missile->Pos(), CHAN_WEAPON, missile->SeeSound, 1, ATTN_NORM);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, PlaySpawnSound)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(missile, AActor);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
P_PlaySpawnSound(missile, self);
return 0;
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
static double GetDefaultSpeed(PClassActor *type)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (type == NULL)
return 0;
else if (G_SkillProperty(SKILLP_FastMonsters) && type->FastSpeed >= 0)
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
return type->FastSpeed;
Normalize line endings
2016-03-01 15:47:10 +00:00
else
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
return GetDefaultByType(type)->Speed;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- scriptified Heretic's wizard.
2016-11-11 22:32:13 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetDefaultSpeed)
{
PARAM_PROLOGUE;
PARAM_CLASS(type, AActor);
ACTION_RETURN_FLOAT(GetDefaultSpeed(type));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_SpawnMissile
//
// Returns NULL if the missile exploded immediately, otherwise returns
// a mobj_t pointer to the missile.
//
//---------------------------------------------------------------------------
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
AActor *P_SpawnMissileXYZ (DVector3 pos, AActor *source, AActor *dest, PClassActor *type, bool checkspawn, AActor *owner)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (dest == NULL)
{
Printf ("P_SpawnMissilyXYZ: Tried to shoot %s from %s with no dest\n",
type->TypeName.GetChars(), source->GetClass()->TypeName.GetChars());
return NULL;
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
if (pos.Z != ONFLOORZ && pos.Z != ONCEILINGZ)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
pos.Z -= source->Floorclip;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
AActor *th = Spawn (type, pos, ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
P_PlaySpawnSound(th, source);
// record missile's originator
if (owner == NULL) owner = source;
th->target = owner;
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double speed = th->Speed;
Normalize line endings
2016-03-01 15:47:10 +00:00
// [RH]
// Hexen calculates the missile velocity based on the source's location.
// Would it be more useful to base it on the actual position of the
// missile?
// Answer: No, because this way, you can set up sets of parallel missiles.
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
DVector3 velocity = source->Vec3To(dest);
Normalize line endings
2016-03-01 15:47:10 +00:00
// Floor and ceiling huggers should never have a vertical component to their velocity
if (th->flags3 & (MF3_FLOORHUGGER|MF3_CEILINGHUGGER))
{
velocity.Z = 0;
}
// [RH] Adjust the trajectory if the missile will go over the target's head.
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
else if (pos.Z - source->Z() >= dest->Height)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
velocity.Z += (dest->Height - pos.Z + source->Z());
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
th->Vel = velocity.Resized(speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
// invisible target: rotate velocity vector in 2D
// [RC] Now monsters can aim at invisible player as if they were fully visible.
if (dest->flags & MF_SHADOW && !(source->flags6 & MF6_SEEINVISIBLE))
{
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
DAngle an = pr_spawnmissile.Random2() * (22.5 / 256);
double c = an.Cos();
double s = an.Sin();
Normalize line endings
2016-03-01 15:47:10 +00:00
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double newx = th->Vel.X * c - th->Vel.Y * s;
double newy = th->Vel.X * s + th->Vel.Y * c;
th->Vel.X = newx;
th->Vel.Y = newy;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
th->AngleFromVel();
Normalize line endings
2016-03-01 15:47:10 +00:00
if (th->flags4 & MF4_SPECTRAL)
{
th->SetFriendPlayer(owner->player);
}
return (!checkspawn || P_CheckMissileSpawn (th, source->radius)) ? th : NULL;
}
- scriptified the IceGuy.
2016-11-26 23:41:06 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnMissileXYZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(dest, AActor);
- scriptified the IceGuy.
2016-11-26 23:41:06 +00:00
PARAM_CLASS(type, AActor);
PARAM_BOOL_DEF(check);
PARAM_OBJECT_DEF(owner, AActor);
ACTION_RETURN_OBJECT(P_SpawnMissileXYZ(DVector3(x,y,z), self, dest, type, check, owner));
}
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
AActor *P_SpawnMissile(AActor *source, AActor *dest, PClassActor *type, AActor *owner)
{
if (source == nullptr)
{
return nullptr;
}
return P_SpawnMissileXYZ(source->PosPlusZ(32 + source->GetBobOffset()), source, dest, type, true, owner);
}
DEFINE_ACTION_FUNCTION(AActor, SpawnMissile)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT_NOT_NULL(dest, AActor);
PARAM_CLASS(type, AActor);
PARAM_OBJECT_DEF(owner, AActor);
ACTION_RETURN_OBJECT(P_SpawnMissile(self, dest, type, owner));
}
AActor *P_SpawnMissileZ(AActor *source, double z, AActor *dest, PClassActor *type)
{
if (source == nullptr)
{
return nullptr;
}
return P_SpawnMissileXYZ(source->PosAtZ(z), source, dest, type);
}
DEFINE_ACTION_FUNCTION(AActor, SpawnMissileZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(z);
PARAM_OBJECT_NOT_NULL(dest, AActor);
PARAM_CLASS(type, AActor);
ACTION_RETURN_OBJECT(P_SpawnMissileZ(self, z, dest, type));
}
- scriptified the IceGuy.
2016-11-26 23:41:06 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
AActor *P_OldSpawnMissile(AActor *source, AActor *owner, AActor *dest, PClassActor *type)
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- trimmed down the AActor Spawn interface and removed all non-float variants. This still needs some cleanup in a few calling functions.
2016-03-23 09:42:41 +00:00
AActor *th = Spawn (type, source->PosPlusZ(32.), ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
P_PlaySpawnSound(th, source);
th->target = owner; // record missile's originator
- renamed some functions and fixed a few more conversion errors.
2016-03-16 23:07:37 +00:00
th->Angles.Yaw = source->AngleTo(dest);
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
th->VelFromAngle();
Normalize line endings
2016-03-01 15:47:10 +00:00
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double dist = source->DistanceBySpeed(dest, MAX(1., th->Speed));
th->Vel.Z = (dest->Z() - source->Z()) / dist;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (th->flags4 & MF4_SPECTRAL)
{
th->SetFriendPlayer(owner->player);
}
P_CheckMissileSpawn(th, source->radius);
return th;
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
DEFINE_ACTION_FUNCTION(AActor, OldSpawnMissile)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(dest, AActor);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
PARAM_CLASS(type, AActor);
PARAM_OBJECT_DEF(owner, AActor);
ACTION_RETURN_OBJECT(P_OldSpawnMissile(self, owner, dest, type));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_SpawnMissileAngle
//
// Returns NULL if the missile exploded immediately, otherwise returns
// a mobj_t pointer to the missile.
//
//---------------------------------------------------------------------------
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
AActor *P_SpawnMissileAngle (AActor *source, PClassActor *type, DAngle angle, double vz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return NULL;
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
return P_SpawnMissileAngleZSpeed (source, source->Z() + 32 + source->GetBobOffset(), type, angle, vz, GetDefaultSpeed (type));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
AActor *P_SpawnMissileAngleZ (AActor *source, double z, PClassActor *type, DAngle angle, double vz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (type == nullptr)
{
return nullptr;
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
return P_SpawnMissileAngleZSpeed (source, z, type, angle, vz, GetDefaultSpeed (type));
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
AActor *P_SpawnMissileZAimed (AActor *source, double z, AActor *dest, PClassActor *type)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
DAngle an;
double dist;
double speed;
double vz;
Normalize line endings
2016-03-01 15:47:10 +00:00
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
an = source->Angles.Yaw;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (dest->flags & MF_SHADOW)
{
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
an += pr_spawnmissile.Random2() * (16. / 360.);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
dist = source->Distance2D (dest);
- floatified p_sight.cpp.
2016-03-28 14:22:21 +00:00
speed = GetDefaultSpeed (type);
Normalize line endings
2016-03-01 15:47:10 +00:00
dist /= speed;
- floatified more of p_mobj.cpp
2016-03-28 08:01:24 +00:00
vz = dist != 0 ? (dest->Z() - source->Z())/dist : speed;
- made AActor::velx/y/z and player_t::velx/y fixedvec's. (This commit is 95% search & replace with only a few places where velz was used as a local variable changed.)
2016-03-12 13:11:43 +00:00
return P_SpawnMissileAngleZSpeed (source, z, type, an, vz, speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- scriptified the Crusader.
2016-11-28 17:36:13 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnMissileZAimed)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(z);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(dest, AActor);
- scriptified the Crusader.
2016-11-28 17:36:13 +00:00
PARAM_CLASS(type, AActor);
ACTION_RETURN_OBJECT(P_SpawnMissileZAimed(self, z, dest, type));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//---------------------------------------------------------------------------
//
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
// FUNC P_SpawnMissileAngleZSpeed
Normalize line endings
2016-03-01 15:47:10 +00:00
//
// Returns NULL if the missile exploded immediately, otherwise returns
// a mobj_t pointer to the missile.
//
//---------------------------------------------------------------------------
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
AActor *P_SpawnMissileAngleZSpeed (AActor *source, double z,
PClassActor *type, DAngle angle, double vz, double speed, AActor *owner, bool checkspawn)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
return nullptr;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
AActor *mo;
if (z != ONFLOORZ && z != ONCEILINGZ)
{
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
z -= source->Floorclip;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
mo = Spawn (type, source->PosAtZ(z), ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
P_PlaySpawnSound(mo, source);
if (owner == NULL) owner = source;
mo->target = owner;
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
mo->Angles.Yaw = angle;
mo->VelFromAngle(speed);
mo->Vel.Z = vz;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (mo->flags4 & MF4_SPECTRAL)
{
mo->SetFriendPlayer(owner->player);
}
return (!checkspawn || P_CheckMissileSpawn(mo, source->radius)) ? mo : NULL;
}
- scriptified Heretic's wizard.
2016-11-11 22:32:13 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnMissileAngleZSpeed)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(z);
PARAM_CLASS(type, AActor);
PARAM_ANGLE(angle);
PARAM_FLOAT(vz);
PARAM_FLOAT(speed);
PARAM_OBJECT_DEF(owner, AActor);
PARAM_BOOL_DEF(checkspawn);
ACTION_RETURN_OBJECT(P_SpawnMissileAngleZSpeed(self, z, type, angle, vz, speed, owner, checkspawn));
}
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
AActor *P_SpawnSubMissile(AActor *source, PClassActor *type, AActor *target)
{
AActor *other = Spawn(type, source->Pos(), ALLOW_REPLACE);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
return nullptr;
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
}
other->target = target;
other->Angles.Yaw = source->Angles.Yaw;
other->VelFromAngle();
if (other->flags4 & MF4_SPECTRAL)
{
if (source->flags & MF_MISSILE && source->flags4 & MF4_SPECTRAL)
{
other->FriendPlayer = source->FriendPlayer;
}
else
{
other->SetFriendPlayer(target->player);
}
}
if (P_CheckMissileSpawn(other, source->radius))
{
DAngle pitch = P_AimLineAttack(source, source->Angles.Yaw, 1024.);
other->Vel.Z = -other->Speed * pitch.Sin();
return other;
}
return NULL;
}
DEFINE_ACTION_FUNCTION(AActor, SpawnSubMissile)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(cls, AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(target, AActor);
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
ACTION_RETURN_OBJECT(P_SpawnSubMissile(self, cls, target));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
/*
================
=
= P_SpawnPlayerMissile
=
= Tries to aim at a nearby monster
================
*/
AActor *P_SpawnPlayerMissile (AActor *source, PClassActor *type)
{
if (source == NULL)
{
return NULL;
}
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
return P_SpawnPlayerMissile (source, 0, 0, 0, type, source->Angles.Yaw);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
AActor *P_SpawnPlayerMissile (AActor *source, PClassActor *type, DAngle angle)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
return P_SpawnPlayerMissile (source, 0, 0, 0, type, angle);
}
- fixed some leftover fixed point remnants in g_hexen. - made the full-coordinate version of P_SpawnPlayerMissile use float coordinates.
2016-03-21 23:30:56 +00:00
AActor *P_SpawnPlayerMissile (AActor *source, double x, double y, double z,
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
PClassActor *type, DAngle angle, FTranslatedLineTarget *pLineTarget, AActor **pMissileActor,
Normalize line endings
2016-03-01 15:47:10 +00:00
bool nofreeaim, bool noautoaim, int aimflags)
{
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
if (source == nullptr || type == nullptr)
{
return nullptr;
}
- fixed: P_SpawnPlayerMissile still used the angle_t values for offsetting the autoaim traces.
2016-04-07 11:11:23 +00:00
static const double angdiff[3] = { -5.625, 5.625, 0 };
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
DAngle an = angle;
DAngle pitch;
Normalize line endings
2016-03-01 15:47:10 +00:00
FTranslatedLineTarget scratch;
AActor *defaultobject = GetDefaultByType(type);
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
DAngle vrange = nofreeaim ? 35. : 0.;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (!pLineTarget) pLineTarget = &scratch;
if (source->player && source->player->ReadyWeapon && ((source->player->ReadyWeapon->WeaponFlags & WIF_NOAUTOAIM) || noautoaim))
{
// Keep exactly the same angle and pitch as the player's own aim
an = angle;
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
pitch = source->Angles.Pitch;
Normalize line endings
2016-03-01 15:47:10 +00:00
pLineTarget->linetarget = NULL;
}
else // see which target is to be aimed at
{
// [XA] If MaxTargetRange is defined in the spawned projectile, use this as the
// maximum range for the P_AimLineAttack call later; this allows MaxTargetRange
// to function as a "maximum tracer-acquisition range" for seeker missiles.
- floatified MaxTargetRange and MeleeThreshold.
2016-03-24 19:56:59 +00:00
double linetargetrange = defaultobject->maxtargetrange > 0 ? defaultobject->maxtargetrange*64 : 16*64.;
Normalize line endings
2016-03-01 15:47:10 +00:00
int i = 2;
do
{
an = angle + angdiff[i];
pitch = P_AimLineAttack (source, an, linetargetrange, pLineTarget, vrange, aimflags);
if (source->player != NULL &&
!nofreeaim &&
level.IsFreelookAllowed() &&
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
source->player->userinfo.GetAimDist() <= 0.5)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
break;
}
} while (pLineTarget->linetarget == NULL && --i >= 0);
if (pLineTarget->linetarget == NULL)
{
an = angle;
if (nofreeaim || !level.IsFreelookAllowed())
{
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
pitch = 0.;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
}
if (z != ONFLOORZ && z != ONCEILINGZ)
{
// Doom spawns missiles 4 units lower than hitscan attacks for players.
- fixed some leftover fixed point remnants in g_hexen. - made the full-coordinate version of P_SpawnPlayerMissile use float coordinates.
2016-03-21 23:30:56 +00:00
z += source->Center() - source->Floorclip;
Normalize line endings
2016-03-01 15:47:10 +00:00
if (source->player != NULL) // Considering this is for player missiles, it better not be NULL.
{
- floatified the remaining fixed point variables accessible through DECORATE. PROP_FIXED_PARAM is no longer used anywhere.
2016-03-24 22:50:29 +00:00
z += ((source->player->mo->AttackZOffset - 4) * source->player->crouchfactor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
else
{
- fixed some leftover fixed point remnants in g_hexen. - made the full-coordinate version of P_SpawnPlayerMissile use float coordinates.
2016-03-21 23:30:56 +00:00
z += 4;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
// Do not fire beneath the floor.
- fixed some leftover fixed point remnants in g_hexen. - made the full-coordinate version of P_SpawnPlayerMissile use float coordinates.
2016-03-21 23:30:56 +00:00
if (z < source->floorz)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- fixed some leftover fixed point remnants in g_hexen. - made the full-coordinate version of P_SpawnPlayerMissile use float coordinates.
2016-03-21 23:30:56 +00:00
z = source->floorz;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- fixed some leftover fixed point remnants in g_hexen. - made the full-coordinate version of P_SpawnPlayerMissile use float coordinates.
2016-03-21 23:30:56 +00:00
DVector3 pos = source->Vec2OffsetZ(x, y, z);
AActor *MissileActor = Spawn (type, pos, ALLOW_REPLACE);
Normalize line endings
2016-03-01 15:47:10 +00:00
if (pMissileActor) *pMissileActor = MissileActor;
P_PlaySpawnSound(MissileActor, source);
MissileActor->target = source;
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
MissileActor->Angles.Yaw = an;
- first stage of converting actor angles to float complete Patched up everything so that it compiles without errors again. This only addresses code related to some compile error. A large portion of the angle code still uses angle_t and converts back and forth.
2016-03-16 11:41:26 +00:00
if (MissileActor->flags3 & (MF3_FLOORHUGGER | MF3_CEILINGHUGGER))
{
MissileActor->VelFromAngle();
}
else
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- reworked calls to P_SpawnPlayerMissile, P_AimLineAttack and P_LineAttack to use floating point angles.
2016-03-17 10:38:56 +00:00
MissileActor->Vel3DFromAngle(pitch, MissileActor->Speed);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
if (MissileActor->flags4 & MF4_SPECTRAL)
{
MissileActor->SetFriendPlayer(source->player);
}
if (P_CheckMissileSpawn (MissileActor, source->radius))
{
return MissileActor;
}
return NULL;
}
- scriptified the Rocket launcher.
2016-11-20 00:11:01 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnPlayerMissile)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_CLASS(type, AActor);
PARAM_ANGLE_DEF(angle);
PARAM_FLOAT_DEF(x);
PARAM_FLOAT_DEF(y);
PARAM_FLOAT_DEF(z);
PARAM_POINTER_DEF(lt, FTranslatedLineTarget);
PARAM_BOOL_DEF(nofreeaim);
PARAM_BOOL_DEF(noautoaim);
PARAM_INT_DEF(aimflags);
AActor *missileactor;
if (numparam == 2) angle = self->Angles.Yaw;
AActor *misl = P_SpawnPlayerMissile(self, x, y, z, type, angle, lt, &missileactor, nofreeaim, noautoaim, aimflags);
if (numret > 0) ret[0].SetPointer(misl, ATAG_OBJECT);
if (numret > 1) ret[1].SetPointer(missileactor, ATAG_OBJECT), numret = 2;
return numret;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
int AActor::GetTeam()
{
if (player)
{
return player->userinfo.GetTeam();
}
int myTeam = DesignatedTeam;
// Check for monsters that belong to a player on the team but aren't part of the team themselves.
if (myTeam == TEAM_NONE && FriendPlayer != 0)
{
myTeam = players[FriendPlayer - 1].userinfo.GetTeam();
}
return myTeam;
}
bool AActor::IsTeammate (AActor *other)
{
if (!other)
{
return false;
}
else if (!deathmatch && player && other->player)
{
return true;
}
else if (teamplay)
{
int myTeam = GetTeam();
int otherTeam = other->GetTeam();
return (myTeam != TEAM_NONE && myTeam == otherTeam);
}
return false;
}
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
DEFINE_ACTION_FUNCTION(AActor, isTeammate)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(other, AActor);
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
ACTION_RETURN_BOOL(self->IsTeammate(other));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor :: GetSpecies
//
// Species is defined as the lowest base class that is a monster
// with no non-monster class in between. If the actor specifies an explicit
// species (i.e. not 'None'), that is used. This is virtualized, so special
// monsters can change this behavior if they like.
//
//==========================================================================
FName AActor::GetSpecies()
{
if (Species != NAME_None)
{
return Species;
}
PClassActor *thistype = GetClass();
if (GetDefaultByType(thistype)->flags3 & MF3_ISMONSTER)
{
while (thistype->ParentClass)
{
if (GetDefaultByType(thistype->ParentClass)->flags3 & MF3_ISMONSTER)
thistype = static_cast<PClassActor *>(thistype->ParentClass);
else
break;
}
}
return Species = thistype->TypeName; // [GZ] Speeds up future calls.
}
- fixed damage handling in A_BetaSkullAttack. For unknown reasons this completely bypassed the normal damage function semantics and even multiplied that with a random value. - made some tests about calling script code from native functions. * scriptified A_SkullAttack to have something to test * changed the A_SkullAttack call in A_PainShootSkull. * use a macro to declare the function pointer. Using local static variable init directly results in hideous code for the need of being thread-safe (which, even if the engine was made multithreaded is not needed here.) * Importsnt node here: Apparently passing an actor pointer to the VMValue constructor results in the void * version being called, not the DObject * version.
2016-11-06 10:36:12 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetSpecies)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_INT(self->GetSpecies());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor :: IsFriend
//
// Checks if two monsters have to be considered friendly.
//
//==========================================================================
bool AActor::IsFriend (AActor *other)
{
if (flags & other->flags & MF_FRIENDLY)
{
if (deathmatch && teamplay)
return IsTeammate(other) ||
(FriendPlayer != 0 && other->FriendPlayer != 0 &&
players[FriendPlayer-1].mo->IsTeammate(players[other->FriendPlayer-1].mo));
return !deathmatch ||
FriendPlayer == other->FriendPlayer ||
FriendPlayer == 0 ||
other->FriendPlayer == 0 ||
players[FriendPlayer-1].mo->IsTeammate(players[other->FriendPlayer-1].mo);
}
return false;
}
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
DEFINE_ACTION_FUNCTION(AActor, isFriend)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(other, AActor);
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
ACTION_RETURN_BOOL(self->IsFriend(other));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
//==========================================================================
//
// AActor :: IsHostile
//
// Checks if two monsters have to be considered hostile under any circumstances
//
//==========================================================================
bool AActor::IsHostile (AActor *other)
{
// Both monsters are non-friendlies so hostilities depend on infighting settings
if (!((flags | other->flags) & MF_FRIENDLY)) return false;
// Both monsters are friendly and belong to the same player if applicable.
if (flags & other->flags & MF_FRIENDLY)
{
if (deathmatch && teamplay)
return !IsTeammate(other) &&
!(FriendPlayer != 0 && other->FriendPlayer != 0 &&
players[FriendPlayer-1].mo->IsTeammate(players[other->FriendPlayer-1].mo));
return deathmatch &&
FriendPlayer != other->FriendPlayer &&
FriendPlayer !=0 &&
other->FriendPlayer != 0 &&
!players[FriendPlayer-1].mo->IsTeammate(players[other->FriendPlayer-1].mo);
}
return true;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, isHostile)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(other, AActor);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
ACTION_RETURN_BOOL(self->IsHostile(other));
}
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
//==========================================================================
//
// AActor :: DoSpecialDamage
//
// override this for special damage effects.
//
//==========================================================================
Normalize line endings
2016-03-01 15:47:10 +00:00
int AActor::DoSpecialDamage (AActor *target, int damage, FName damagetype)
{
if (target->player && target->player->mo == target && damage < 1000 &&
(target->player->cheats & CF_GODMODE || target->player->cheats & CF_GODMODE2))
{
return -1;
}
else
{
if (target->player)
{
// Only do this for old style poison damage.
if (PoisonDamage > 0 && PoisonDuration == INT_MIN)
{
P_PoisonPlayer (target->player, this, this->target, PoisonDamage);
damage >>= 1;
}
}
return damage;
}
}
- scriptified the Ironlich.
2016-11-23 20:26:59 +00:00
DEFINE_ACTION_FUNCTION(AActor, DoSpecialDamage)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(target, AActor);
- scriptified the Ironlich.
2016-11-23 20:26:59 +00:00
PARAM_INT(damage);
PARAM_NAME(damagetype);
ACTION_RETURN_INT(self->DoSpecialDamage(target, damage, damagetype));
}
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
int AActor::CallDoSpecialDamage(AActor *target, int damage, FName damagetype)
{
IFVIRTUAL(AActor, DoSpecialDamage)
{
// Without the type cast this picks the 'void *' assignment...
VMValue params[4] = { (DObject*)this, (DObject*)target, damage, damagetype.GetIndex() };
VMReturn ret;
int retval;
ret.IntAt(&retval);
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 4, &ret, 1, nullptr);
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
return retval;
}
else return DoSpecialDamage(target, damage, damagetype);
}
//==========================================================================
//
// AActor :: TakeSpecialDamage
//
//==========================================================================
- scriptified the Ironlich.
2016-11-23 20:26:59 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
int AActor::TakeSpecialDamage (AActor *inflictor, AActor *source, int damage, FName damagetype)
{
FState *death;
// If the actor does not have a corresponding death state, then it does not take damage.
// Note that DeathState matches every kind of damagetype, so an actor has that, it can
// be hurt with any type of damage. Exception: Massacre damage always succeeds, because
// it needs to work.
// Always kill if there is a regular death state or no death states at all.
if (FindState (NAME_Death) != NULL || !HasSpecialDeathStates() || damagetype == NAME_Massacre)
{
return damage;
}
if (inflictor && inflictor->DeathType != NAME_None)
damagetype = inflictor->DeathType;
if (damagetype == NAME_Ice)
{
death = FindState (NAME_Death, NAME_Ice, true);
if (death == NULL && !deh.NoAutofreeze && !(flags4 & MF4_NOICEDEATH) &&
(player || (flags3 & MF3_ISMONSTER)))
{
death = FindState(NAME_GenericFreezeDeath);
}
}
else
{
death = FindState (NAME_Death, damagetype);
}
return (death == NULL) ? -1 : damage;
}
- converted the rest of a_strifestuff.cpp. - changed some very old A_Explode calls which passed all values as integer literals.
2016-11-28 23:16:30 +00:00
DEFINE_ACTION_FUNCTION(AActor, TakeSpecialDamage)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_OBJECT(inflictor, AActor);
PARAM_OBJECT(source, AActor);
PARAM_INT(damage);
PARAM_NAME(damagetype);
ACTION_RETURN_INT(self->TakeSpecialDamage(inflictor, source, damage, damagetype));
}
int AActor::CallTakeSpecialDamage(AActor *inflictor, AActor *source, int damage, FName damagetype)
{
IFVIRTUAL(AActor, TakeSpecialDamage)
{
VMValue params[5] = { (DObject*)this, inflictor, source, damage, damagetype.GetIndex() };
VMReturn ret;
int retval;
ret.IntAt(&retval);
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
GlobalVMStack.Call(func, params, 5, &ret, 1, nullptr);
- converted the rest of a_strifestuff.cpp. - changed some very old A_Explode calls which passed all values as integer literals.
2016-11-28 23:16:30 +00:00
return retval;
}
else return TakeSpecialDamage(inflictor, source, damage, damagetype);
}
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::Crash()
{
// [RC] Weird that this forces the Crash state regardless of flag.
if(!(flags6 & MF6_DONTCORPSE))
{
if (((flags & MF_CORPSE) || (flags6 & MF6_KILLED)) &&
!(flags3 & MF3_CRASHED) &&
!(flags & MF_ICECORPSE))
{
FState *crashstate = NULL;
if (DamageType != NAME_None)
{
if (health < GetGibHealth())
{ // Extreme death
FName labels[] = { NAME_Crash, NAME_Extreme, DamageType };
crashstate = FindState (3, labels, true);
}
if (crashstate == NULL)
{ // Normal death
crashstate = FindState(NAME_Crash, DamageType, true);
}
}
if (crashstate == NULL)
{
if (health < GetGibHealth())
{ // Extreme death
crashstate = FindState(NAME_Crash, NAME_Extreme);
}
else
{ // Normal death
crashstate = FindState(NAME_Crash);
}
}
if (crashstate != NULL) SetState(crashstate);
// Set MF3_CRASHED regardless of the presence of a crash state
// so this code doesn't have to be executed repeatedly.
flags3 |= MF3_CRASHED;
}
}
}
void AActor::SetIdle(bool nofunction)
{
FState *idle = FindState (NAME_Idle);
if (idle == NULL) idle = SpawnState;
SetState(idle, nofunction);
}
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetIdle)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_BOOL_DEF(nofunction);
self->SetIdle(nofunction);
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
int AActor::SpawnHealth() const
{
int defhealth = StartHealth ? StartHealth : GetDefault()->health;
if (!(flags3 & MF3_ISMONSTER) || defhealth == 0)
{
return defhealth;
}
else if (flags & MF_FRIENDLY)
{
- floatification of g_shared. - rewrote FraggleScript's movecamera function because it was utterly incomprehensible.
2016-03-24 00:46:11 +00:00
int adj = int(defhealth * G_SkillProperty(SKILLP_FriendlyHealth));
Normalize line endings
2016-03-01 15:47:10 +00:00
return (adj <= 0) ? 1 : adj;
}
else
{
- floatification of g_shared. - rewrote FraggleScript's movecamera function because it was utterly incomprehensible.
2016-03-24 00:46:11 +00:00
int adj = int(defhealth * G_SkillProperty(SKILLP_MonsterHealth));
Normalize line endings
2016-03-01 15:47:10 +00:00
return (adj <= 0) ? 1 : adj;
}
}
- scriptified D'Sparil. - added retrieval of defaults from an actor pointer.
2016-11-24 00:23:35 +00:00
DEFINE_ACTION_FUNCTION(AActor, SpawnHealth)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_INT(self->SpawnHealth());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
FState *AActor::GetRaiseState()
{
if (!(flags & MF_CORPSE))
{
return NULL; // not a monster
}
if (tics != -1 && // not lying still yet
!state->GetCanRaise()) // or not ready to be raised yet
{
return NULL;
}
if (IsKindOf(RUNTIME_CLASS(APlayerPawn)))
{
return NULL; // do not resurrect players
}
return FindState(NAME_Raise);
}
void AActor::Revive()
{
AActor *info = GetDefault();
flags = info->flags;
flags2 = info->flags2;
flags3 = info->flags3;
flags4 = info->flags4;
flags5 = info->flags5;
flags6 = info->flags6;
flags7 = info->flags7;
- fixed: monsters which were made friendly by the MBF map flag lost their friendliness when being revived with Thing_Raise.
2016-08-04 15:14:31 +00:00
if (SpawnFlags & MTF_FRIENDLY) flags |= MF_FRIENDLY;
Normalize line endings
2016-03-01 15:47:10 +00:00
DamageType = info->DamageType;
health = SpawnHealth();
target = NULL;
lastenemy = NULL;
// [RH] If it's a monster, it gets to count as another kill
if (CountsAsKill())
{
level.total_monsters++;
}
}
int AActor::GetGibHealth() const
{
int gibhealth = GetClass()->GibHealth;
if (gibhealth != INT_MIN)
{
return -abs(gibhealth);
}
else
{
- floatification of G_CheckSpot and a few other things.
2016-03-26 08:28:00 +00:00
return -int(SpawnHealth() * gameinfo.gibfactor);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
double AActor::GetCameraHeight() const
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- converted AActor::height to double.
2016-03-20 19:55:06 +00:00
return GetClass()->CameraHeight == INT_MIN ? Height / 2 : GetClass()->CameraHeight;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetCameraHeight)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_FLOAT(self->GetCameraHeight());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
DDropItem *AActor::GetDropItems() const
{
return GetClass()->DropItems;
}
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetDropItems)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_OBJECT(self->GetDropItems());
}
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
double AActor::GetGravity() const
Normalize line endings
2016-03-01 15:47:10 +00:00
{
if (flags & MF_NOGRAVITY) return 0;
- made AActor::gravity and FMapThing::gravity floats.
2016-03-20 23:51:19 +00:00
return level.gravity * Sector->gravity * Gravity * 0.00125;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetGravity)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_FLOAT(self->GetGravity());
}
Normalize line endings
2016-03-01 15:47:10 +00:00
// killough 11/98:
// Whether an object is "sentient" or not. Used for environmental influences.
// (left precisely the same as MBF even though it doesn't make much sense.)
bool AActor::IsSentient() const
{
return health > 0 && SeeState != NULL;
}
FSharedStringArena AActor::mStringPropertyData;
const char *AActor::GetTag(const char *def) const
{
if (Tag != NULL)
{
const char *tag = Tag->GetChars();
if (tag[0] == '$')
{
return GStrings(tag + 1);
}
else
{
return tag;
}
}
else if (def)
{
return def;
}
else
{
return GetClass()->TypeName.GetChars();
}
}
- implemented code generation for stack variables. - fixed code generation for using local variables as array index. This must use a different register for the array element offset because the original register may not be overwritten.
2016-11-17 15:44:41 +00:00
DEFINE_ACTION_FUNCTION(AActor, GetTag)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_STRING(def);
ACTION_RETURN_STRING(self->GetTag(def.Len() == 0? nullptr : def.GetChars()));
}
Normalize line endings
2016-03-01 15:47:10 +00:00
void AActor::SetTag(const char *def)
{
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
if (def == NULL || *def == 0) Tag = nullptr;
else Tag = mStringPropertyData.Alloc(def);
}
DEFINE_ACTION_FUNCTION(AActor, SetTag)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_STRING(def);
if (def.IsEmpty()) self->Tag = nullptr;
else self->Tag = self->mStringPropertyData.Alloc(def);
return 0;
Normalize line endings
2016-03-01 15:47:10 +00:00
}
void AActor::ClearCounters()
{
if (CountsAsKill() && health > 0)
{
level.total_monsters--;
flags &= ~MF_COUNTKILL;
}
// Same, for items
if (flags & MF_COUNTITEM)
{
level.total_items--;
flags &= ~MF_COUNTITEM;
}
// And finally for secrets
if (flags5 & MF5_COUNTSECRET)
{
level.total_secrets--;
flags5 &= ~MF5_COUNTSECRET;
}
}
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
DEFINE_ACTION_FUNCTION(AActor, ClearCounters)
{
PARAM_SELF_PROLOGUE(AActor);
self->ClearCounters();
return 0;
}
Normalize line endings
2016-03-01 15:47:10 +00:00
- exported a few more functions. - refactored the ModifyDamage interface to be more scripting friendly. In general it should be avoided having to call directly into chained inventory functions because they are very problematic and prone to errors. So this got wrapped into a single handler (on AActor, not AInventory!) which will later make it easier to refactor the parameters of ModifyDamage to work better for scripting and avoid the chaining.
2016-11-27 10:59:47 +00:00
int AActor::GetModifiedDamage(FName damagetype, int damage, bool passive)
{
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
auto inv = Inventory;
while (inv != nullptr)
{
- more exporting of AInventory.
2017-01-19 19:56:31 +00:00
IFVIRTUALPTR(inv, AInventory, ModifyDamage)
{
VMValue params[5] = { (DObject*)inv, damage, int(damagetype), &damage, passive };
GlobalVMStack.Call(func, params, 5, nullptr, 0, nullptr);
}
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
inv = inv->Inventory;
}
- exported a few more functions. - refactored the ModifyDamage interface to be more scripting friendly. In general it should be avoided having to call directly into chained inventory functions because they are very problematic and prone to errors. So this got wrapped into a single handler (on AActor, not AInventory!) which will later make it easier to refactor the parameters of ModifyDamage to work better for scripting and avoid the chaining.
2016-11-27 10:59:47 +00:00
return damage;
}
DEFINE_ACTION_FUNCTION(AActor, GetModifiedDamage)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_NAME(type);
PARAM_INT(damage);
PARAM_BOOL(passive);
ACTION_RETURN_INT(self->GetModifiedDamage(type, damage, passive));
}
- made player_t::crouchoffset and FPlayerStart's coordinates doubles and added a float version of divline_t so that I could complete the conversion of Hexen's game code. - consolidated the actor based damage factor code which was repeated multiple times in various damage inflicting functions.
2016-03-21 23:06:58 +00:00
int AActor::ApplyDamageFactor(FName damagetype, int damage) const
{
damage = int(damage * DamageFactor);
if (damage > 0)
{
damage = DamageTypeDefinition::ApplyMobjDamageFactor(damage, damagetype, GetClass()->DamageFactors);
}
return damage;
}
- exported a few more functions. - refactored the ModifyDamage interface to be more scripting friendly. In general it should be avoided having to call directly into chained inventory functions because they are very problematic and prone to errors. So this got wrapped into a single handler (on AActor, not AInventory!) which will later make it easier to refactor the parameters of ModifyDamage to work better for scripting and avoid the chaining.
2016-11-27 10:59:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, ApplyDamageFactor)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_NAME(type);
PARAM_INT(damage);
ACTION_RETURN_INT(self->ApplyDamageFactor(type, damage));
}
- made player_t::crouchoffset and FPlayerStart's coordinates doubles and added a float version of divline_t so that I could complete the conversion of Hexen's game code. - consolidated the actor based damage factor code which was repeated multiple times in various damage inflicting functions.
2016-03-21 23:06:58 +00:00
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
void AActor::SetTranslation(FName trname)
- added ACS and DECORATE setter functions for named translations.
2016-10-02 12:09:45 +00:00
{
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
// There is no constant for the empty name...
if (trname.GetChars()[0] == 0)
- added ACS and DECORATE setter functions for named translations.
2016-10-02 12:09:45 +00:00
{
// an empty string resets to the default
Translation = GetDefault()->Translation;
return;
}
int tnum = R_FindCustomTranslation(trname);
if (tnum >= 0)
{
Translation = tnum;
}
// silently ignore if the name does not exist, this would create some insane message spam otherwise.
}
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
//---------------------------------------------------------------------------
//
// PROP A_RestoreSpecialPosition
//
//---------------------------------------------------------------------------
static FRandom pr_restore("RestorePos");
void AActor::RestoreSpecialPosition()
{
// Move item back to its original location
DVector2 sp = SpawnPoint;
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
FLinkContext ctx;
UnlinkFromWorld(&ctx);
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
SetXY(sp);
- removed the global 'sector_list' variable. If the calling code wants to recycle this it will have to pass a container variable to AActor::UnlinkFromWorld and AActor::LinkToWorld. This was changed because keeping such data in a global variable is dangerous for a set of functions that can be called from a script. Note that the scripted versions do not yet support saving of the touching_sectorlist.
2016-12-25 21:40:26 +00:00
LinkToWorld(&ctx, true);
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
SetZ(Sector->floorplane.ZatPoint(sp));
P_FindFloorCeiling(this, FFCF_ONLYSPAWNPOS | FFCF_NOPORTALS); // no portal checks here so that things get spawned in this sector.
if (flags & MF_SPAWNCEILING)
{
SetZ(ceilingz - Height - SpawnPoint.Z);
}
else if (flags2 & MF2_SPAWNFLOAT)
{
double space = ceilingz - Height - floorz;
if (space > 48)
{
space -= 40;
SetZ((space * pr_restore()) / 256. + floorz + 40);
}
else
{
SetZ(floorz);
}
}
else
{
SetZ(SpawnPoint.Z + floorz);
}
// Redo floor/ceiling check, in case of 3D floors and portals
P_FindFloorCeiling(this, FFCF_SAMESECTOR | FFCF_ONLY3DFLOORS | FFCF_3DRESTRICT);
if (Z() < floorz)
{ // Do not reappear under the floor, even if that's where we were for the
// initial spawn.
SetZ(floorz);
}
if ((flags & MF_SOLID) && (Top() > ceilingz))
{ // Do the same for the ceiling.
SetZ(ceilingz - Height);
}
// Do not interpolate from the position the actor was at when it was
// picked up, in case that is different from where it is now.
ClearInterpolation();
}
DEFINE_ACTION_FUNCTION(AActor, A_RestoreSpecialPosition)
{
PARAM_SELF_PROLOGUE(AActor);
self->RestoreSpecialPosition();
return 0;
}
- refactored global sides array to be more VM friendly. - moved FLevelLocals to its own header to resolve some circular include conflicts.
2017-01-08 17:45:30 +00:00
double AActor::GetBobOffset(double ticfrac) const
{
if (!(flags2 & MF2_FLOATBOB))
{
return 0;
}
return BobSin(FloatBobPhase + level.maptime + ticfrac);
}
DEFINE_ACTION_FUNCTION(AActor, GetBobOffset)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT_DEF(frac);
ACTION_RETURN_FLOAT(self->GetBobOffset(frac));
}
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
class DActorIterator : public DObject, public NActorIterator
{
DECLARE_CLASS(DActorIterator, DObject)
public:
DActorIterator(PClassActor *cls= nullptr, int tid = 0)
: NActorIterator(cls, tid)
{
}
};
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
IMPLEMENT_CLASS(DActorIterator, false, false);
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
DEFINE_ACTION_FUNCTION(DActorIterator, Create)
{
PARAM_PROLOGUE;
- removed incorrect _DEF.
2016-11-16 18:46:36 +00:00
PARAM_INT(tid);
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
PARAM_CLASS_DEF(type, AActor);
ACTION_RETURN_OBJECT(new DActorIterator(type, tid));
}
DEFINE_ACTION_FUNCTION(DActorIterator, Next)
{
PARAM_SELF_PROLOGUE(DActorIterator);
ACTION_RETURN_OBJECT(self->Next());
}
DEFINE_ACTION_FUNCTION(DActorIterator, Reinit)
{
PARAM_SELF_PROLOGUE(DActorIterator);
self->Reinit();
return 0;
}
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
DEFINE_ACTION_FUNCTION(AActor, deltaangle) // should this be global?
{
PARAM_PROLOGUE;
PARAM_FLOAT(a1);
PARAM_FLOAT(a2);
ACTION_RETURN_FLOAT(deltaangle(DAngle(a1), DAngle(a2)).Degrees);
}
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
DEFINE_ACTION_FUNCTION(AActor, absangle) // should this be global?
{
PARAM_PROLOGUE;
PARAM_FLOAT(a1);
PARAM_FLOAT(a2);
ACTION_RETURN_FLOAT(absangle(DAngle(a1), DAngle(a2)).Degrees);
}
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, Distance2D)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(other, AActor);
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
ACTION_RETURN_FLOAT(self->Distance2D(other));
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, Distance3D)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(other, AActor);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
ACTION_RETURN_FLOAT(self->Distance3D(other));
}
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
DEFINE_ACTION_FUNCTION(AActor, AddZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(addz);
- fixed a lost '='. - scriptified A_TimeBomb.
2016-11-16 20:12:16 +00:00
PARAM_BOOL_DEF(moving);
self->AddZ(addz, moving);
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
return 0;
}
- scriptified Hexen's bats. - removed AMinotaurFriend::IsOkayToAttack. The condition it checks (i.e. friendliness with player) is already covered by the base version of this function so this is quite redundant. - removed a few 'virtual' qualifiers from functions that never get overridden.
2016-11-12 08:33:43 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(z);
self->SetZ(z);
return 0;
}
- scriptified parts of a_bossbrain.cpp. Some things cannot be done yet, the script code is there but commented out. - exported thinker iterator and drop item chain to scripting. Unlike its native counterpart the script-side iterator is wrapped into a DObject to allow proper handling for memory management. - fixed: The VMFunctionBuilder only distinguished between member and action functions but failed on static ones. - fixed: FxAssign did not add all needed type casts. Except for purely numeric types it will now wrap the expression in an FxTypeCast. Numeric handling remains unchanged for both performance reasons and not altering semantics for DECORATE. - exported all internal flags as variables to scripting. They still cannot be used in an actor definition. - make ATAG_STATE the same as ATAG_GENERIC. Since state pointers exist as actual variables they can take both values which on occasion can trigger some asserts. - gave PClass a bExported flag, so that scripts cannot see purely internal classes. Especially the types like PInt can cause problems. Todo: we need readonly references to safely expose the actor defaults. Right now some badly behaving code could overwrite them.
2016-10-31 16:02:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetDamage)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_INT(dmg);
self->SetDamage(dmg);
return 0;
}
DEFINE_ACTION_FUNCTION(AActor, GetDefaultByType)
{
PARAM_PROLOGUE;
PARAM_CLASS(cls, AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
ACTION_RETURN_OBJECT(cls == nullptr? nullptr : GetDefaultByType(cls));
- scriptified parts of a_bossbrain.cpp. Some things cannot be done yet, the script code is there but commented out. - exported thinker iterator and drop item chain to scripting. Unlike its native counterpart the script-side iterator is wrapped into a DObject to allow proper handling for memory management. - fixed: The VMFunctionBuilder only distinguished between member and action functions but failed on static ones. - fixed: FxAssign did not add all needed type casts. Except for purely numeric types it will now wrap the expression in an FxTypeCast. Numeric handling remains unchanged for both performance reasons and not altering semantics for DECORATE. - exported all internal flags as variables to scripting. They still cannot be used in an actor definition. - make ATAG_STATE the same as ATAG_GENERIC. Since state pointers exist as actual variables they can take both values which on occasion can trigger some asserts. - gave PClass a bExported flag, so that scripts cannot see purely internal classes. Especially the types like PInt can cause problems. Todo: we need readonly references to safely expose the actor defaults. Right now some badly behaving code could overwrite them.
2016-10-31 16:02:47 +00:00
}
- scriptified A_FatAttack*. - swapped parameters of two-parameter VelToAngle method, so that internal and script version are in line. - fixed parameter asserts to handle NULL pointers properly.
2016-10-27 15:47:46 +00:00
// This combines all 3 variations of the internal function
DEFINE_ACTION_FUNCTION(AActor, VelFromAngle)
{
PARAM_SELF_PROLOGUE(AActor);
if (numparam == 1)
{
self->VelFromAngle();
}
else
{
PARAM_FLOAT(speed);
if (numparam == 2)
{
self->VelFromAngle(speed);
}
else
{
PARAM_ANGLE(angle);
self->VelFromAngle(speed, angle);
}
}
return 0;
}
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
// This combines all 3 variations of the internal function
DEFINE_ACTION_FUNCTION(AActor, Vel3DFromAngle)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(speed);
PARAM_ANGLE(angle);
PARAM_ANGLE(pitch);
self->Vel3DFromAngle(pitch, angle, speed);
return 0;
}
- scriptified Hexen's Bishop.
2016-11-12 15:32:26 +00:00
// This combines all 3 variations of the internal function
DEFINE_ACTION_FUNCTION(AActor, Thrust)
{
PARAM_SELF_PROLOGUE(AActor);
if (numparam == 1)
{
self->Thrust();
}
else
{
PARAM_FLOAT(speed);
if (numparam == 2)
{
self->Thrust(speed);
}
else
{
PARAM_ANGLE(angle);
self->Thrust(angle, speed);
}
}
return 0;
}
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
DEFINE_ACTION_FUNCTION(AActor, AngleTo)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(targ, AActor);
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
PARAM_BOOL_DEF(absolute);
ACTION_RETURN_FLOAT(self->AngleTo(targ, absolute).Degrees);
}
- scriptified A_PainShootSkull which was the last remaining bit in g_doom, so this directory is gone now.
2016-11-23 18:47:09 +00:00
DEFINE_ACTION_FUNCTION(AActor, AngleToVector)
{
PARAM_PROLOGUE;
PARAM_ANGLE(angle);
PARAM_FLOAT_DEF(length);
ACTION_RETURN_VEC2(angle.ToVector(length));
}
DEFINE_ACTION_FUNCTION(AActor, RotateVector)
{
PARAM_PROLOGUE;
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_ANGLE(angle);
ACTION_RETURN_VEC2(DVector2(x, y).Rotated(angle));
}
- scriptified the moving camera.
2017-01-13 21:13:03 +00:00
DEFINE_ACTION_FUNCTION(AActor, Normalize180)
{
PARAM_PROLOGUE;
PARAM_ANGLE(angle);
ACTION_RETURN_FLOAT(angle.Normalized180().Degrees);
}
- fixed damage handling in A_BetaSkullAttack. For unknown reasons this completely bypassed the normal damage function semantics and even multiplied that with a random value. - made some tests about calling script code from native functions. * scriptified A_SkullAttack to have something to test * changed the A_SkullAttack call in A_PainShootSkull. * use a macro to declare the function pointer. Using local static variable init directly results in hideous code for the need of being thread-safe (which, even if the engine was made multithreaded is not needed here.) * Importsnt node here: Apparently passing an actor pointer to the VMValue constructor results in the void * version being called, not the DObject * version.
2016-11-06 10:36:12 +00:00
DEFINE_ACTION_FUNCTION(AActor, DistanceBySpeed)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(targ, AActor);
- fixed damage handling in A_BetaSkullAttack. For unknown reasons this completely bypassed the normal damage function semantics and even multiplied that with a random value. - made some tests about calling script code from native functions. * scriptified A_SkullAttack to have something to test * changed the A_SkullAttack call in A_PainShootSkull. * use a macro to declare the function pointer. Using local static variable init directly results in hideous code for the need of being thread-safe (which, even if the engine was made multithreaded is not needed here.) * Importsnt node here: Apparently passing an actor pointer to the VMValue constructor results in the void * version being called, not the DObject * version.
2016-11-06 10:36:12 +00:00
PARAM_FLOAT(speed);
ACTION_RETURN_FLOAT(self->DistanceBySpeed(targ, speed));
}
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetXYZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
self->SetXYZ(x, y, z);
return 0;
}
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec2Angle)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(length);
PARAM_ANGLE(angle);
PARAM_BOOL_DEF(absolute);
ACTION_RETURN_VEC2(self->Vec2Angle(length, angle, absolute));
}
- scriptified the Loremaster.
2016-11-28 17:59:57 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec3To)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(t, AActor)
- scriptified the Loremaster.
2016-11-28 17:59:57 +00:00
ACTION_RETURN_VEC3(self->Vec3To(t));
}
- scriptified ASecurityCamera and AAimingCamera. This concludes this round of script converesions of internal classes.
2016-11-29 19:16:14 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec2To)
{
PARAM_SELF_PROLOGUE(AActor);
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
PARAM_OBJECT_NOT_NULL(t, AActor)
- scriptified ASecurityCamera and AAimingCamera. This concludes this round of script converesions of internal classes.
2016-11-29 19:16:14 +00:00
ACTION_RETURN_VEC2(self->Vec2To(t));
}
- scriptified a_archvile.cpp. - fixed the type checks for the conditional operator.
2016-10-30 17:41:39 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec3Angle)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(length)
- scriptified the Loremaster.
2016-11-28 17:59:57 +00:00
PARAM_ANGLE(angle);
- scriptified a_archvile.cpp. - fixed the type checks for the conditional operator.
2016-10-30 17:41:39 +00:00
PARAM_FLOAT(z);
- scriptified the Loremaster.
2016-11-28 17:59:57 +00:00
PARAM_BOOL_DEF(absolute);
- scriptified a_archvile.cpp. - fixed the type checks for the conditional operator.
2016-10-30 17:41:39 +00:00
ACTION_RETURN_VEC3(self->Vec3Angle(length, angle, z, absolute));
}
- scriptified parts of a_bossbrain.cpp. Some things cannot be done yet, the script code is there but commented out. - exported thinker iterator and drop item chain to scripting. Unlike its native counterpart the script-side iterator is wrapped into a DObject to allow proper handling for memory management. - fixed: The VMFunctionBuilder only distinguished between member and action functions but failed on static ones. - fixed: FxAssign did not add all needed type casts. Except for purely numeric types it will now wrap the expression in an FxTypeCast. Numeric handling remains unchanged for both performance reasons and not altering semantics for DECORATE. - exported all internal flags as variables to scripting. They still cannot be used in an actor definition. - make ATAG_STATE the same as ATAG_GENERIC. Since state pointers exist as actual variables they can take both values which on occasion can trigger some asserts. - gave PClass a bExported flag, so that scripts cannot see purely internal classes. Especially the types like PInt can cause problems. Todo: we need readonly references to safely expose the actor defaults. Right now some badly behaving code could overwrite them.
2016-10-31 16:02:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec2OffsetZ)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL_DEF(absolute);
ACTION_RETURN_VEC3(self->Vec2OffsetZ(x, y, z, absolute));
}
- fixed damage handling in A_BetaSkullAttack. For unknown reasons this completely bypassed the normal damage function semantics and even multiplied that with a random value. - made some tests about calling script code from native functions. * scriptified A_SkullAttack to have something to test * changed the A_SkullAttack call in A_PainShootSkull. * use a macro to declare the function pointer. Using local static variable init directly results in hideous code for the need of being thread-safe (which, even if the engine was made multithreaded is not needed here.) * Importsnt node here: Apparently passing an actor pointer to the VMValue constructor results in the void * version being called, not the DObject * version.
2016-11-06 10:36:12 +00:00
- scriptified Strife's flamethrower and grenade launcher.
2016-11-29 13:12:39 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec2Offset)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_BOOL_DEF(absolute);
ACTION_RETURN_VEC2(self->Vec2Offset(x, y, absolute));
}
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
DEFINE_ACTION_FUNCTION(AActor, Vec3Offset)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
PARAM_FLOAT(z);
PARAM_BOOL_DEF(absolute);
ACTION_RETURN_VEC3(self->Vec3Offset(x, y, z, absolute));
}
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
DEFINE_ACTION_FUNCTION(AActor, PosRelative)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER(sec, sector_t);
ACTION_RETURN_VEC3(self->PosRelative(sec));
}
- scriptified the Ironlich.
2016-11-23 20:26:59 +00:00
DEFINE_ACTION_FUNCTION(AActor, RestoreDamage)
{
PARAM_SELF_PROLOGUE(AActor);
self->RestoreDamage();
return 0;
}
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
DEFINE_ACTION_FUNCTION(AActor, PlayerNumber)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_INT(self->player ? int(self->player - players) : 0);
}
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
DEFINE_ACTION_FUNCTION(AActor, SetFriendPlayer)
{
PARAM_SELF_PROLOGUE(AActor);
PARAM_POINTER(player, player_t);
self->SetFriendPlayer(player);
return 0;
}
- changed AInventory::HandlePickup to work iteratively instead of recursively. Two reasons for this: 1. if this has to be routed through the VM each recursion will cost 1000 bytes of stack space which simply is not good. 2. having the virtual function only care about the item itself but not the entire inventory chain is a lot less error prone for scripting. Since the scripting interface needs a separate caller function anyway this seemed like a good time to change it. The same will be done for the other chained inventory handlers as well.
2016-11-27 09:40:43 +00:00
DEFINE_ACTION_FUNCTION(AActor, ClearBounce)
{
PARAM_SELF_PROLOGUE(AActor);
self->BounceFlags = 0;
return 0;
}
- scriptified Strife's dagger and crossbow.
2016-11-29 12:00:07 +00:00
DEFINE_ACTION_FUNCTION(AActor, AccuracyFactor)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_FLOAT(self->AccuracyFactor());
}
- changed AInventory::HandlePickup to work iteratively instead of recursively. Two reasons for this: 1. if this has to be routed through the VM each recursion will cost 1000 bytes of stack space which simply is not good. 2. having the virtual function only care about the item itself but not the entire inventory chain is a lot less error prone for scripting. Since the scripting interface needs a separate caller function anyway this seemed like a good time to change it. The same will be done for the other chained inventory handlers as well.
2016-11-27 09:40:43 +00:00
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
DEFINE_ACTION_FUNCTION(AActor, CountsAsKill)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_FLOAT(self->CountsAsKill());
}
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
DEFINE_ACTION_FUNCTION(AActor, IsZeroDamage)
{
PARAM_SELF_PROLOGUE(AActor);
ACTION_RETURN_BOOL(self->IsZeroDamage());
}
DEFINE_ACTION_FUNCTION(AActor, ClearInterpolation)
{
PARAM_SELF_PROLOGUE(AActor);
self->ClearInterpolation();
return 0;
}
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
DEFINE_ACTION_FUNCTION(AActor, ApplyDamageFactors)
{
PARAM_PROLOGUE;
PARAM_CLASS(itemcls, AInventory);
PARAM_NAME(damagetype);
PARAM_INT(damage);
PARAM_INT(defdamage);
DmgFactors *df = itemcls->DamageFactors;
if (df != nullptr && df->CountUsed() != 0)
{
ACTION_RETURN_INT(df->Apply(damagetype, damage));
}
else
{
ACTION_RETURN_INT(defdamage);
}
}
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
//----------------------------------------------------------------------------
//
// DropItem handling
//
//----------------------------------------------------------------------------
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
- disabled the scripted virtual function module after finding out that it only works if each single class that may serve as a parent for scripting is explicitly declared. Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going. It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
2016-11-24 20:36:02 +00:00
IMPLEMENT_CLASS(DDropItem, false, true)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_START(DDropItem)
- added proper definitions for all exported native fields. - synthesize native fields for all declared flags, not just for AActor.
2016-11-22 22:42:32 +00:00
IMPLEMENT_POINTER(Next)
Separate the pointer list from the implement macro
2016-11-05 16:08:54 +00:00
IMPLEMENT_POINTERS_END
Normalize line endings
2016-03-01 15:47:10 +00:00
- added proper definitions for all exported native fields. - synthesize native fields for all declared flags, not just for AActor.
2016-11-22 22:42:32 +00:00
DEFINE_FIELD(DDropItem, Next)
DEFINE_FIELD(DDropItem, Name)
DEFINE_FIELD(DDropItem, Probability)
DEFINE_FIELD(DDropItem, Amount)
- moved declaration of native fields into the respective class definitions. This bypasses a declaration in the script in favor of a simpler implementation. In order to work it is always necessary to have an offset table to map the variables to, but doing it fully on the native side only requires adding the type to the declaration.
2016-11-03 23:19:36 +00:00
Normalize line endings
2016-03-01 15:47:10 +00:00
void PrintMiscActorInfo(AActor *query)
{
if (query)
{
int flagi;
int querystyle = STYLE_Count;
for (int style = STYLE_None; style < STYLE_Count; ++style)
{ // Check for a legacy render style that matches.
if (LegacyRenderStyles[style] == query->RenderStyle)
{
querystyle = style;
break;
}
}
static const char * renderstyles[]= {"None", "Normal", "Fuzzy", "SoulTrans",
"OptFuzzy", "Stencil", "Translucent", "Add", "Shaded", "TranslucentStencil",
"Shadow", "Subtract", "AddStencil", "AddShaded"};
FLineSpecial *spec = P_GetLineSpecialInfo(query->special);
Printf("%s @ %p has the following flags:\n flags: %x", query->GetTag(), query, query->flags.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags & ActorFlags::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags));
Printf("\n flags2: %x", query->flags2.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags2 & ActorFlags2::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags2));
Printf("\n flags3: %x", query->flags3.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags3 & ActorFlags3::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags3));
Printf("\n flags4: %x", query->flags4.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags4 & ActorFlags4::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags4));
Printf("\n flags5: %x", query->flags5.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags5 & ActorFlags5::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags5));
Printf("\n flags6: %x", query->flags6.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags6 & ActorFlags6::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags6));
Printf("\n flags7: %x", query->flags7.GetValue());
for (flagi = 0; flagi <= 31; flagi++)
if (query->flags7 & ActorFlags7::FromInt(1<<flagi)) Printf(" %s", FLAG_NAME(1<<flagi, flags7));
Printf("\nBounce flags: %x\nBounce factors: f:%f, w:%f",
- floatified AActor::bouncefactor and wallbouncefactor.
2016-03-24 19:43:35 +00:00
query->BounceFlags.GetValue(), query->bouncefactor,
query->wallbouncefactor);
Normalize line endings
2016-03-01 15:47:10 +00:00
/*for (flagi = 0; flagi < 31; flagi++)
if (query->BounceFlags & 1<<flagi) Printf(" %s", flagnamesb[flagi]);*/
Printf("\nRender style = %i:%s, alpha %f\nRender flags: %x",
querystyle, (querystyle < STYLE_Count ? renderstyles[querystyle] : "Unknown"),
- made AActor::alpha a floating point value - replaced some uses of FRACUNIT with OPAQUE when it was about translucency. - simplified some overly complicated translucency multiplications in the SBARINFO code.
2016-03-21 11:18:46 +00:00
query->Alpha, query->renderflags.GetValue());
Normalize line endings
2016-03-01 15:47:10 +00:00
/*for (flagi = 0; flagi < 31; flagi++)
if (query->renderflags & 1<<flagi) Printf(" %s", flagnamesr[flagi]);*/
Printf("\nSpecial+args: %s(%i, %i, %i, %i, %i)\nspecial1: %i, special2: %i.",
(spec ? spec->name : "None"),
query->args[0], query->args[1], query->args[2], query->args[3],
query->args[4], query->special1, query->special2);
Printf("\nTID: %d", query->tid);
Printf("\nCoord= x: %f, y: %f, z:%f, floor:%f, ceiling:%f.",
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
query->X(), query->Y(), query->Z(),
- floatified the rest of p_mobj_cpp and removed a large part of the conversion cruft from the headers that was needed to keep the code compileable.
2016-03-28 10:03:07 +00:00
query->floorz, query->ceilingz);
Normalize line endings
2016-03-01 15:47:10 +00:00
Printf("\nSpeed= %f, velocity= x:%f, y:%f, z:%f, combined:%f.\n",
- replaced AActor::vel and player_t::Vel with a floating point version. - Converted P_MovePlayer and all associated variables to floating point because this wasn't working well with a mixture between float and fixed. Like the angle commit this has just been patched up to compile, the bulk of work is yet to be done.
2016-03-19 23:54:18 +00:00
query->Speed, query->Vel.X, query->Vel.Y, query->Vel.Z, query->Vel.Length());
- fixed: Dehacked did not copy the defaults for DehackedPickup replacements anymore.
2016-12-02 00:33:18 +00:00
Printf("Scale: x:%f, y:%f\n", query->Scale.X, query->Scale.Y);
Normalize line endings
2016-03-01 15:47:10 +00:00
}
}
Reference in a new issue Copy permalink