//----------------------------------------------------------------------------- // // Copyright 2016-2018 Christoph Oelckers // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see http://www.gnu.org/licenses/ // //----------------------------------------------------------------------------- // // VM thunks for internal functions of actor classes // // Important note about this file: Since everything in here is supposed to be called // from JIT-compiled VM code it needs to be very careful about calling conventions. // As a result none of the integer sized struct types may be used as function // arguments, because current C++ calling conventions require them to be passed // by reference. The JIT code, however will pass them by value so any direct native function // taking such an argument needs to receive it as a naked int. // //----------------------------------------------------------------------------- #include "vm.h" #include "r_defs.h" #include "g_levellocals.h" #include "s_sound.h" #include "p_local.h" #include "v_font.h" #include "gstrings.h" #include "a_keys.h" #include "sbar.h" #include "doomstat.h" #include "p_acs.h" #include "a_pickups.h" #include "a_specialspot.h" #include "actorptrselect.h" #include "a_weapons.h" #include "d_player.h" #include "p_setup.h" #include "i_music.h" #include "p_terrain.h" #include "p_checkposition.h" #include "p_linetracedata.h" #include "p_local.h" #include "p_effect.h" #include "p_spec.h" #include "actorinlines.h" #include "p_enemy.h" #include "gi.h" DVector2 AM_GetPosition(); int Net_GetLatency(int *ld, int *ad); void PrintPickupMessage(bool localview, const FString &str); // FCheckPosition requires explicit construction and destruction when used in the VM static void FCheckPosition_C(void *mem) { new(mem) FCheckPosition; } DEFINE_ACTION_FUNCTION_NATIVE(_FCheckPosition, _Constructor, FCheckPosition_C) { PARAM_SELF_STRUCT_PROLOGUE(FCheckPosition); FCheckPosition_C(self); return 0; } static void FCheckPosition_D(FCheckPosition *self) { self->~FCheckPosition(); } DEFINE_ACTION_FUNCTION_NATIVE(_FCheckPosition, _Destructor, FCheckPosition_D) { PARAM_SELF_STRUCT_PROLOGUE(FCheckPosition); self->~FCheckPosition(); return 0; } static void ClearLastRipped(FCheckPosition *self) { self->LastRipped.Clear(); } DEFINE_ACTION_FUNCTION_NATIVE(_FCheckPosition, ClearLastRipped, ClearLastRipped) { PARAM_SELF_STRUCT_PROLOGUE(FCheckPosition); self->LastRipped.Clear(); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(DObject, SetMusicVolume, I_SetMusicVolume) { PARAM_PROLOGUE; PARAM_FLOAT(vol); I_SetMusicVolume(vol); return 0; } //===================================================================================== // // AActor exports (this will be expanded) // //===================================================================================== DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetPointer, COPY_AAPTR) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(ptr); ACTION_RETURN_OBJECT(COPY_AAPTR(self, ptr)); } //========================================================================== // // Custom sound functions. // //========================================================================== static void NativeStopSound(AActor *actor, int slot) { S_StopSound(actor, slot); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_StopSound, NativeStopSound) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(slot); S_StopSound(self, slot); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_SoundVolume, S_ChangeSoundVolume) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(channel); PARAM_FLOAT(volume); S_ChangeSoundVolume(self, channel, volume); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_PlaySound, A_PlaySound) { PARAM_SELF_PROLOGUE(AActor); PARAM_SOUND(soundid); PARAM_INT(channel); PARAM_FLOAT(volume); PARAM_BOOL(looping); PARAM_FLOAT(attenuation); PARAM_BOOL(local); A_PlaySound(self, soundid, channel, volume, looping, attenuation, local); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckKeys, P_CheckKeys) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(locknum); PARAM_BOOL(remote); PARAM_BOOL(quiet); ACTION_RETURN_BOOL(P_CheckKeys(self, locknum, remote, quiet)); } static double deltaangleDbl(double a1, double a2) { return deltaangle(DAngle(a1), DAngle(a2)).Degrees; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, deltaangle, deltaangleDbl) // should this be global? { PARAM_PROLOGUE; PARAM_FLOAT(a1); PARAM_FLOAT(a2); ACTION_RETURN_FLOAT(deltaangle(DAngle(a1), DAngle(a2)).Degrees); } static double absangleDbl(double a1, double a2) { return absangle(DAngle(a1), DAngle(a2)).Degrees; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, absangle, absangleDbl) // should this be global? { PARAM_PROLOGUE; PARAM_FLOAT(a1); PARAM_FLOAT(a2); ACTION_RETURN_FLOAT(absangle(DAngle(a1), DAngle(a2)).Degrees); } static double Distance2DSquared(AActor *self, AActor *other) { return self->Distance2DSquared(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Distance2DSquared, Distance2DSquared) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_FLOAT(self->Distance2DSquared(other)); } static double Distance3DSquared(AActor *self, AActor *other) { return self->Distance3DSquared(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Distance3DSquared, Distance3DSquared) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_FLOAT(self->Distance3DSquared(other)); } static double Distance2D(AActor *self, AActor *other) { return self->Distance2D(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Distance2D, Distance2D) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_FLOAT(self->Distance2D(other)); } static double Distance3D(AActor *self, AActor *other) { return self->Distance3D(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Distance3D, Distance3D) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_FLOAT(self->Distance3D(other)); } static void AddZ(AActor *self, double addz, bool moving) { self->AddZ(addz, moving); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, AddZ, AddZ) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(addz); PARAM_BOOL(moving); self->AddZ(addz, moving); return 0; } static void SetZ(AActor *self, double z) { self->SetZ(z); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetZ, SetZ) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(z); self->SetZ(z); return 0; } static void SetDamage(AActor *self, int dmg) { self->SetDamage(dmg); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetDamage, SetDamage) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(dmg); self->SetDamage(dmg); return 0; } // This combines all 3 variations of the internal function static void VelFromAngle(AActor *self, double speed, double angle) { if (speed == 1e37) { self->VelFromAngle(); } else { if (angle == 1e37) { self->VelFromAngle(speed); } else { self->VelFromAngle(speed, angle); } } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, VelFromAngle, VelFromAngle) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(speed); PARAM_FLOAT(angle); VelFromAngle(self, speed, angle); return 0; } static void Vel3DFromAngle(AActor *self, double speed, double angle, double pitch) { self->Vel3DFromAngle(angle, pitch, speed); } // This combines all 3 variations of the internal function DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vel3DFromAngle, Vel3DFromAngle) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(speed); PARAM_ANGLE(angle); PARAM_ANGLE(pitch); self->Vel3DFromAngle(angle, pitch, speed); return 0; } // This combines all 3 variations of the internal function static void Thrust(AActor *self, double speed, double angle) { if (speed == 1e37) { self->Thrust(); } else { if (angle == 1e37) { self->Thrust(speed); } else { self->Thrust(angle, speed); } } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Thrust, Thrust) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(speed); PARAM_FLOAT(angle); Thrust(self, speed, angle); return 0; } static double AngleTo(AActor *self, AActor *targ, bool absolute) { return self->AngleTo(PARAM_NULLCHECK(targ, targ), absolute).Degrees; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, AngleTo, AngleTo) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(targ, AActor); PARAM_BOOL(absolute); ACTION_RETURN_FLOAT(self->AngleTo(targ, absolute).Degrees); } static void AngleToVector(double angle, double length, DVector2 *result) { *result = DAngle(angle).ToVector(length); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, AngleToVector, AngleToVector) { PARAM_PROLOGUE; PARAM_ANGLE(angle); PARAM_FLOAT(length); ACTION_RETURN_VEC2(angle.ToVector(length)); } static void RotateVector(double x, double y, double angle, DVector2 *result) { *result = DVector2(x, y).Rotated(angle); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RotateVector, RotateVector) { PARAM_PROLOGUE; PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_ANGLE(angle); ACTION_RETURN_VEC2(DVector2(x, y).Rotated(angle)); } static double Normalize180(double angle) { return DAngle(angle).Normalized180().Degrees; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Normalize180, Normalize180) { PARAM_PROLOGUE; PARAM_ANGLE(angle); ACTION_RETURN_FLOAT(angle.Normalized180().Degrees); } static double DistanceBySpeed(AActor *self, AActor *targ, double speed) { return self->DistanceBySpeed(PARAM_NULLCHECK(targ, targ), speed); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, DistanceBySpeed, DistanceBySpeed) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(targ, AActor); PARAM_FLOAT(speed); ACTION_RETURN_FLOAT(self->DistanceBySpeed(targ, speed)); } static void SetXYZ(AActor *self, double x, double y, double z) { self->SetXYZ(x, y, z); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetXYZ, SetXYZ) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); self->SetXYZ(x, y, z); return 0; } static void Vec2Angle(AActor *self, double length, double angle, bool absolute, DVector2 *result) { *result = self->Vec2Angle(length, angle, absolute); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec2Angle, Vec2Angle) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(length); PARAM_ANGLE(angle); PARAM_BOOL(absolute); ACTION_RETURN_VEC2(self->Vec2Angle(length, angle, absolute)); } static void Vec3To(AActor *self, AActor *t, DVector3 *result) { *result = self->Vec3To(PARAM_NULLCHECK(t, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec3To, Vec3To) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(t, AActor) ACTION_RETURN_VEC3(self->Vec3To(t)); } static void Vec2To(AActor *self, AActor *t, DVector2 *result) { *result = self->Vec2To(PARAM_NULLCHECK(t, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec2To, Vec2To) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(t, AActor) ACTION_RETURN_VEC2(self->Vec2To(t)); } static void Vec3Angle(AActor *self, double length, double angle, double z, bool absolute, DVector3 *result) { *result = self->Vec3Angle(length, angle, z, absolute); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec3Angle, Vec3Angle) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(length) PARAM_ANGLE(angle); PARAM_FLOAT(z); PARAM_BOOL(absolute); ACTION_RETURN_VEC3(self->Vec3Angle(length, angle, z, absolute)); } static void Vec2OffsetZ(AActor *self, double x, double y, double z, bool absolute, DVector3 *result) { *result = self->Vec2OffsetZ(x, y, z, absolute); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec2OffsetZ, Vec2OffsetZ) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_BOOL(absolute); ACTION_RETURN_VEC3(self->Vec2OffsetZ(x, y, z, absolute)); } static void Vec2Offset(AActor *self, double x, double y, bool absolute, DVector2 *result) { *result = self->Vec2OffsetZ(x, y, absolute); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec2Offset, Vec2Offset) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_BOOL(absolute); ACTION_RETURN_VEC2(self->Vec2Offset(x, y, absolute)); } static void Vec3Offset(AActor *self, double x, double y, double z, bool absolute, DVector3 *result) { *result = self->Vec3Offset(x, y, z, absolute); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Vec3Offset, Vec3Offset) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_BOOL(absolute); ACTION_RETURN_VEC3(self->Vec3Offset(x, y, z, absolute)); } static void ZS_PosRelative(AActor *self, sector_t *sec, DVector3 *result) { *result = self->PosRelative(sec); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, PosRelative, ZS_PosRelative) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER(sec, sector_t); ACTION_RETURN_VEC3(self->PosRelative(sec)); } static void RestoreDamage(AActor *self) { self->DamageVal = self->GetDefault()->DamageVal; self->DamageFunc = self->GetDefault()->DamageFunc; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RestoreDamage, RestoreDamage) { PARAM_SELF_PROLOGUE(AActor); RestoreDamage(self); return 0; } static int PlayerNumber(AActor *self) { return self->player ? self->Level->PlayerNum(self->player) : 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, PlayerNumber, PlayerNumber) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(PlayerNumber(self)); } static void SetFriendPlayer(AActor *self, player_t *player) { self->SetFriendPlayer(player); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetFriendPlayer, SetFriendPlayer) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER(player, player_t); self->SetFriendPlayer(player); return 0; } void ClearBounce(AActor *self) { self->BounceFlags = 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, ClearBounce, ClearBounce) { PARAM_SELF_PROLOGUE(AActor); ClearBounce(self); return 0; } static int CountsAsKill(AActor *self) { return self->CountsAsKill(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CountsAsKill, CountsAsKill) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(self->CountsAsKill()); } static int IsZeroDamage(AActor *self) { return self->IsZeroDamage(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, IsZeroDamage, IsZeroDamage) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(self->IsZeroDamage()); } static void ClearInterpolation(AActor *self) { self->ClearInterpolation(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, ClearInterpolation, ClearInterpolation) { PARAM_SELF_PROLOGUE(AActor); self->ClearInterpolation(); return 0; } static int ApplyDamageFactors(PClassActor *itemcls, int damagetype, int damage, int defdamage) { DmgFactors &df = itemcls->ActorInfo()->DamageFactors; if (df.Size() != 0) { return (df.Apply(ENamedName(damagetype), damage)); } else { return (defdamage); } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, ApplyDamageFactors, ApplyDamageFactors) { PARAM_PROLOGUE; PARAM_CLASS(itemcls, AActor); PARAM_NAME(damagetype); PARAM_INT(damage); PARAM_INT(defdamage); ACTION_RETURN_INT(ApplyDamageFactors(itemcls, damagetype.GetIndex(), damage, defdamage)); } static void RestoreSpecialPosition(AActor *self) { self->RestoreSpecialPosition(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_RestoreSpecialPosition, RestoreSpecialPosition) { PARAM_SELF_PROLOGUE(AActor); self->RestoreSpecialPosition(); return 0; } static double GetBobOffset(AActor *self, double frac) { return self->GetBobOffset(frac); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetBobOffset, GetBobOffset) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(frac); ACTION_RETURN_FLOAT(self->GetBobOffset(frac)); } static void SetIdle(AActor *self, bool nofunction) { self->SetIdle(nofunction); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetIdle, SetIdle) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(nofunction); self->SetIdle(nofunction); return 0; } static int SpawnHealth(AActor *self) { return self->SpawnHealth(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SpawnHealth, SpawnHealth) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(self->SpawnHealth()); } // Why does this exist twice? DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetSpawnHealth, SpawnHealth) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(self->SpawnHealth()); } void Revive(AActor *self) { self->Revive(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Revive, Revive) { PARAM_SELF_PROLOGUE(AActor); self->Revive(); return 0; } static double GetCameraHeight(AActor *self) { return self->GetCameraHeight(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetCameraHeight, GetCameraHeight) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_FLOAT(self->GetCameraHeight()); } static FDropItem *GetDropItems(AActor *self) { return self->GetDropItems(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetDropItems, GetDropItems) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_POINTER(self->GetDropItems()); } static double GetGravity(AActor *self) { return self->GetGravity(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetGravity, GetGravity) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_FLOAT(self->GetGravity()); } static void GetTag(AActor *self, const FString &def, FString *result) { *result = self->GetTag(def.Len() == 0 ? nullptr : def.GetChars()); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetTag, GetTag) { PARAM_SELF_PROLOGUE(AActor); PARAM_STRING(def); FString res; GetTag(self, def, &res); ACTION_RETURN_STRING(res); } static void SetTag(AActor *self, const FString &def) { if (def.IsEmpty()) self->Tag = nullptr; else self->Tag = self->mStringPropertyData.Alloc(def); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetTag, SetTag) { PARAM_SELF_PROLOGUE(AActor); PARAM_STRING(def); SetTag(self, def); return 0; } static void ClearCounters(AActor *self) { self->ClearCounters(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, ClearCounters, ClearCounters) { PARAM_SELF_PROLOGUE(AActor); self->ClearCounters(); return 0; } static int GetModifiedDamage(AActor *self, int type, int damage, bool passive) { return self->GetModifiedDamage(ENamedName(type), damage, passive); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetModifiedDamage, GetModifiedDamage) { PARAM_SELF_PROLOGUE(AActor); PARAM_NAME(type); PARAM_INT(damage); PARAM_BOOL(passive); ACTION_RETURN_INT(self->GetModifiedDamage(type, damage, passive)); } static int ApplyDamageFactor(AActor *self, int type, int damage) { return self->ApplyDamageFactor(ENamedName(type), damage); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, ApplyDamageFactor, ApplyDamageFactor) { PARAM_SELF_PROLOGUE(AActor); PARAM_NAME(type); PARAM_INT(damage); ACTION_RETURN_INT(self->ApplyDamageFactor(type, damage)); } double GetDefaultSpeed(PClassActor *type); DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetDefaultSpeed, GetDefaultSpeed) { PARAM_PROLOGUE; PARAM_CLASS(type, AActor); ACTION_RETURN_FLOAT(GetDefaultSpeed(type)); } static int isTeammate(AActor *self, AActor *other) { return self->IsTeammate(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, isTeammate, isTeammate) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_BOOL(self->IsTeammate(other)); } static int GetSpecies(AActor *self) { return self->GetSpecies(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetSpecies, GetSpecies) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(self->GetSpecies()); } static int isFriend(AActor *self, AActor *other) { return self->IsFriend(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, isFriend, isFriend) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_BOOL(self->IsFriend(other)); } static int isHostile(AActor *self, AActor *other) { return self->IsHostile(PARAM_NULLCHECK(other, other)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, isHostile, isHostile) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(other, AActor); ACTION_RETURN_BOOL(self->IsHostile(other)); } static FTerrainDef *GetFloorTerrain(AActor *self) { return &Terrains[P_GetThingFloorType(self)]; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetFloorTerrain, GetFloorTerrain) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_POINTER(GetFloorTerrain(self)); } static int P_FindUniqueTID(FLevelLocals *Level, int start, int limit) { return Level->FindUniqueTID(start, limit); } DEFINE_ACTION_FUNCTION_NATIVE(FLevelLocals, FindUniqueTid, P_FindUniqueTID) { PARAM_SELF_STRUCT_PROLOGUE(FLevelLocals); PARAM_INT(start); PARAM_INT(limit); ACTION_RETURN_INT(P_FindUniqueTID(self, start, limit)); } static void RemoveFromHash(AActor *self) { self->RemoveFromHash(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RemoveFromHash, RemoveFromHash) { PARAM_SELF_PROLOGUE(AActor); self->RemoveFromHash(); return 0; } static void ChangeTid(AActor *self, int tid) { self->RemoveFromHash(); self->tid = tid; self->AddToHash(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, ChangeTid, ChangeTid) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(tid); ChangeTid(self, tid); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, FindFloorCeiling, P_FindFloorCeiling) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(flags); P_FindFloorCeiling(self, flags); return 0; } static int TeleportMove(AActor *self, double x, double y, double z, bool telefrag, bool modify) { return P_TeleportMove(self, DVector3(x, y, z), telefrag, modify); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, TeleportMove, TeleportMove) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_BOOL(telefrag); PARAM_BOOL(modify); ACTION_RETURN_BOOL(P_TeleportMove(self, DVector3(x, y, z), telefrag, modify)); } static double ZS_GetFriction(AActor *self, double *mf) { double friction; *mf = P_GetMoveFactor(self, &friction); return friction; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetFriction, ZS_GetFriction) { PARAM_SELF_PROLOGUE(AActor); double friction, movefactor = P_GetMoveFactor(self, &friction); if (numret > 1) ret[1].SetFloat(movefactor); if (numret > 0) ret[0].SetFloat(friction); return numret; } static int CheckPosition(AActor *self, double x, double y, bool actorsonly, FCheckPosition *tm) { if (tm) { return (P_CheckPosition(self, DVector2(x, y), *tm, actorsonly)); } else { return (P_CheckPosition(self, DVector2(x, y), actorsonly)); } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckPosition, CheckPosition) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_BOOL(actorsonly); PARAM_POINTER(tm, FCheckPosition); ACTION_RETURN_BOOL(CheckPosition(self, x, y, actorsonly, tm)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, TestMobjLocation, P_TestMobjLocation) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(P_TestMobjLocation(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, TestMobjZ, P_TestMobjZ) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(quick); AActor *on = nullptr; bool retv = P_TestMobjZ(self, quick, &on); if (numret > 1) ret[1].SetObject(on); if (numret > 0) ret[0].SetInt(retv); return numret; } static int TryMove(AActor *self ,double x, double y, int dropoff, bool missilecheck, FCheckPosition *tm) { if (tm == nullptr) { return (P_TryMove(self, DVector2(x, y), dropoff, nullptr, missilecheck)); } else { return (P_TryMove(self, DVector2(x, y), dropoff, nullptr, *tm, missilecheck)); } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, TryMove, TryMove) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_INT(dropoff); PARAM_BOOL(missilecheck); PARAM_POINTER(tm, FCheckPosition); ACTION_RETURN_BOOL(TryMove(self, x, y, dropoff, missilecheck, tm)); } static int CheckMove(AActor *self ,double x, double y, int flags, FCheckPosition *tm) { if (tm == nullptr) { return (P_CheckMove(self, DVector2(x, y), flags)); } else { return (P_CheckMove(self, DVector2(x, y), *tm, flags)); } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckMove, CheckMove) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_INT(flags); PARAM_POINTER(tm, FCheckPosition); ACTION_RETURN_BOOL(CheckMove(self, x, y, flags, tm)); } static double AimLineAttack(AActor *self, double angle, double distance, FTranslatedLineTarget *pLineTarget, double vrange, int flags, AActor *target, AActor *friender) { return P_AimLineAttack(self, angle, distance, pLineTarget, vrange, flags, target, friender).Degrees; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, AimLineAttack, AimLineAttack) { PARAM_SELF_PROLOGUE(AActor); PARAM_ANGLE(angle); PARAM_FLOAT(distance); PARAM_OUTPOINTER(pLineTarget, FTranslatedLineTarget); PARAM_ANGLE(vrange); PARAM_INT(flags); PARAM_OBJECT(target, AActor); PARAM_OBJECT(friender, AActor); ACTION_RETURN_FLOAT(P_AimLineAttack(self, angle, distance, pLineTarget, vrange, flags, target, friender).Degrees); } static AActor *ZS_LineAttack(AActor *self, double angle, double distance, double pitch, int damage, int damageType, PClassActor *puffType, int flags, FTranslatedLineTarget *victim, double offsetz, double offsetforward, double offsetside, int *actualdamage) { if (puffType == nullptr) puffType = PClass::FindActor(NAME_BulletPuff); // P_LineAttack does not work without a puff to take info from. return P_LineAttack(self, angle, distance, pitch, damage, ENamedName(damageType), puffType, flags, victim, actualdamage, offsetz, offsetforward, offsetside); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LineAttack, ZS_LineAttack) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(angle); PARAM_FLOAT(distance); PARAM_FLOAT(pitch); PARAM_INT(damage); PARAM_INT(damageType); PARAM_CLASS(puffType, AActor); PARAM_INT(flags); PARAM_OUTPOINTER(victim, FTranslatedLineTarget); PARAM_FLOAT(offsetz); PARAM_FLOAT(offsetforward); PARAM_FLOAT(offsetside); int acdmg; auto puff = ZS_LineAttack(self, angle, distance, pitch, damage, damageType, puffType, flags, victim, offsetz, offsetforward, offsetside, &acdmg); if (numret > 0) ret[0].SetObject(puff); if (numret > 1) ret[1].SetInt(acdmg), numret = 2; return numret; } static int LineTrace(AActor *self, double angle, double distance, double pitch, int flags, double offsetz, double offsetforward, double offsetside, FLineTraceData *data) { return P_LineTrace(self,angle,distance,pitch,flags,offsetz,offsetforward,offsetside,data); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LineTrace, LineTrace) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(angle); PARAM_FLOAT(distance); PARAM_FLOAT(pitch); PARAM_INT(flags); PARAM_FLOAT(offsetz); PARAM_FLOAT(offsetforward); PARAM_FLOAT(offsetside); PARAM_OUTPOINTER(data, FLineTraceData); ACTION_RETURN_BOOL(P_LineTrace(self,angle,distance,pitch,flags,offsetz,offsetforward,offsetside,data)); } static void TraceBleedAngle(AActor *self, int damage, double angle, double pitch) { P_TraceBleed(damage, self, angle, pitch); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, TraceBleedAngle, TraceBleedAngle) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(damage); PARAM_FLOAT(angle); PARAM_FLOAT(pitch); P_TraceBleed(damage, self, angle, pitch); return 0; } static void TraceBleedTLT(FTranslatedLineTarget *self, int damage, AActor *missile) { P_TraceBleed(damage, self, PARAM_NULLCHECK(missile, missile)); } DEFINE_ACTION_FUNCTION_NATIVE(_FTranslatedLineTarget, TraceBleed, TraceBleedTLT) { PARAM_SELF_STRUCT_PROLOGUE(FTranslatedLineTarget); PARAM_INT(damage); PARAM_OBJECT_NOT_NULL(missile, AActor); P_TraceBleed(damage, self, missile); return 0; } static void TraceBleedA(AActor *self, int damage, AActor *missile) { if (missile) P_TraceBleed(damage, self, missile); else P_TraceBleed(damage, self); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, TraceBleed, TraceBleedA) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(damage); PARAM_OBJECT(missile, AActor); TraceBleedA(self, damage, missile); return 0; } static void RailAttack(AActor *self, FRailParams *p) { p->source = self; P_RailAttack(p); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RailAttack, RailAttack) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER(p, FRailParams); RailAttack(self, p); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, UsePuzzleItem, P_UsePuzzleItem) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(puzznum); ACTION_RETURN_BOOL(P_UsePuzzleItem(self, puzznum)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetRadiusDamage, P_GetRadiusDamage) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT(thing, AActor); PARAM_INT(damage); PARAM_INT(distance); PARAM_INT(fulldmgdistance); PARAM_BOOL(oldradiusdmg); ACTION_RETURN_INT(P_GetRadiusDamage(self, thing, damage, distance, fulldmgdistance, oldradiusdmg)); } static int RadiusAttack(AActor *self, AActor *bombsource, int bombdamage, int bombdistance, int damagetype, int flags, int fulldamagedistance) { return P_RadiusAttack(self, bombsource, bombdamage, bombdistance, ENamedName(damagetype), flags, fulldamagedistance); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RadiusAttack, RadiusAttack) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT(bombsource, AActor); PARAM_INT(bombdamage); PARAM_INT(bombdistance); PARAM_INT(damagetype); PARAM_INT(flags); PARAM_INT(fulldamagedistance); ACTION_RETURN_INT(RadiusAttack(self, bombsource, bombdamage, bombdistance, damagetype, flags, fulldamagedistance)); } static int ZS_GetSpriteIndex(int sprt) { return GetSpriteIndex(FName(ENamedName(sprt)).GetChars(), false); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetSpriteIndex, ZS_GetSpriteIndex) { PARAM_PROLOGUE; PARAM_INT(sprt); ACTION_RETURN_INT(ZS_GetSpriteIndex(sprt)); } static PClassActor *ZS_GetReplacement(PClassActor *c) { return c->GetReplacement(currentVMLevel); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetReplacement, ZS_GetReplacement) { PARAM_PROLOGUE; PARAM_POINTER(c, PClassActor); ACTION_RETURN_POINTER(ZS_GetReplacement(c)); } static PClassActor *ZS_GetReplacee(PClassActor *c) { return c->GetReplacee(currentVMLevel); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetReplacee, ZS_GetReplacee) { PARAM_PROLOGUE; PARAM_POINTER(c, PClassActor); ACTION_RETURN_POINTER(ZS_GetReplacee(c)); } static void DrawSplash(AActor *self, int count, double angle, int kind) { P_DrawSplash(self->Level, count, self->Pos(), angle, kind); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, DrawSplash, DrawSplash) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(count); PARAM_FLOAT(angle); PARAM_INT(kind); P_DrawSplash(self->Level, count, self->Pos(), angle, kind); return 0; } static void UnlinkFromWorld(AActor *self, FLinkContext *ctx) { self->UnlinkFromWorld(ctx); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, UnlinkFromWorld, UnlinkFromWorld) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER(ctx, FLinkContext); self->UnlinkFromWorld(ctx); // fixme return 0; } static void LinkToWorld(AActor *self, FLinkContext *ctx) { self->LinkToWorld(ctx); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LinkToWorld, LinkToWorld) { PARAM_SELF_PROLOGUE(AActor); PARAM_POINTER(ctx, FLinkContext); self->LinkToWorld(ctx); return 0; } static void SetOrigin(AActor *self, double x, double y, double z, bool moving) { self->SetOrigin(x, y, z, moving); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SetOrigin, SetOrigin) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_BOOL(moving); self->SetOrigin(x, y, z, moving); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RoughMonsterSearch, P_RoughMonsterSearch) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(distance); PARAM_BOOL(onlyseekable); PARAM_BOOL(frontonly); ACTION_RETURN_OBJECT(P_RoughMonsterSearch(self, distance, onlyseekable, frontonly)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckSight, P_CheckSight) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT_NOT_NULL(target, AActor); PARAM_INT(flags); ACTION_RETURN_BOOL(P_CheckSight(self, target, flags)); } static void GiveSecret(AActor *self, bool printmessage, bool playsound) { P_GiveSecret(self->Level, self, printmessage, playsound, -1); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GiveSecret, GiveSecret) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(printmessage); PARAM_BOOL(playsound); GiveSecret(self, printmessage, playsound); return 0; } static int ZS_GetMissileDamage(AActor *self, int mask, int add, int pick_pointer) { self = COPY_AAPTR(self, pick_pointer); return self ? self->GetMissileDamage(mask, add) : 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetMissileDamage, ZS_GetMissileDamage) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(mask); PARAM_INT(add); PARAM_INT(pick_pointer); ACTION_RETURN_INT(ZS_GetMissileDamage(self, mask, add, pick_pointer)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, SoundAlert, P_NoiseAlert) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT(target, AActor); PARAM_BOOL(splash); PARAM_FLOAT(maxdist); P_NoiseAlert(self, target, splash, maxdist); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, HitFriend, P_HitFriend) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(P_HitFriend(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, MonsterMove, P_Move) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(P_Move(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, NewChaseDir, P_NewChaseDir) { PARAM_SELF_PROLOGUE(AActor); P_NewChaseDir(self); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, RandomChaseDir, P_RandomChaseDir) { PARAM_SELF_PROLOGUE(AActor); P_RandomChaseDir(self); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, IsVisible, P_IsVisible) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT(other, AActor); PARAM_BOOL(allaround); PARAM_POINTER(params, FLookExParams); ACTION_RETURN_BOOL(P_IsVisible(self, other, allaround, params)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LookForMonsters, P_LookForMonsters) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(P_LookForMonsters(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LookForTID, P_LookForTID) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(allaround); PARAM_POINTER(params, FLookExParams); ACTION_RETURN_BOOL(P_LookForTID(self, allaround, params)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LookForEnemies, P_LookForEnemies) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(allaround); PARAM_POINTER(params, FLookExParams); ACTION_RETURN_BOOL(P_LookForEnemies(self, allaround, params)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, LookForPlayers, P_LookForPlayers) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(allaround); PARAM_POINTER(params, FLookExParams); ACTION_RETURN_BOOL(P_LookForPlayers(self, allaround, params)); } static int CheckMonsterUseSpecials(AActor *self) { spechit_t spec; int good = 0; if (!(self->flags6 & MF6_NOTRIGGER)) { while (spechit.Pop (spec)) { // [RH] let monsters push lines, as well as use them if (((self->flags4 & MF4_CANUSEWALLS) && P_ActivateLine (spec.line, self, 0, SPAC_Use)) || ((self->flags2 & MF2_PUSHWALL) && P_ActivateLine (spec.line, self, 0, SPAC_Push))) { good |= spec.line == self->BlockingLine ? 1 : 2; } } } else spechit.Clear(); return good; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckMonsterUseSpecials, CheckMonsterUseSpecials) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(CheckMonsterUseSpecials(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_Wander, A_Wander) { PARAM_SELF_PROLOGUE(AActor); PARAM_INT(flags); A_Wander(self, flags); return 0; } //========================================================================== // // A_Chase and variations // //========================================================================== static void A_FastChase(AActor *self) { A_DoChase(self, true, self->MeleeState, self->MissileState, true, true, false, 0); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_FastChase, A_FastChase) { PARAM_SELF_PROLOGUE(AActor); A_FastChase(self); return 0; } static void A_VileChase(AActor *self) { if (!P_CheckForResurrection(self, true)) { A_DoChase(self, false, self->MeleeState, self->MissileState, true, gameinfo.nightmarefast, false, 0); } } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_VileChase, A_VileChase) { PARAM_SELF_PROLOGUE(AActor); A_VileChase(self); return 0; } static void A_ExtChase(AActor *self, bool domelee, bool domissile, bool playactive, bool nightmarefast) { // Now that A_Chase can handle state label parameters, this function has become rather useless... A_DoChase(self, false, domelee ? self->MeleeState : NULL, domissile ? self->MissileState : NULL, playactive, nightmarefast, false, 0); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_ExtChase, A_ExtChase) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(domelee); PARAM_BOOL(domissile); PARAM_BOOL(playactive); PARAM_BOOL(nightmarefast); A_ExtChase(self, domelee, domissile, playactive, nightmarefast); return 0; } int CheckForResurrection(AActor *self) { return P_CheckForResurrection(self, false); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_CheckForResurrection, CheckForResurrection) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(P_CheckForResurrection(self, false)); } static void ZS_Face(AActor *self, AActor *faceto, double max_turn, double max_pitch, double ang_offset, double pitch_offset, int flags, double z_add) { A_Face(self, faceto, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_Face, ZS_Face) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT(faceto, AActor) PARAM_ANGLE(max_turn) PARAM_ANGLE(max_pitch) PARAM_ANGLE(ang_offset) PARAM_ANGLE(pitch_offset) PARAM_INT(flags) PARAM_FLOAT(z_add) A_Face(self, faceto, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_add); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckBossDeath, CheckBossDeath) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(CheckBossDeath(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_BossDeath, A_BossDeath) { PARAM_SELF_PROLOGUE(AActor); A_BossDeath(self); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, Substitute, DObject::StaticPointerSubstitution) { PARAM_SELF_PROLOGUE(AActor); PARAM_OBJECT(replace, AActor); DObject::StaticPointerSubstitution(self, replace); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, GetSpawnableType, P_GetSpawnableType) { PARAM_PROLOGUE; PARAM_INT(num); ACTION_RETURN_POINTER(P_GetSpawnableType(num)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, A_NoBlocking, A_Unblock) { PARAM_SELF_PROLOGUE(AActor); PARAM_BOOL(drop); A_Unblock(self, drop); return 0; } //===================================================================================== // // Inventory exports // //===================================================================================== DEFINE_ACTION_FUNCTION_NATIVE(AInventory, PrintPickupMessage, PrintPickupMessage) { PARAM_PROLOGUE; PARAM_BOOL(localview); PARAM_STRING(str); PrintPickupMessage(localview, str); return 0; } //===================================================================================== // // Key exports // //===================================================================================== DEFINE_ACTION_FUNCTION_NATIVE(AKey, GetKeyTypeCount, P_GetKeyTypeCount) { PARAM_PROLOGUE; ACTION_RETURN_INT(P_GetKeyTypeCount()); } DEFINE_ACTION_FUNCTION_NATIVE(AKey, GetKeyType, P_GetKeyType) { PARAM_PROLOGUE; PARAM_INT(num); ACTION_RETURN_POINTER(P_GetKeyType(num)); } //===================================================================================== // // 3D Floor exports // //===================================================================================== int CheckFor3DFloorHit(AActor *self, double z, bool trigger) { return P_CheckFor3DFloorHit(self, z, trigger); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckFor3DFloorHit, CheckFor3DFloorHit) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(z); PARAM_BOOL(trigger); ACTION_RETURN_BOOL(P_CheckFor3DFloorHit(self, z, trigger)); } int CheckFor3DCeilingHit(AActor *self, double z, bool trigger) { return P_CheckFor3DCeilingHit(self, z, trigger); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, CheckFor3DCeilingHit, CheckFor3DCeilingHit) { PARAM_SELF_PROLOGUE(AActor); PARAM_FLOAT(z); PARAM_BOOL(trigger); ACTION_RETURN_BOOL(P_CheckFor3DCeilingHit(self, z, trigger)); } static int isFrozen(AActor *self) { return self->isFrozen(); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, isFrozen, isFrozen) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_BOOL(isFrozen(self)); } //===================================================================================== // // compat flags. These two are the only ones that get checked in script code // so anything more complex isn't really needed. // //===================================================================================== static int compat_limitpain_(AActor *self) { return self->Level->i_compatflags & COMPATF_LIMITPAIN; } static int compat_mushroom_(AActor *self) { return self->Level->i_compatflags & COMPATF_MUSHROOM; } DEFINE_ACTION_FUNCTION_NATIVE(AActor, compat_limitpain, compat_limitpain_) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(compat_limitpain_(self)); } DEFINE_ACTION_FUNCTION_NATIVE(AActor, compat_mushroom, compat_mushroom_) { PARAM_SELF_PROLOGUE(AActor); ACTION_RETURN_INT(compat_mushroom_(self)); } //=========================================================================== // // PlayerPawn functions // //=========================================================================== DEFINE_ACTION_FUNCTION_NATIVE(APlayerPawn, MarkPlayerSounds, S_MarkPlayerSounds) { PARAM_SELF_PROLOGUE(AActor); S_MarkPlayerSounds(self); return 0; } static void GetPrintableDisplayNameJit(PClassActor *cls, FString *result) { *result = cls->GetDisplayName(); } DEFINE_ACTION_FUNCTION_NATIVE(APlayerPawn, GetPrintableDisplayName, GetPrintableDisplayNameJit) { PARAM_PROLOGUE; PARAM_CLASS(type, AActor); ACTION_RETURN_STRING(type->GetDisplayName()); } DEFINE_FIELD(DThinker, Level) DEFINE_FIELD(AActor, snext) 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) DEFINE_FIELD(AActor, renderradius) 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, FloatBobStrength) 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, Blocking3DFloor) DEFINE_FIELD(AActor, BlockingCeiling) DEFINE_FIELD(AActor, BlockingFloor) 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) DEFINE_FIELD(AActor, fountaincolor) DEFINE_FIELD(AActor, CameraHeight) DEFINE_FIELD(AActor, CameraFOV) DEFINE_FIELD(AActor, RadiusDamageFactor) DEFINE_FIELD(AActor, SelfDamageFactor) DEFINE_FIELD(AActor, StealthAlpha) DEFINE_FIELD(AActor, WoundHealth) DEFINE_FIELD(AActor, BloodColor) DEFINE_FIELD(AActor, BloodTranslation) DEFINE_FIELD(AActor, RenderHidden) DEFINE_FIELD(AActor, RenderRequired) DEFINE_FIELD(AActor, friendlyseeblocks) DEFINE_FIELD(AActor, SpawnTime) DEFINE_FIELD(AActor, InventoryID) DEFINE_FIELD_X(FCheckPosition, FCheckPosition, thing); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, pos); DEFINE_FIELD_NAMED_X(FCheckPosition, FCheckPosition, sector, cursector); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, floorz); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, ceilingz); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, dropoffz); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, floorpic); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, floorterrain); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, floorsector); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, ceilingpic); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, ceilingsector); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, touchmidtex); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, abovemidtex); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, floatok); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, FromPMove); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, ceilingline); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, stepthing); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, DoRipping); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, portalstep); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, portalgroup); DEFINE_FIELD_X(FCheckPosition, FCheckPosition, PushTime); DEFINE_FIELD_X(FRailParams, FRailParams, source); DEFINE_FIELD_X(FRailParams, FRailParams, damage); DEFINE_FIELD_X(FRailParams, FRailParams, offset_xy); DEFINE_FIELD_X(FRailParams, FRailParams, offset_z); DEFINE_FIELD_X(FRailParams, FRailParams, color1); DEFINE_FIELD_X(FRailParams, FRailParams, color2); DEFINE_FIELD_X(FRailParams, FRailParams, maxdiff); DEFINE_FIELD_X(FRailParams, FRailParams, flags); DEFINE_FIELD_X(FRailParams, FRailParams, puff); DEFINE_FIELD_X(FRailParams, FRailParams, angleoffset); DEFINE_FIELD_X(FRailParams, FRailParams, pitchoffset); DEFINE_FIELD_X(FRailParams, FRailParams, distance); DEFINE_FIELD_X(FRailParams, FRailParams, duration); DEFINE_FIELD_X(FRailParams, FRailParams, sparsity); DEFINE_FIELD_X(FRailParams, FRailParams, drift); DEFINE_FIELD_X(FRailParams, FRailParams, spawnclass); DEFINE_FIELD_X(FRailParams, FRailParams, SpiralOffset); DEFINE_FIELD_X(FRailParams, FRailParams, limit); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, HitActor); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, HitLine); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, HitSector); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, Hit3DFloor); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, HitTexture); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, HitLocation); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, Distance); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, NumPortals); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, LineSide); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, LinePart); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, SectorPlane); DEFINE_FIELD_X(FLineTraceData, FLineTraceData, HitType);