add new apis

Author: Hedgefog

api_advanced_pushing.sma

@@ -0,0 +1,229 @@
+#pragma semicolon 1
+
+#include <amxmodx>
+#include <hamsandwich>
+#include <fakemeta>
+#include <xs>
+
+#include <api_advanced_pushing>
+
+#define PLAYER_PREVENT_CLIMB (1<<5)
+
+#define IS_PLAYER(%1) (%1 >= 1 && %1 <= MaxClients)
+
+new Float:g_flPlayerReleaseClimbBlock[MAX_PLAYERS + 1];
+
+public plugin_init() {
+  register_plugin("[API] Advanced Pushing", "1.0.0", "Hedgehog Fog");
+
+  RegisterHamPlayer(Ham_Spawn, "HamHook_Player_Spawn_Post", .Post = 1);
+  RegisterHamPlayer(Ham_Player_PostThink, "HamHook_Player_PostThink_Post", .Post = 1);
+}
+
+public plugin_natives() {
+  register_library("api_advanced_pushing");
+  register_native("APS_Push", "Native_Push");
+  register_native("APS_PushFromOrigin", "Native_PushFromOrigin");
+  register_native("APS_PushFromBBox", "Native_PushFromBBox");
+}
+
+public Native_Push(iPluginId, iArgc) {
+  static pEntity = get_param(1);
+  static Float:vecForce[3]; get_array_f(2, vecForce, sizeof(vecForce));
+  static APS_Flags:iFlags = APS_Flags:get_param(3);
+  @Base_Push(pEntity, vecForce, iFlags);
+}
+
+public Native_PushFromOrigin(iPluginId, iArgc) {
+  static pEntity; pEntity = get_param(1);
+  static Float:flForce; flForce = get_param_f(2);
+  static Float:vecPushOrigin[3]; get_array_f(3, vecPushOrigin, sizeof(vecPushOrigin));
+  static APS_Flags:iFlags; iFlags = APS_Flags:get_param(4);
+
+  @Base_PushFromOrigin(pEntity, flForce, vecPushOrigin, iFlags);
+}
+
+public Native_PushFromBBox(iPluginId, iArgc) {
+  static pEntity; pEntity = get_param(1);
+  static Float:flForce; flForce = get_param_f(2);
+  static Float:vecAbsMin[3]; get_array_f(3, vecAbsMin, sizeof(vecAbsMin));
+  static Float:vecAbsMax[3]; get_array_f(4, vecAbsMax, sizeof(vecAbsMax));
+  static Float:flMinDepthRatio; flMinDepthRatio = get_param_f(5);
+  static Float:flMaxDepthRatio; flMaxDepthRatio = get_param_f(6);
+  static Float:flDepthInfluenceMin; flDepthInfluenceMin = get_param_f(7);
+  static Float:flDepthInfluenceMax; flDepthInfluenceMax = get_param_f(8);
+  static APS_Flags:iFlags; iFlags = APS_Flags:get_param(9);
+
+  @Base_PushFromBBox(pEntity, flForce, vecAbsMin, vecAbsMax, flMinDepthRatio, flMaxDepthRatio, flDepthInfluenceMin, flDepthInfluenceMax, iFlags);
+}
+
+public HamHook_Player_Spawn_Post(pPlayer) {
+  @Player_ReleaseClimbPrevention(pPlayer);
+}
+
+public HamHook_Player_PostThink_Post(pPlayer) {
+  if (g_flPlayerReleaseClimbBlock[pPlayer] && g_flPlayerReleaseClimbBlock[pPlayer] <= get_gametime()) {
+    @Player_ReleaseClimbPrevention(pPlayer);
+  }
+}
+
+@Player_SetClimbPrevention(pPlayer, bool:bValue) {
+  new iPlayerFlags = pev(pPlayer, pev_iuser3);
+
+  if (bValue) {
+    iPlayerFlags |= PLAYER_PREVENT_CLIMB;
+  } else {
+    iPlayerFlags &= ~PLAYER_PREVENT_CLIMB;
+  }
+
+  set_pev(pPlayer, pev_iuser3, iPlayerFlags);
+}
+
+@Player_ReleaseClimbPrevention(this) {
+  if (g_flPlayerReleaseClimbBlock[this]) {
+    @Player_SetClimbPrevention(this, false);
+    g_flPlayerReleaseClimbBlock[this] = 0.0;
+  }
+}
+
+@Base_Push(this, const Float:vecForce[3], APS_Flags:iFlags) {
+  static Float:vecVelocity[3]; pev(this, pev_velocity, vecVelocity);
+
+  if (iFlags & APS_Flag_AddForce) {
+    xs_vec_add(vecVelocity, vecForce, vecVelocity);
+  } else {
+    for (new i = 0; i < 3; ++i) {
+      if (iFlags & APS_Flag_OverlapMode) {
+        vecVelocity[i] = vecForce[i] ? vecForce[i] : vecVelocity[i];
+      } else {
+        vecVelocity[i] = vecForce[i];
+      }
+    }
+  }
+
+  set_pev(this, pev_velocity, vecVelocity);
+
+  if (IS_PLAYER(this) && ~pev(this, pev_iuser3) & PLAYER_PREVENT_CLIMB) {
+    @Player_SetClimbPrevention(this, true);
+    g_flPlayerReleaseClimbBlock[this] = get_gametime() + 0.1;
+  }
+}
+
+@Base_PushFromOrigin(this, Float:flForce, Float:vecPushOrigin[3], APS_Flags:iFlags) {
+  static Float:vecOrigin[3]; pev(this, pev_origin, vecOrigin);
+
+  static Float:vecForce[3];
+  xs_vec_sub(vecOrigin, vecPushOrigin, vecForce);
+  xs_vec_normalize(vecForce, vecForce);
+  xs_vec_mul_scalar(vecForce, flForce, vecForce);
+
+  @Base_Push(this, vecForce, iFlags);
+}
+
+@Base_PushFromBBox(
+  this,
+  Float:flForce,
+  const Float:vecAbsMin[3],
+  const Float:vecAbsMax[3],
+  Float:flMinDepthRatio,
+  Float:flMaxDepthRatio,
+  Float:flDepthInfluenceMin,
+  Float:flDepthInfluenceMax,
+  APS_Flags:iFlags
+) {
+  static Float:vecOrigin[3]; pev(this, pev_origin, vecOrigin);
+  static Float:vecToucherAbsMin[3]; pev(this, pev_absmin, vecToucherAbsMin);
+  static Float:vecToucherAbsMax[3]; pev(this, pev_absmax, vecToucherAbsMax);
+
+  // Find and check intersection point
+  for (new iAxis = 0; iAxis < 3; ++iAxis) {
+    if (vecOrigin[iAxis] < vecAbsMin[iAxis]) {
+      vecOrigin[iAxis] = vecToucherAbsMax[iAxis];
+    } else if (vecOrigin[iAxis] > vecAbsMax[iAxis]) {
+      vecOrigin[iAxis] = vecToucherAbsMin[iAxis];
+    }
+
+    if (vecAbsMin[iAxis] >= vecOrigin[iAxis]) return;
+    if (vecAbsMax[iAxis] <= vecOrigin[iAxis]) return;
+  }
+
+  new iClosestAxis = -1;
+  new pTrace = create_tr2();
+  static Float:vecOffset[3]; xs_vec_copy(Float:{0.0, 0.0, 0.0}, vecOffset);
+
+  for (new iAxis = 0; iAxis < 3; ++iAxis) {
+    // Calculates the toucher's offset relative to the current axis
+    static Float:flSideOffsets[2];
+    flSideOffsets[0] = vecAbsMin[iAxis] - vecOrigin[iAxis];
+    flSideOffsets[1] = vecAbsMax[iAxis] - vecOrigin[iAxis];
+
+    if (iAxis == 2 && iClosestAxis != -1) {
+      break;
+    }
+
+    for (new side = 0; side < 2; ++side) {
+      // Check exit from current side
+      static Float:vecTarget[3];
+      xs_vec_copy(vecOrigin, vecTarget);
+      vecTarget[iAxis] += flSideOffsets[side];
+      engfunc(EngFunc_TraceMonsterHull, this, vecOrigin, vecTarget, IGNORE_MONSTERS | IGNORE_GLASS, this, pTrace);
+
+      static Float:flFraction;
+      get_tr2(pTrace, TR_flFraction, flFraction);
+
+      // No exit, cannot push this way
+      if (flFraction != 1.0) {
+        flSideOffsets[side] = 0.0;
+      }
+
+      if (iAxis != 2) {
+        // Save minimum offset, but ignore zero offsets
+        if (!vecOffset[iAxis] || (flSideOffsets[side] && floatabs(flSideOffsets[side]) < floatabs(vecOffset[iAxis]))) {
+          vecOffset[iAxis] = flSideOffsets[side];
+        }
+      } else {
+        // Priority on bottom side
+        if (flSideOffsets[0]) {
+          vecOffset[iAxis] = flSideOffsets[0];
+        }
+      }
+
+      // Find closest axis to push
+      if (vecOffset[iAxis]) {
+        if (iClosestAxis == -1 || floatabs(vecOffset[iAxis]) < floatabs(vecOffset[iClosestAxis])) {
+          iClosestAxis = iAxis;
+        }
+      }
+    }
+  }
+
+  free_tr2(pTrace);
+
+  // Push by closest axis
+  if (iClosestAxis == -1) return;
+  
+  static iPushDir; iPushDir = vecOffset[iClosestAxis] > 0.0 ? 1 : -1;
+  static Float:vecSize[3]; xs_vec_sub(vecAbsMax, vecAbsMin, vecSize);
+  static Float:flDepthRatio; flDepthRatio = floatabs(vecOffset[iClosestAxis]) / (vecSize[iClosestAxis] / 2);
+
+  flDepthRatio = floatclamp(flDepthRatio, flMinDepthRatio, flMaxDepthRatio);
+
+  static Float:vecForce[3]; xs_vec_copy(Float:{0.0, 0.0, 0.0}, vecForce);
+  
+  static bool:bInInfluence; bInInfluence = (
+    flDepthRatio >= flDepthInfluenceMin &&
+    flDepthRatio <= flDepthInfluenceMax
+  );
+
+  if (bInInfluence) {
+    vecForce[iClosestAxis] = flForce * flDepthRatio * iPushDir;
+  } else {
+    vecForce[iClosestAxis] = flForce * iPushDir;
+
+    if (iFlags & APS_Flag_AddForceInfluenceMode) {
+      iFlags &= ~APS_Flag_AddForce;
+    }
+  }
+
+  @Base_Push(this, vecForce, iFlags);
+}