L L4D2node

CGrabController::AttachEntity

0x004ec5e0 · 1868 bytes · __cdecl

_ZN15CGrabController12AttachEntityEP11CBasePlayerP11CBaseEntityP14IPhysicsObjectbRK6Vectorb

Decompiled

undefined (6 params)

/* CGrabController::AttachEntity(CBasePlayer*, CBaseEntity*, IPhysicsObject*, bool, Vector const&,
   bool) */

void CGrabController::AttachEntity
               (CBasePlayer *param_1,CBaseEntity *param_2,IPhysicsObject *param_3,bool param_4,
               Vector *param_5,bool param_6)

{
  Vector *pVVar1;
  float fVar2;
  float fVar3;
  float fVar4;
  CBasePlayer CVar5;
  ushort uVar6;
  int iVar7;
  int iVar8;
  int *piVar9;
  undefined4 *puVar10;
  float *pfVar11;
  CPhysicsProp *this;
  float *pfVar12;
  float *pfVar13;
  CBasePlayer *pCVar14;
  int iVar15;
  Vector *pVVar16;
  Vector *pVVar17;
  longdouble lVar18;
  float fVar19;
  float fVar20;
  float fVar21;
  float fVar22;
  float fVar23;
  undefined3 in_stack_00000011;
  QAngle *pQVar24;
  int local_10a4;
  undefined4 local_1098;
  Vector local_1094 [12];
  QAngle local_1088 [12];
  float local_107c [3];
  Vector local_1070 [4];
  float afStack_106c [8];
  undefined4 local_104c;
  undefined4 local_1048;
  undefined4 local_1044;
  undefined4 local_101c [1027];
  
  piVar9 = *(int **)(param_2 + 0x238);
  if (piVar9 != (int *)0x0) {
    iVar7 = (**(code **)(*piVar9 + 0x9c))(piVar9);
    iVar8 = (**(code **)(*(int *)_param_4 + 0x9c))(_param_4);
    PhysicsImpactSound(param_2,_param_4,6,iVar8,iVar7,1.0,64.0);
  }
  (**(code **)(*(int *)_param_4 + 0xc4))(_param_4,local_1094,local_1088);
  if (((byte)param_2[0x14d] & 8) != 0) {
    CBaseEntity::CalcAbsolutePosition(param_2);
  }
  Pickup_GetPreferredCarryAngles
            ((CBaseEntity *)param_3,(CBasePlayer *)param_2,(matrix3x4_t *)(param_2 + 0x28c),
             local_1088);
  CVar5 = (CBasePlayer)CBaseEntity::BlocksLOS((CBaseEntity *)param_3);
  param_1[0x60] = CVar5;
  CBaseEntity::SetBlocksLOS((CBaseEntity *)param_3,false);
  piVar9 = (int *)(**(code **)(*physenv + 0x78))(physenv,param_1);
  *(int **)(param_1 + 0x207c) = piVar9;
  (**(code **)(*piVar9 + 0xc))(piVar9,_param_4,1);
  (**(code **)(*(int *)_param_4 + 100))(_param_4);
  uVar6 = (**(code **)(*(int *)_param_4 + 0x50))(_param_4);
  (**(code **)(*(int *)_param_4 + 0x4c))(_param_4,uVar6 | 4);
  SetTargetPosition((CGrabController *)param_1,local_1094,local_1088);
  if (param_3 == (IPhysicsObject *)0x0) {
    *(undefined4 *)(param_1 + 0x2068) = 0xffffffff;
  }
  else {
    puVar10 = (undefined4 *)(**(code **)(*(int *)param_3 + 0xc))(param_3);
    *(undefined4 *)(param_1 + 0x2068) = *puVar10;
  }
  iVar7 = (**(code **)(*(int *)param_3 + 0x2b8))(param_3,local_101c,0x400);
  local_1098 = 0x41200000;
  *(undefined4 *)(param_1 + 100) = 0;
  fVar19 = (float)iVar7 * 0.13333334;
  if (fVar19 <= 1.0) {
    fVar19 = 1.0;
  }
  if (0 < iVar7) {
    iVar8 = 0;
    pCVar14 = param_1 + 0x68;
    do {
      piVar9 = (int *)local_101c[iVar8];
      lVar18 = (longdouble)(**(code **)(*piVar9 + 0x78))(piVar9);
      piVar9 = (int *)local_101c[iVar8];
      (**(code **)(*piVar9 + 0x90))(piVar9,0,pCVar14);
      *(float *)(param_1 + 100) = *(float *)(param_1 + 100) + (float)lVar18;
      *(float *)(pCVar14 + 0x1000) = (float)lVar18;
      piVar9 = (int *)local_101c[iVar8];
      (**(code **)(*piVar9 + 0x74))(piVar9,1.0 / fVar19);
      piVar9 = (int *)local_101c[iVar8];
      iVar8 = iVar8 + 1;
      (**(code **)(*piVar9 + 0x8c))(piVar9,0,&local_1098);
      pCVar14 = pCVar14 + 4;
    } while (iVar8 != iVar7);
  }
  (**(code **)(*(int *)_param_4 + 0x74))(_param_4,0x3f800000);
  (**(code **)(*(int *)_param_4 + 0x3c))(_param_4,0);
  *(undefined4 *)(param_1 + 0x50) = 0xbf800000;
  *(undefined4 *)(param_1 + 0x54) = 0;
  *(undefined4 *)(param_1 + 0x58) = 0;
  pQVar24 = local_1088;
  pCVar14 = param_1;
  TransformAnglesToPlayerSpace((QAngle *)&local_104c,param_1);
  *(undefined4 *)(param_1 + 4) = local_104c;
  *(undefined4 *)(param_1 + 8) = local_1048;
  *(undefined4 *)(param_1 + 0xc) = local_1044;
  fVar19 = *(float *)(param_1 + 0x5c);
  if (fVar19 != 0.0) {
    AngleMatrix((QAngle *)(param_1 + 4),(matrix3x4_t *)&local_104c);
    pVVar16 = local_1070;
    local_10a4 = 3;
    iVar7 = 2;
    do {
      iVar8 = iVar7;
      pQVar24 = (QAngle *)local_107c;
      MatrixGetColumn((matrix3x4_t *)&local_104c,iVar8,(Vector *)pQVar24);
      if (fVar19 < ABS(local_107c[0])) {
        pfVar11 = local_107c + 2;
        pfVar13 = local_107c + 1;
        pfVar12 = local_107c;
        fVar20 = local_107c[0];
LAB_004ecb13:
        *pfVar12 = (float)(~-(uint)(fVar20 < 0.0) & 0x3f800000 | -(uint)(fVar20 < 0.0) & 0xbf800000)
        ;
        *pfVar13 = 0.0;
        *pfVar11 = 0.0;
        MatrixSetColumn((Vector *)local_107c,iVar8,(matrix3x4_t *)&local_104c);
        iVar7 = 0;
        pVVar17 = local_1070;
        do {
          iVar15 = iVar7 + 1;
          MatrixGetColumn((matrix3x4_t *)&local_104c,iVar7,pVVar17);
          iVar7 = iVar15;
          pVVar17 = pVVar17 + 0xc;
        } while (iVar15 != 3);
        fVar20 = *(float *)(pVVar16 + 0x1c);
        fVar2 = *(float *)(pVVar16 + 0x18);
        fVar3 = *(float *)(pVVar16 + 0x20);
        iVar7 = local_10a4 % 3;
        iVar15 = (local_10a4 + 1) % 3;
        pVVar17 = local_1070 + iVar15 * 0xc;
        pVVar1 = local_1070 + iVar7 * 0xc;
        fVar22 = afStack_106c[iVar7 * 3];
        fVar21 = *(float *)pVVar1;
        fVar23 = fVar2 * fVar22 - fVar20 * fVar21;
        fVar4 = afStack_106c[iVar7 * 3 + 1];
        afStack_106c[iVar15 * 3 + 1] = fVar23;
        fVar21 = fVar21 * fVar3 - fVar2 * fVar4;
        fVar22 = fVar4 * fVar20 - fVar22 * fVar3;
        afStack_106c[iVar15 * 3] = fVar21;
        *(float *)pVVar17 = fVar22;
        fVar20 = *(float *)(pVVar16 + 0x1c);
        fVar2 = *(float *)(pVVar16 + 0x18);
        fVar3 = *(float *)(pVVar16 + 0x20);
        *(float *)pVVar1 = fVar21 * fVar3 - fVar23 * fVar20;
        afStack_106c[iVar7 * 3] = fVar23 * fVar2 - fVar3 * fVar22;
        afStack_106c[iVar7 * 3 + 1] = fVar22 * fVar20 - fVar21 * fVar2;
        VectorNormalize(pVVar17);
        VectorNormalize(pVVar1);
        MatrixSetColumn(pVVar1,iVar7,(matrix3x4_t *)&local_104c);
        pQVar24 = (QAngle *)&local_104c;
        MatrixSetColumn(pVVar17,iVar15,(matrix3x4_t *)&local_104c);
      }
      else {
        if (fVar19 < ABS(local_107c[1])) {
          pfVar11 = local_107c;
          pfVar13 = local_107c + 2;
          pfVar12 = local_107c + 1;
          fVar20 = local_107c[1];
          goto LAB_004ecb13;
        }
        pfVar11 = local_107c + 1;
        pfVar13 = local_107c;
        pfVar12 = local_107c + 2;
        fVar20 = local_107c[2];
        if (fVar19 < ABS(local_107c[2])) goto LAB_004ecb13;
      }
      pVVar16 = pVVar16 + -0xc;
      iVar7 = iVar8 + -1;
      local_10a4 = iVar8;
    } while (iVar8 + -1 != -1);
    pCVar14 = (CBasePlayer *)local_107c;
    MatrixAngles((matrix3x4_t *)&local_104c,(float *)pCVar14);
    *(float *)(param_1 + 4) = local_107c[0];
    *(float *)(param_1 + 8) = local_107c[1];
    *(float *)(param_1 + 0xc) = local_107c[2];
  }
  if (((byte)param_3[0x14d] & 8) != 0) {
    CBaseEntity::CalcAbsolutePosition((CBaseEntity *)param_3);
  }
  pfVar11 = (float *)(**(code **)(*(int *)param_3 + 0x288))(param_3,pCVar14,pQVar24,param_2);
  VectorITransform(pfVar11,(matrix3x4_t *)(param_3 + 0x28c),(float *)(param_1 + 0x10));
  this = (CPhysicsProp *)__dynamic_cast(param_3,&CBaseEntity::typeinfo,&CPhysicsProp::typeinfo,0);
  if (this == (CPhysicsProp *)0x0) {
    param_1[0x2078] = (CBasePlayer)0x0;
    return;
  }
  CVar5 = (CBasePlayer)
          CPhysicsProp::GetPropDataAngles(this,"preferred_carryangles",(QAngle *)(param_1 + 0x206c))
  ;
  param_1[0x2078] = CVar5;
  return;
}

SourceMod gamedata

paste into addons/sourcemod/gamedata/<your_plugin>.txt
used as the SourceMod key — change to fit your plugin's convention
SourceMod library name (server / engine / matchmaking)

Just a Signatures{} block, ready to drop into a gamedata file. Wire it up in your plugin however you like - SDKCall, DHooks, raw memory ops, or anything else.



        

        

          

Type inference is best-effort from the C signature - sanity-check the DHooks types before shipping.

Return-type handling cheatsheet (DHookReturn)