hero_head_5_7/jni/CPlayer.cpp

#include "CPlayer.h"

#include "ACT.h"
#include "CAnimManager.h"
#include "CBall.h"
#include "CBallProj.h"
#include "CPlayerManager.h"
#include "GL.h"
#include "GM.h"
#include "GPA.h"
#include "GU.h"
#include "SNDGAME.h"
#include "TGame.h"
#include "TStateList.h"
#include "XMATH.h"
#include "XSYS.h"
#include "TAnimData.h"
int LOCO_SPEED_WALK_MIN = 0x321;     // 0033E988
int LOCO_SPEED_WALK_MAX = 0x321;     // 0033E98C
int LOCO_SPEED_WALK_AVG = 0x321;     // 0033E990
int LOCO_SPEED_JOG_MIN = 0xC84;      // 0033E994
int LOCO_SPEED_JOG_MAX = 0xE9A;      // 0033E998
int LOCO_SPEED_JOG_AVG = 0xD8F;      // 0033E99C
int LOCO_SPEED_SPRINT_MIN = 0xE9A;   // 0033E9A0
int LOCO_SPEED_SPRINT_MAX = 0x11BB;  // 0033E9A4
int LOCO_SPEED_SPRINT_AVG = 0x102A;  // 0033E9A8

//-------------------------------------------------------------------------------------------------
// 0011DE8C
void CPlayer::SetPos(int i1, int i2) {
  LOGE("CPlayer::SetPos%p%x%x", this, i1, i2);
}
//-------------------------------------------------------------------------------------------------
// 00125D8C
void CPlayer::SetPos(TPoint3D r1) {}
//-------------------------------------------------------------------------------------------------
// 00154314 ^_^
uint64_t CPlayer::GetDistance(TPoint point1) { return 0; }
//-------------------------------------------------------------------------------------------------
// 0015432C ^_^
int CPlayer::GetDistanceSq(TPoint point1) { return 0; }
//-------------------------------------------------------------------------------------------------
// 0015CBD0
void CPlayer::SetPos(TPoint point1) {
  LOGE("CPlayer::SetPos%p%x%x", this, point1.dx_0, point1.dy_4);
}
//-------------------------------------------------------------------------------------------------
// 0016E630
void CPlayer::UpdateFE() {}
//-------------------------------------------------------------------------------------------------
// 0016E64E ^_- 经过单元测试，功能正常
void CPlayer::UpdateRot() {
  // locret_16E6AC
}
//-------------------------------------------------------------------------------------------------
// 0016E6B0 ^_- 经过单元测试，功能正常
void CPlayer::UpdateHeadRot() {
  // LOGI("CPlayer::UpdateHeadRot %p", this);
  // locret_16E798
}
//-------------------------------------------------------------------------------------------------
// 0016E7A4 ^_^
void CPlayer::UpdateFinalise() {}
//-------------------------------------------------------------------------------------------------
// 0016E7C2 ^_^
void CPlayer::Update() {}
//-------------------------------------------------------------------------------------------------
// 0016E81A ^_^
void CPlayer::UpdateSprint() {
  // locret_16E870
}
//-------------------------------------------------------------------------------------------------
// 0016E874
void CPlayer::UpdateFace() { LOGI("CPlayer::UpdateFace %p", this); }
//-------------------------------------------------------------------------------------------------
int UNITROT_X(int x) { return xsin(x) / 16; }
int UNITROT_Y(int x) { return 0 - xcos(x) / 16; }
// 0016E9BC
//  0016E9BC 经过更衣室和游戏第一关测试正常
void CPlayer::UpdatePosVel() {
  TAnimData *r6_pAnimData = GetAnimData();
  int r5_i;
  if ((r6_pAnimData->u_C.s_C.uc_d & 0x20) == 0 ||
      tStr32_44.field_14 < r6_pAnimData->filed_20[0].us_0) {
    // loc_16E9D6
    r5_i = GetRunSpeed();
  } else {
    r5_i = 0;
  }

  // loc_16E9E2
  int r0_i, r1_i;
  if (s_158 == 0 && ballPosPrev_4.dz_8 == 0 && Point3D_14.dz_8 == 0) {
    // 0016E9FC
    if (tStr32_44.field_8 != 3) {
      // 0016EA02
      if (tStr32_44.field_8 || tStr32_44.sBlend_2E) {
        // loc_16EA0C
        int r7_i = u_0.s_2_0.s_0;
        if (u_0.s_2_0.s_0 != -1) {
          // 0016EA14
          if (tStr32_44.field_8 == 4) {
            // 0016EA18
            TAnimData *r2_pAnimData =
                &CAnimManager::s_tAnimData[tStr32_44.field_20];
            if (tStr32_44.sBlend_2E &&
                r2_pAnimData->filed_8 == 4) {  // 0016EA34
              // 0016EA38
              // sint32 r3_si = (sint32)tStr32_44.u_2C.s_2C.uBlend_2E;
              // r3_si=((r3_si>>26)&0x1f)+tStr32_44.u_2C.s_2C.uBlend_2E;
              // uint r3_ui = UBFX(r3_si, 26, 5);
              short r3_si = tStr32_44.sBlend_2E;
              r0_i = GM_BlendAngle(r6_pAnimData->s_64, r2_pAnimData->s_64,
                                   r3_si / 32);

            } else {
              // loc_16EAC2
              //！！！！！！！修改
              r0_i = r6_pAnimData->s_64;
            }

            // loc_16EAC6
            int r6_i = r0_i + r7_i;
            r7_i = xsin(r6_i) / 4 * r5_i;
            r0_i = xcos(r6_i);
            // r1_i = 0 - (r0_i * 4096);
            if (r1_i < 0)
              r1_i = 0x3FFF;
            else
              r1_i = 0;
            r0_i = r1_i - (r0_i * 4096);

            r0_i = (r0_i >> 14) * r5_i / 4096;

            // loc_16EAF8
            r1_i = r7_i / 4096;

          } else {
            // loc_16EA86
            r0_i = xsin(r7_i);
            r0_i = r0_i / 4;
            int r6_i = r0_i * r5_i;
            r0_i = xcos(r7_i);  // 0016EA9E
            // r1_i = 0 - ((uint)r0_i << 12);
            //  r1_i = r1_i >> 31;
            //  r1_i = (uint)r1_i >> 18;
            if (r1_i < 0)
              r1_i = 0x3fff;
            else
              r1_i = 0;
            r0_i = r1_i - ((uint)r0_i << 12);
            // //FF003FFF
            r0_i = r0_i >> 14;
            // FFFFFC00
            //  loc_16EAF8
            r1_i = r6_i / 4096;
            r0_i = r0_i * r5_i / 4096;
          }

        } else {
          // loc_16EA80
          r0_i = 0;
          r1_i = 0;
        }
      } else {
        // loc_16EAB8
        r0_i = 0;
        r1_i = 0;
        Point3D_14.point_0.dx_0 = 0;
        Point3D_14.point_0.dy_4 = 0;
      }
    } else {
      // loc_16EA52
      int r6_i = GU_GetRot(ballPosPrev_4.point_0, point_78);
      int r7_i = UNITROT_X(r6_i) * r5_i;
      r0_i = UNITROT_Y(r6_i) * r5_i;
      r1_i = r7_i / 1024;
      r0_i = r0_i / 1024;
    }

    // loc_16EB04
    int r2_i = Point3D_14.point_0.dx_0;
    int r3_i = Point3D_14.point_0.dy_4;
    Point3D_14.point_0.dx_0 = ((r2_i * 96) + (r1_i * 32)) / 128;
    Point3D_14.point_0.dy_4 = ((r3_i * 96) + (r0_i * 32)) / 128;
  }
  // loc_16EB30

  ballPosPrev_4.point_0.dx_0 += Point3D_14.point_0.dx_0;
  ballPosPrev_4.point_0.dy_4 += Point3D_14.point_0.dy_4;
  if (Point3D_14.dz_8 || ballPosPrev_4.dz_8 >= 1) {
    // loc_16EB4A
    ballPosPrev_4.dz_8 += Point3D_14.dz_8;
    Point3D_14.dz_8 -= 98;
    if (ballPosPrev_4.dz_8 > -1) {
      return;
    }
  }

  // loc_16EB5E
  Point3D_14.dz_8 = 0;
  ballPosPrev_4.dz_8 = 0;
}
//-------------------------------------------------------------------------------------------------
// 0016EB6C ^_^
void CPlayer::UpdateFuturePos() {}
//-------------------------------------------------------------------------------------------------
// 0016EB86
__attribute__((noinline)) void CPlayer::UpdateBallInHands() {
  LOGI("CPlayer::UpdateBallInHands %p", this);
}
//-------------------------------------------------------------------------------------------------
// 0016EB88
void CPlayer::SetPos(int i1, int i2, int i3) {
  // LOGI("CPlayer::SetPos %d %d %d", i1, i2, i3);
}
//-------------------------------------------------------------------------------------------------
// 0016EBDE
void CPlayer::SetPosDest() {}
//-------------------------------------------------------------------------------------------------
// 0016EBE6
__attribute__((noinline)) void CPlayer::SetMoveDest(int i1, int i2) {
  LOGI("CPlayer::SetPosDest %p %d %d", this, i1, i2);
}
//-------------------------------------------------------------------------------------------------
// 0016EBF2
void CPlayer::SetMoveDest(TPoint point1) {
  LOGI("CPlayer::SetPosDest %p %d %d", this, point1.dx_0, point1.dy_4);
}
//-------------------------------------------------------------------------------------------------
// 0016EBFE
void CPlayer::SetRotExplicit(int i1) {
  LOGI("CPlayer::SetRotExplicit %p %d ", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 0016EC02
__attribute__((noinline)) void CPlayer::SetRot(int r1, bool r2) {
  LOGI("CPlayer::SetRot %p %d %d", this, r1, r2);
  // locret_16EC0A
}
//-------------------------------------------------------------------------------------------------
// 0016EC0C
__attribute__((noinline)) void CPlayer::SetRot(TPoint point1, bool b2) {
  LOGI("CPlayer::SetPosDest %p %d %d %d", this, point1.dx_0, point1.dy_4, b2);
}
//-------------------------------------------------------------------------------------------------
// 0016EC20
__attribute__((noinline)) ushort CPlayer::GetRotPoint(TPoint point1) {
  LOGE("CPlayer::GetRotPoint0016EC20%p%x%x", this, point1.dx_0, point1.dy_4);
  return rand();
}
//-------------------------------------------------------------------------------------------------
// 0016EC34
__attribute__((noinline)) void CPlayer::SetFace(int i1) {
  LOGE("CPlayer::SetFace%p%x", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 0016EC3A
__attribute__((noinline)) void CPlayer::SetFace(int i1, int i2) {
  LOGI("CPlayer::SetFace %p %d %d", this, i1, i2);
}
//-------------------------------------------------------------------------------------------------
// 0016EC48
void CPlayer::SetFace(TPoint point1) {}
//-------------------------------------------------------------------------------------------------
// 0016EC56
void CPlayer::SetFaceDest() {}
//-------------------------------------------------------------------------------------------------
// 0016EC7A
void CPlayer::Stop(int i1) { LOGE("CPlayer::SetFace%p%x", this, i1); }
//-------------------------------------------------------------------------------------------------
// 0016EC8E ^_^
int CPlayer::GetRotDest() {
  // 0016EC9E
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 0016ECB6
__attribute__((noinline)) ushort CPlayer::GetRotPoint(TPoint3D point1) {
  LOGE("CPlayer::GetRotPoint0016ECB6 %p %x %x %x", this, point1.point_0.dx_0,
       point1.point_0.dy_4, point1.dz_8);
  return rand();
}
//-------------------------------------------------------------------------------------------------
// 0016ECCC ^_^
int CPlayer::GetRotBall() { return 0; }
//-------------------------------------------------------------------------------------------------
// 0016ECF0
__attribute__((noinline)) void CPlayer::GetDistance(CPlayer *pPlayer1) {
  LOGI("CPlayer::GetDistance %p %p", this, pPlayer1);
}
//-------------------------------------------------------------------------------------------------
// 0016ED1C
__attribute__((noinline)) void CPlayer::GetDistanceSq(CPlayer *pPlayer1) {
  LOGI("CPlayer::GetDistanceSq %p %p", this, pPlayer1);
}
//-------------------------------------------------------------------------------------------------
// 0016ED40 ^_^
void CPlayer::SetSpaceRot(int i1, int i2) {}
//-------------------------------------------------------------------------------------------------
// 0016ED8A
__attribute__((noinline)) void CPlayer::GetMoveDistance() {
  LOGI("CPlayer::GetMoveDistance %p", this);
}
//-------------------------------------------------------------------------------------------------
// 0016ED96 ^_^
void CPlayer::Init() {}
//-------------------------------------------------------------------------------------------------
// 0016EDD0 经过单元测试功能正常
void CPlayer::SetupGoally(int i1, TPlayerInfo *pPlayerInfo2) {
  // LOGI("CPlayer::SetupGoally %p %d %p", this, i1, pPlayerInfo2);
}
//-------------------------------------------------------------------------------------------------
// 0016EEC6 经过单元测试，功能正常
void CPlayer::SetupPlayer(int i1, int i2, TPlayerInfo *pPlayerInfo3) {
  LOGI("CPlayer::SetupPlayer %p %d %d %p", this, i1, i2, pPlayerInfo3);
}
//-------------------------------------------------------------------------------------------------
// 0016EFBC ^_^
void CPlayer::SetupStandard() {}
//-------------------------------------------------------------------------------------------------
// 0016F008 ^_^
void CPlayer::SetupOfficial() {}
//-------------------------------------------------------------------------------------------------
// 0016F044 经过单元测试同，功能正常
void CPlayer::Reset() { LOGI("CPlayer::Reset %p", this); }
//-------------------------------------------------------------------------------------------------
// 0016F114
void CPlayer::CancelHeadInputControl() {}
//-------------------------------------------------------------------------------------------------
// 0016F11C
void CPlayer::SetHeadRotRel(int r1, bool r2) {
  // locret_16F12A
}
//-------------------------------------------------------------------------------------------------
// 0016F12C
TPoint3D CPlayer::GetBonePos(int i2) {
  TPoint3D ret;
  return ret;
}
//-------------------------------------------------------------------------------------------------
// 0016F13C 经过单元测试，功能正常
TPoint CPlayer::GetTimePos(int i2) {
  LOGI("CPlayer::GetTimePos %p %d", this, i2);
  TPoint retPos;
  retPos.dx_0 = i2 + rand();
  retPos.dy_4 = i2 + rand();
  return retPos;
}
//-------------------------------------------------------------------------------------------------
// 0016F280 ^_^
int CPlayer::AttributeInterpolate_Internal(EPlayerAttribute eAttr1, int i2,
                                           int i3, int i4, int i5, int i6) {
  // LOGI("CPlayer::AttributeInterpolate_Internal %p %d %d %d %d %d %d", this,
  // eAttr1, i2, i3, i4, i5, i6);
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 0016F324 ^_- 经过单元测试，功能正常
void CPlayer::UpdateAction() {
  // LOGI("CPlayer::UpdateAction %p", this);
}
//-------------------------------------------------------------------------------------------------
// 0016F3D4
__attribute__((noinline)) int CPlayer::ActionTend(int i1, TPoint3D *pPoint3D2) {
  LOGI("CPlayer::UpdateAction %p %d%x", this, i1, (uint)pPoint3D2);
  return rand() % 4;
}
//-------------------------------------------------------------------------------------------------
// 0016F734
__attribute__((noinline)) void CPlayer::UpdateActionSlideTackleX(int i1) {
  LOGI("CPlayer::UpdateActionSlideTackleX %p %d", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 0016FA40
void CPlayer::UpdateActionSlideTackle(int i1) {}
//-------------------------------------------------------------------------------------------------
// 0016FAAC ^_^
void CPlayer::UpdateActionConservativeTackle(int i1) {
  // LOGI("CPlayer::UpdateActionConservativeTackle entry %d", i1);
  // locret_16FB1A
}
//-------------------------------------------------------------------------------------------------
// 0016FB24 ^_-
void CPlayer::UpdateActionGKSave(int i1) {}
//-------------------------------------------------------------------------------------------------
// 0016FB94
__attribute__((noinline)) void CPlayer::UpdateActionDeek(int i1) {
  LOGI("CPlayer::UpdateActionDeek %p %d", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 0016FE80 ^_^
void CPlayer::UpdateActionControl(int i1) {
  // LOGI("CPlayer::UpdateActionControl %p %d", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 0016FF24 ^_^
void CPlayer::UpdateActionKick(int i1) {}
//-------------------------------------------------------------------------------------------------
// 0016FF78 ^_-
void CPlayer::UpdateActionGKKick(int i1) {}
//-------------------------------------------------------------------------------------------------
// 0016FFC8
__attribute__((noinline)) void CPlayer::ClearAction() {
  LOGI("CPlayer::ClearAction %p", this);
}
//-------------------------------------------------------------------------------------------------
// 0016FFD4 经过单元测试，功能正常
bool CPlayer::ActionCheckIsStillValidRange(int i1, int i2, int i3) {
  // LOGI("CPlayer::ActionCheckIsStillValidRange %p %d %d %d", this, i1, i2,
  // i3);
  return true;
}
//-------------------------------------------------------------------------------------------------
// 001700C0 ^_^
void CPlayer::KickFail() {}
//-------------------------------------------------------------------------------------------------
// 001700E4 ^_^
void CPlayer::ActionUpdateDynamic() {
  // locret_170126
}
//-------------------------------------------------------------------------------------------------
// 0017012C  //???
void CPlayer::ActionTendSetupDest(TPoint3D point3D1) {
  TAnimData *r10_pAnimData = GetAnimData();
  int r1_i = r10_pAnimData->filed_20[s_15A].i_4;
  ushort r0_us = r10_pAnimData->filed_20[s_15A].us_2;
  r1_i = r1_i * us_122;
  aPoint3D_178[0] = point3D1;
  int r7 = (r0_us + u_0.s_2_0.s_0) & 0x3FFF;
  int r8_i = r1_i / 1024;

  int r0_i = xsin(r7) * r8_i;  // 00170178   MUL.W R0, R0, R8
  r0_i = r0_i / 2048;
  point3D_164.point_0.dx_0 =
      point3D1.point_0.dx_0 -
      r0_i;  // 00170184   SUB.W           R0, R6, R0,ASR#11
  int r5 = us_122 * r10_pAnimData->filed_20[s_15A].i_8;

  r0_i = xcos(r7) * r8_i;  // 00170194   MUL.W           R0, R0, R8

  point3D_164.point_0.dy_4 = point3D1.point_0.dy_4 + (r0_i / 2048);
  point3D_164.dz_8 = (point3D1.dz_8 - (r5 / 128));
  if (point3D_164.dz_8 < 0) point3D_164.dz_8 = 0;
  TPoint var_2C;
  if (r10_pAnimData->filed_54) {
    GetRootBoneOfs(&var_2C, r10_pAnimData);
  }

  // loc_1701C4
  field_170 = ballPosPrev_4.point_0.dx_0;
  field_174 = ballPosPrev_4.point_0.dy_4;
}
//-------------------------------------------------------------------------------------------------
// 001701D0 ^_^
void CPlayer::ActionTendSetup(TActionSetup *pActionSetup01, EACTION eAction2) {}
//-------------------------------------------------------------------------------------------------
// 00170242
TPoint3D CPlayer::ActionGetPosFromDest() {
  TPoint3D ret_p3D;
  return ret_p3D;
}
//-------------------------------------------------------------------------------------------------
// 001702B0 经过单元测试，功能正常
void CPlayer::Animate(int i1) { LOGI("CPlayer::Animate %p%d", this, i1); }
//-------------------------------------------------------------------------------------------------
// 0017039C ^_- 经过单元测试，功能正常
void CPlayer::ApplyRootBoneOfs(TAnimData *pAniData1, int i2) {
  // LOGI("CPlayer::ApplyRootBoneOfs %d", i2);
  LOGE("ApplyRootBoneOfs%p%x%x", this, (uint)pAniData1, i2);
}
//-------------------------------------------------------------------------------------------------
// 00170440 ^_-
void CPlayer::SetNextState(TAnimData *pAnimData1) {
  // LOGI("CPlayer::SetNextState %p %p", this, pAnimData1);
}
//-------------------------------------------------------------------------------------------------
// 001704DC ^_^
__attribute__((noinline)) TAnimData *CPlayer::GetAnimData() {
  LOGE("TAnimData *CPlayer::GetAnimData");
  return (TAnimData *)rand();
}
//-------------------------------------------------------------------------------------------------
// 001704F4 经过单元测试，功能正常
void CPlayer::SetAnim(int i1) {
  if (CAnimManager::s_tAnimData[tStr32_44.field_10].filed_54 !=
      nullptr) {  // 00170514
    // 00170516
    GetRootBoneMove(&Point3D_14.point_0);
    int r7_i = XMATH_Mag2D(&Point3D_14);
    int r1_i = GetSprintSpeed();
    if (r7_i > r1_i) {  // 00170532
      // 00170534
      XMATH_Normalize(&Point3D_14, r1_i);
    }
  }

  ushort r9_us;
  // loc_17053C
  if (tStr32_44.sBlend_2E > 4096) {
    // 00170546
    r9_us = GetTrueRot() - tStr32_44.s_2C;
    tStr32_44.sBlend_2E = 0;
    tStr32_44.field_10 = tStr32_44.field_20;
    tStr32_44.field_14 = tStr32_44.field_24;
    tStr32_44.s_18 = tStr32_44.s_2A;
    u_0.s_2_0.s_2 = r9_us;
  } else {
    // loc_170572
    r9_us = u_0.s_2_0.s_2;
  }

  int r0_i;
  // loc_170578
  u_0.s_2_0.s_2 = GetTrueRot();
  if (field_10 >= 2) {
    // 00170586
    tStr32_44.field_20 = tStr32_44.field_10;
    tStr32_44.field_24 = tStr32_44.field_14;
    TAnimData *r8_pAnimData = &CAnimManager::s_tAnimData[tStr32_44.field_10];
    if (r8_pAnimData->filed_8 == 4) {
      // 001705AE

      r0_i = ((int)(((uint)(XMATH_Mag(&Point3D_14.point_0))) * 2)) /
             ((short)r8_pAnimData->s_18);
      r0_i *= tStr32_44.field_1C;
      r0_i /= 128;
    } else {
      // loc_1705D8
      r0_i = tStr32_44.field_1C;
    }

    // loc_1705DA
    tStr32_44.s_28 = r0_i;

    tStr32_44.sBlend_2E = 8192;
    // LOGE("tStr32_44.u_2C.s_2C.sBlend_2E=%x",tStr32_44.u_2C.s_2C.sBlend_2E);
    tStr32_44.s_2A = tStr32_44.s_18;
    tStr32_44.s_2C = (((8192 - r9_us) + u_0.s_2_0.s_2) & 0x3FFF) - 0x2000;
  } else {
    // loc_1705CE
    tStr32_44.s_2C = 0;
    tStr32_44.sBlend_2E = 0;
  }

  // loc_170604
  tStr32_44.field_10 = i1;  // 0017060C
  tStr32_44.field_14 = 0;

  TAnimData *r5_pAnimData = &CAnimManager::s_tAnimData[i1];

  tStr32_44.s_C = r5_pAnimData->filed_6e;
  // 00170614
  if (tStr32_44.field_8 == 4) {
    // 00170624
    if (us_122) {
      // 0017062A
      r0_i = (131072 / us_122) * 512;
    } else {
      // loc_170642
      r0_i = 0x10000;
    }

    // loc_170646
    tStr32_44.field_1C = (int)(r5_pAnimData->i_10 * r0_i) >> 16;

    // 00170648
    if (field_10 <= 1) {
      // 00170656
      if (!r5_pAnimData->filed_9) {
        // 0017065A
        tStr32_44.field_14 = XSYS_Random(0x10000);
      }
    }  // loc_170666

  } else {
    // 00170636
    tStr32_44.field_1C = *(short *)&r5_pAnimData->i_10;
    if (!tStr32_44.field_8) {
      // loc_170656
      // 00170656
      if (!r5_pAnimData->filed_9) {
        // 0017065A
        tStr32_44.field_14 = XSYS_Random(0x10000);
      }
    }
  }

  // loc_170666
  if (r5_pAnimData->us_1C) {
    // 0017066A
    u_0.s_2_0.s_2 = (u_0.s_2_0.s_2 - r5_pAnimData->us_1C) & 0x3FFF;
  }

  // loc_170674
  if (r5_pAnimData->filed_54) {
    // 00170678
    ApplyRootBoneOfs(r5_pAnimData, -1);
  }
  // loc_170684
  UpdateAnimCalcs();
}
//-------------------------------------------------------------------------------------------------
// 00170694 ^_- 经过单元测试，功能正常
void CPlayer::GetRootBoneMove(TPoint *pPoint1) {
  LOGI("CPlayer::GetRootBoneMove %p %p", this, pPoint1);
}
//-------------------------------------------------------------------------------------------------
// 0017077C ^_- 经过单元测试，功能正常
short CPlayer::GetTrueRot() {
  LOGI("CPlayer::GetRootBoneMove %p ", this);
  return rand() & 0x3fff;
}
//-------------------------------------------------------------------------------------------------
// 00170820
__attribute__((noinline)) bool CPlayer::AnimBlendNeeded() { return false; }
//-------------------------------------------------------------------------------------------------
// 0017082C ^_- 经过单元测试，功能正常
void CPlayer::UpdateAnimCalcs() {
  // LOGI("CPlayer::UpdateAnimCalcs entry");
  LOGI("CPlayer::UpdateAnimCalcs %p ", this);
  // loc_1708C8
}
//-------------------------------------------------------------------------------------------------
// 001708D0
void CPlayer::SetTrophyData(ETrophyPos e1, ushort us2, ushort us3) {}
//-------------------------------------------------------------------------------------------------
// 001708DE
__attribute__((noinline)) void CPlayer::ClearBlend() {
  LOGE("CPlayer::ClearBlend%p", this);
}
//-------------------------------------------------------------------------------------------------
// 001708E8 后面的代码好像与
// NIS的测试环境，通过单元测试，发现后面的代码不写，不影响逻辑
void CPlayer::UpdateJostlePoint() {
  if (!tStr32_44.uc_1) return;

  // 001708F4
  if (tStr32_44.field_8 != 4) {
    if (tStr32_44.field_8 || tStr32_44.s_C != 5 || tStr58_A0.field_4 <= 1024)
      return;

    // 00170910
    // SetAnimFromStateLoco(int i1, int i2, int i3) {
    SetAnimFromStateLoco(-1, -1, 0);
    return;
  }
  // loc_170926
  if (tStr32_44.s_C != 40) return;

  // 0017092E
  TAnimData *r6_pAnimData = &CAnimManager::s_tAnimData[tStr32_44.field_10];

  // 00170944
  if (r6_pAnimData->s_64) return;

  //??? 后面的代码好像与
  // NIS的测试环境，通过单元测试，发现后面的代码不写，不影响逻辑
}
//-------------------------------------------------------------------------------------------------
// 00170A14 ^_^
bool CPlayer::SetReaction(int i1, int i2, int i3) { return true; }
//-------------------------------------------------------------------------------------------------
// 00170A50 经过单元测试，功能正常
void CPlayer::UpdateAnimation() {
  // 00170A56
  int i_r5 = GetRunSpeed();
  // 00170A5E
  if (tStr32_44.field_8 == 4) {
    // 00170A62
    int i_r7 = this->tStr32_44.field_10;
    int i_r0;
    // 00170A6C
    if (s_80 <= 256) {
      // 00170A78
      uint ui_r1 = this->tStr32_44.s_30 % 3;
      i_r0 = CAnimManager::s_iStandardWalk[ui_r1];
      TAnimData *panimdata_r0 = &CAnimManager::s_tAnimData[i_r0];
      i_r0 = panimdata_r0->i_10;
      i_r0 = i_r0 * 5973;
      TAnimData *panimdata_r1 = &CAnimManager::s_tAnimData[i_r7];
      int i_r1 = panimdata_r1->i_10;
      // 00170B14
      i_r0 = i_r0 / i_r1;
    } else if (s_80 <= 768) {  // 00170AA8
      // 00170AAE
      uint ui_r0 = this->tStr32_44.s_30;
      uint ui_r1 = ui_r0 % 3;
      int i_r9 = CAnimManager::s_iStandardWalk[ui_r1];
      // 00170AD4
      int i_r1 = XMATH_InterpolateClamp(s_80, 0x100, 0x300, 0xC0, 0x230);
      int i_r6 = 0x118000 / i_r1;
      TAnimData *panimdata_r7 = &CAnimManager::s_tAnimData[i_r7];
      i_r0 = this->s_80;
      TAnimData *panimdata_r1 = &CAnimManager::s_tAnimData[i_r9];
      int i_r2 = panimdata_r7->i_10 * 16;
      int i_r3 = panimdata_r1->i_10 * 16;
      // 00170B0A
      i_r0 = XMATH_InterpolateClamp(i_r0, 0x100, 0x300, i_r3, i_r2);
      i_r0 = i_r6 *i_r0/ (panimdata_r7->i_10 * 16);
    } else if ((s_80 <= 1024) ||
               (CAnimManager::s_tAnimData[tStr32_44.field_10].s_64 !=
                0)) {  // loc_170B1A
      // 00170B2E
      i_r0 = 2048;
    } else {
      // 00170B50
      uint ui_r1 = this->tStr32_44.s_30 & 3;
      int i_r9 = CAnimManager::s_iStandardSprint[ui_r1];
      // 00170B52
      if (s_80 <= 3072) {
        // 00170B68
        int i_r6 =
            1146880 / XMATH_InterpolateClamp(s_80, 0xC00, 0x400, 0x3C0, 0x230);
        //int i_r0 = this->s_80;
        TAnimData *panimdata_r1 = &CAnimManager::s_tAnimData[i_r9];
        int i_r2 = CAnimManager::s_tAnimData[i_r7].i_10 * 16;
        int i_r3 = panimdata_r1->i_10 * 16;
        // 00170B0A
        i_r0 = XMATH_InterpolateClamp(s_80, 0xC00, 0x400, i_r3, i_r2);
        i_r0 = i_r0 * i_r6;
        int i_r1 = CAnimManager::s_tAnimData[i_r7].i_10 * 16;
        i_r0 = i_r0 / i_r1;
      } else {
        // 00170BAC
        i_r0 = CAnimManager::s_tAnimData[i_r9].i_10;
        i_r0 = i_r0 * 0x4AA;
        int i_r1 = CAnimManager::s_tAnimData[i_r7].i_10;
        i_r0 = i_r0 / i_r1;
      }
    }
    // 00170B32
    i_r0 = i_r0 * i_r5;
    this->tStr32_44.s_18 = this->s_80;
    i_r5 = i_r0 / 2048;
  }
  // 00170B44
  // 00170B4C
  Animate(i_r5);
}
//-------------------------------------------------------------------------------------------------
// 00170BD0 ^_^
void CPlayer::OverrideAnimFrame(int i1) {}
//-------------------------------------------------------------------------------------------------
// 00170C0C
__attribute__((noinline)) void CPlayer::EnableIdleAnims(bool b1) {}
//-------------------------------------------------------------------------------------------------
// 00170C14 经过单元测试，功能正常
void CPlayer::SetAnimFromStateGen(int i1, int i2, int i3) {
  LOGI("CPlayer::SetAnimFromStateGen %p %d %d %d", this, i1, i2, i3);
}
//-------------------------------------------------------------------------------------------------
// 00170D10 经过单元测试，功能正常
void CPlayer::SetAnimFromStateI() {
  // 00170D16
  if (tStr32_44.field_8) {
    // 00170D18
    if (tStr32_44.field_8 != 4) {
      if (tStr32_44.field_8 == 11) {
        // 00170D20
        if (tGame.mTLogic_6678.field_8 == 1) {
          // 00170D3A
          // loc_170DA8
          SetAnimFromStateGen(
              GetRotPoint(cBall.point3D_84),
              CAnimManager::s_tAnimData[tStr32_44.field_10].s_76, 0x200);
        } else {
          // loc_170D98
          SetAnimFromStateGen(
              GetRotPoint(g_vZero),
              CAnimManager::s_tAnimData[tStr32_44.field_10].s_76, 0x200);
        }

      } else {
        // loc_170D82

        SetAnimFromStateGen(-1, -1, 0);
        tStr32_44.field_14 = 0;
      }

    } else {  // loc_170D6C
      SetAnimFromStateLoco(-1, -1, 0x180);
      tStr32_44.field_14 = 0;
    }

  } else {
    // loc_170D4E
    if (u_0.s_2_0.s_0 + 1 != 0) {
      // 00170D56
      if (Turn(u_0.s_2_0.s_0, u_0.s_2_0.s_0, false)) {
        // locret_170D96
        return;
      }

      // 00170D62
      tStr32_44.field_8 = 4;
      SetAnimFromStateLoco(-1, -1, 0x180);
      tStr32_44.field_14 = 0x2000;
    } else {
      // loc_170D6C
      SetAnimFromStateLoco(-1, -1, 0x180);
      tStr32_44.field_14 = 0;
    }
  }
}
//-------------------------------------------------------------------------------------------------
// 00170DD4 ^_^
void CPlayer::GetRootBoneOfs(TPoint *pPoint1, TAnimData *pAnimData2) {
  LOGE("CPlayer::GetRootBoneOfs%p%p%p", this, pPoint1, pAnimData2);
}
//-------------------------------------------------------------------------------------------------
// 00170E50 ^_^
void CPlayer::UpdateActOKTime() {}
//-------------------------------------------------------------------------------------------------
// 00170E98 ^_^
int CPlayer::GetActionTime() { return 0; }
//-------------------------------------------------------------------------------------------------
// 00170EC8
__attribute__((noinline)) void CPlayer::GetAnimTime() {
  LOGI("CPlayer::GetAnimTime %p", this);
}
//-------------------------------------------------------------------------------------------------
// 00170EE0
__attribute__((noinline)) int CPlayer::SetAnimFromStateAction(
    int i1, int i2, int i3, int i4, int i5, int i6, TActionSetup *pActionSetup7,
    int i8, int i9) {
  LOGI("CPlayer::SetAnimFromStateAction %p %d %d %d %d %d %d %p %d %d", this,
       i1, i2, i3, i4, i5, i6, pActionSetup7, i8, i9);
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 001714E4
__attribute__((noinline)) void CPlayer::GetAnimActionPoint(
    TPoint *pPoint1, TAnimData *pAnimData2, int i3, int i4) {
  LOGI("CPlayer::GetAnimTime %p %p %p %d %d", this, pPoint1, pAnimData2, i3,
       i4);
}
//-------------------------------------------------------------------------------------------------
// 00171534 没有测试到
void CPlayer::GetActionPoint(TPoint3D *pPoint3D1) {
  LOGI("CPlayer::GetActionPoint %p %p", this, pPoint3D1);
}
//-------------------------------------------------------------------------------------------------
// 001715EC 经过单元测试，功能正常
// 001715EC 经过单元测试，功能正常
void CPlayer::GetBonePosition(int i1, TPoint3D *pPoint3D2) {
  short aShort_1E_sp12[3];
  CAnimManager::GetBonePositionAnim(aShort_1E_sp12, tStr32_44.field_10,
                                    tStr32_44.field_14, i1, s_80,
                                    tStr32_44.s_30);

  // 00171616
  if (tStr32_44.sBlend_2E) {
    // 0017161A
    short aShort_24_spC[3];
    CAnimManager::GetBonePositionAnim(aShort_24_spC, tStr32_44.field_20,
                                      tStr32_44.field_24, i1, tStr32_44.s_2A,
                                      tStr32_44.s_30);

    // 00171632
    short r0_s;
    short r1_s;
    // 0017164C
    if (CAnimManager::s_tAnimData[tStr32_44.field_10].us_1C != tStr32_44.s_2C) {
      // 00171650
      int r0_i =
          CAnimManager::s_tAnimData[tStr32_44.field_10].us_1C - tStr32_44.s_2C;

      int r7_i = xsin(-r0_i);
      r0_i = xcos(-r0_i);

      int r3_i = r0_i * aShort_24_spC[0];
      int r1_i = aShort_24_spC[0] * r7_i;
      r3_i -= r7_i * aShort_24_spC[1];  // 0017166E   MLS.W 3, R7, R2, R3
      r0_i = (r0_i * aShort_24_spC[1]) + r1_i;

      r1_s = r3_i / 0x4000;
      r0_s = r0_i / 0x4000;

      aShort_24_spC[0] = r1_s;
      aShort_24_spC[1] = r0_s;
    } else {
      // loc_171690
      r0_s = aShort_24_spC[1];
      r1_s = aShort_24_spC[0];
    }
    // loc_171698

    int r4_i = 0x2000 - tStr32_44.sBlend_2E;
    int r3_i = aShort_1E_sp12[0] * r4_i;  // 001716B0   MULS            R3, R4

    int r1_i = (r1_s * tStr32_44.sBlend_2E) +
               r3_i;  // 001716B2   SMLABB.W        R1, R1, R2, R3
    r3_i = r4_i * aShort_1E_sp12[2];  // 001716B6   MUL.W           R3, R4, R6

    // int r7_i = aShort_1E_sp12[1] * r4_i;
    int r0_i = (r0_s * tStr32_44.sBlend_2E) + (aShort_1E_sp12[1] * r4_i);
    int r2_i = (aShort_24_spC[2] * tStr32_44.sBlend_2E) + r3_i;

    aShort_1E_sp12[0] = r1_i / 8192;
    aShort_1E_sp12[1] = r0_i / 8192;
    aShort_1E_sp12[2] = r2_i / 8192;
  }

  // loc_1716EC
  int r6_i = (4096 - u_0.s_2_0.s_2) & 0x3FFF;
  int r7_i = xsin(r6_i);
  int r0_i = xcos(r6_i);

  r6_i = r0_i * aShort_1E_sp12[0];
  int r1_i = aShort_1E_sp12[0] * r7_i;
  r7_i = r6_i - (r7_i * aShort_1E_sp12[1]);  // 00171716

  r0_i = (r0_i * aShort_1E_sp12[1]) + r1_i;  // 0017171C

  int r2_i = (r7_i / 0x4000) * us_122;
  r0_i = (r0_i / 0x4000) * us_122;

  // 0017173A
  r1_i = us_122 * aShort_1E_sp12[2];

  pPoint3D2->point_0.dx_0 =
      ballPosPrev_4.point_0.dx_0 + ((381 * (r2_i / -32))) / 1024;
  pPoint3D2->point_0.dy_4 =
      ballPosPrev_4.point_0.dy_4 + ((381 * (r0_i / 32))) / 1024;
  pPoint3D2->dz_8 = ballPosPrev_4.dz_8 + (381 * (r1_i / 32)) / 1024;
}
//-------------------------------------------------------------------------------------------------
// 00171798
__attribute__((noinline)) void CPlayer::GetHandPosition(TPoint3D *pPoint3D1,
                                                        bool b2) {
  LOGI("CPlayer::GetAnimTime %p %p %d", this, pPoint3D1, b2);
}
//-------------------------------------------------------------------------------------------------
// 001717A8 ^_^ 经过单元测试，功能正常
TPoint3D CPlayer::GetHandsPosition(int i1) {
  TPoint3D ret;
  return ret;
}
//-------------------------------------------------------------------------------------------------
// 00171868
__attribute__((noinline)) void CPlayer::GetBoneOrientation(
    int i1, TPoint3D *pPoint3D2) {
  LOGI("CPlayer::GetAnimTime %p %d %p", this, i1, pPoint3D2);
}
//-------------------------------------------------------------------------------------------------
// 00172634 ^_^
int CPlayer::GetDistanceSq(TPoint3D point3D1) { return 0; }
//-------------------------------------------------------------------------------------------------
// 00172EB2 ^_^
bool CPlayer::Fell(TPoint point1, bool b3) { return true; }
//-------------------------------------------------------------------------------------------------
// 00172EE4
bool CPlayer::Fell(int i1, bool b2) {
  bool r4_bret = rand();
  // loc_172FEE
  LOGE("CPlayer::Fell%x%x%p", i1, b2, this);
  return r4_bret;
}
//-------------------------------------------------------------------------------------------------
// 00172F78 ^_-
bool CPlayer::Trip(int i1, int i2) {
  bool r4_bret = rand();
  // loc_172FEE
  LOGE("CPlayer::Trip%x%x%p", i1, i2, this);
  return r4_bret;
}
//-------------------------------------------------------------------------------------------------
// 00172FF8 ^_^
void CPlayer::UpdateLogic() {
  if (NIS_Active()) return;

  // 00173002
  UpdateJostlePoint();
  UpdateIdle();
  UpdateReactions();
  UpdateBallReactions();
  UpdateFall();

  if (!uc_88) return;

  // 00173026
  if (cBall.ballPosPrev_4.dz_8 <= us_122 * 72 &&
      tStr58_A0.u_50.ui_50 <= 0x28000) {
    // 00173046
    if (tGame.field_6C38 <= 4 && (int)cBall.speedXY_28 > 0x14DC) {
      uc_88 = 0;
    } else if (tGame.mTLogic_6678.team_40 != tStr32_44.uc_0) {
      uc_88 = 0;
    }

  } else {
    uc_88 = 0;
  }
  // loc_17306E
}
//-------------------------------------------------------------------------------------------------
// 00173080 ^_^
void CPlayer::UpdateIdle() {
  // LOGI("CPlayer::UpdateIdle %p", this);
  if (b_30) return;

  // 0017308C
  if (tGame.field_6C38 >= 6 && !tStr32_44.field_8) {
    // 001730A0
    // tStr32_44.s_C > 6 ||
    if ((tStr32_44.s_C != 6 && tStr32_44.s_C != 3 && tStr32_44.s_C != 2)) {
      // loc_1730B4
      field_120++;
      if ((int)field_120 >= 241) {
        // 001730CC
        if (XSYS_Random(0x12C) || uc_88) {
          // loc_1730D6
          if (tStr32_44.s_C == 6 || tStr32_44.s_C == 1) {
            // 001730E2
            NewPlayerStateX(0, -1, 0);
          }  // loc_173104
        } else {
          // loc_173178
          NewPlayerStateX(0, -1, 0xB);
        }
      }  //-> loc_173104
    } else {
      field_120 = 0;
    }
  } else {
    // loc_1730F2
    if (tStr32_44.field_8 == 14 && tStr32_44.s_C == 6) {
      // loc_173170
      field_120++;
    } else {
      // 001730FE
      field_120 = 0;
    }
  }

  // loc_1730FE

  // loc_173100

  // loc_173104
  if (tGame.mTLogic_6678.field_8 == 1 && tGame.mTLogic_6678.field_10 == 1) {
    // loc_17311A
    if (tGame.mTLogic_6678.field_38 <= 29 && tStr32_44.field_8 == 14 &&
        tStr32_44.field_14 > (tStr32_44.field_1C * 30)) {
      // 00173138
      NewPlayerStateX(0, -1, 0);
      if (tGame.mTLogic_6678.field_38 >= 61 && tStr32_44.field_8 == 0 &&
          tStr32_44.s_C == 2) {
        // 0017315E
        NewPlayerStateX(0, -1, 0);
      }
    }
  }

  // 00173118
  return;
}
//-------------------------------------------------------------------------------------------------
// 00173188 ^_^
void CPlayer::UpdateReactions() {
  if (field_8C) {
    // 00173192
    if (s_32) {
      // 00173196
      field_8C--;
    } else {
      // loc_17319A
      NewPlayerStateDataNIS(s_90, s_92, 0, s_94);
      field_8C = 0;
    }
    // loc_1731B2
  }
  // locret_1731B6
}
//-------------------------------------------------------------------------------------------------
// 001731B8
__attribute__((noinline)) void CPlayer::UpdateBallReactions() {
  UpdateTake();
  UpdateAvoid();
}
//-------------------------------------------------------------------------------------------------
// 001731CA ^_-
void CPlayer::UpdateFall() {
  if (tStr32_44.field_8 != 10) return;

  // 001731D6
  TAnimData *r1_data = GetAnimData();

  // 001731E2
  if (tStr32_44.s_C == 10) {
    // 001731E6
    SetNextState(r1_data);
  } else {
    // 001731F0
    if (tStr32_44.field_14 >= r1_data->filed_20[0].us_0 &&
        tStr32_44.field_14 <
            (r1_data->filed_20[0].us_0 + tStr32_44.field_1C)) {
      tStr32_44.s_18 = 1;
    }
  }

  // locret_173206
}
//-------------------------------------------------------------------------------------------------
// 00173208
__attribute__((noinline)) void CPlayer::UpdateAvoid() {
  LOGI("CPlayer::UpdateAvoid %p", this);
}
//-------------------------------------------------------------------------------------------------
// 001733C4
__attribute__((noinline)) void CPlayer::IsWalking() {
  LOGI("CPlayer::IsWalking %p", this);
}
//-------------------------------------------------------------------------------------------------
// 001733EC
bool CPlayer::IsSprinting() {
  // locret_173412
  return false;
}
//-------------------------------------------------------------------------------------------------
// 00173414
__attribute__((noinline)) void CPlayer::IsStanding() {
  LOGI("CPlayer::IsStanding %p", this);
}
//-------------------------------------------------------------------------------------------------
// 0017341E
__attribute__((noinline)) void CPlayer::IsFacing(int i1, int i2) {
  LOGI("CPlayer::IsFacing %p %d %d", this, i1, i2);
}
//-------------------------------------------------------------------------------------------------
// 00173442
__attribute__((noinline)) void CPlayer::IsAtDest(TPoint *pPoint1, int i2) {
  LOGI("CPlayer::IsAtDest %p %d %d", this, (int)pPoint1, i2);
}
//-------------------------------------------------------------------------------------------------
// 0017346C
__attribute__((noinline)) void CPlayer::UpdateMovement() {
  LOGI("CPlayer::UpdateMovement %p", this);
}
//-------------------------------------------------------------------------------------------------
// 00173DBA ^_^
void CPlayer::SetStateStand(bool b1) {}
//-------------------------------------------------------------------------------------------------
// 00173DD4 ^_^
void CPlayer::SetStateLoco() {}
//-------------------------------------------------------------------------------------------------
// 00173E58
__attribute__((noinline)) void CPlayer::SetAnimFromStateLoco(int i1, int i2,
                                                             int i3) {
  LOGI("CPlayer::SetAnimFromStateLoco %p %d %d %d", this, i1, i2, i3);
}
//-------------------------------------------------------------------------------------------------
// 00174074
void CPlayer::CheckAvoid(TPoint *pPoint1, int i2, int i3) {
  // LOGI("CPlayer::CheckAvoid %p %p %d %d", this, pPoint1, i2, i3);
  // tStr32_44.uc_1
}
//-------------------------------------------------------------------------------------------------
// 001741FC
__attribute__((noinline)) void CPlayer::SetConstantSpeed(bool b1) {
  LOGI("CPlayer::SetConstantSpeed %p %d", this, b1);
}
//-------------------------------------------------------------------------------------------------
// 00174204 ^_^
int CPlayer::GetAverageRunSpeed() {
  LOGE("GetAverageRunSpeed%p", this);
  return rand();
}
//-------------------------------------------------------------------------------------------------
// 00174260 ^_^
void CPlayer::SetAverageRunSpeed(int i1) {}
//-------------------------------------------------------------------------------------------------
// 00174290
void CPlayer::GetInterceptRunSpeed() {}
//-------------------------------------------------------------------------------------------------
// 00174294
__attribute__((noinline)) void CPlayer::GetWalkSpeed() {
  LOGI("CPlayer::GetWalkSpeed %p", this);
}
//-------------------------------------------------------------------------------------------------
// 001742B4 ^_^
int CPlayer::GetSprintSpeed() {
  LOGE("this=%xCPlayer::GetRunSpeed", (uint)this);
  return rand();
}
//-------------------------------------------------------------------------------------------------
// 00174310 ^_^
int CPlayer::GetTargetRunSpeed() { return 0; }
//-------------------------------------------------------------------------------------------------
// 0017432C //^_^
int CPlayer::GetCurrentRunSpeed() {
  // LOGI("CPlayer::GetCurrentRunSpeed %p", this);
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 00174458 ^_-
int CPlayer::GetRunSpeed() {
  int dret = 0;
  // loc_1744BA
  LOGE("this=%xCPlayer::GetRunSpeed", (uint)this);
  return rand() + 0x409360;
}
//-------------------------------------------------------------------------------------------------
// 001744CC
int CPlayer::AttributeInterpolate(EPlayerAttribute eAttr1, int i2, int i3) {
  LOGE("AttributeInterpolate%p%x%x%x", this, eAttr1, i2, i3);
  return 0;
}
//-------------------------------------------------------------------------------------------------
// 001744E2
float CPlayer::GetMoveSpeed() { return 0.1f; }
//-------------------------------------------------------------------------------------------------
// 001744E8 ^_^
int CPlayer::GetInterceptMaxHeight() {
  LOGE("%pGetInterceptMaxHeight", this);
  return rand();
}
//-------------------------------------------------------------------------------------------------
// 00174530 ^_^
void CPlayer::SetUrgency(int i1) {
  LOGI("CPlayer::SetUrgency %d %d", i1, s_82);
}
//-------------------------------------------------------------------------------------------------
// 00174550 经过单元测试，功能正常
// 00174550 经过单元测试，功能正常
void CPlayer::SetUrgencyTime(int i1, bool b2) {
  int r5_i = i1;
  int r8_i = LOCO_SPEED_WALK_AVG;
  if (!bool_2F)  // 00174568
    r8_i = LOCO_SPEED_WALK_MIN;

  int r10_i = GetAverageRunSpeed();
  int r9_i = GetSprintSpeed();

  if (b2) {
    // 00174584
    r5_i = (r5_i * 3) / 4;
  }

  // loc_174590
  int r7_i = 1;
  if (r5_i <= 1) {  // 00174598
    // 001745A4
    r5_i = 1;
  }

  TPoint point_28_sp8 = point_34;
  // 001745A8
  int r0_i = XMATH_Distance(&point_28_sp8, &point_78);
  int r1_i = r5_i - s_32;
  if (r1_i > 1) {
    r7_i = r1_i;
  }

  int r6_i;
  // 001745B6
  // 001745BA
  r0_i = r0_i / r7_i;
  if (r0_i < r10_i) {  // 001745BA
    // 001745BE
    r6_i = XMATH_InterpolateClamp(r0_i, r8_i, r10_i, 0, 0x800);
  } else {
    // loc_1745CC
    r6_i = XMATH_InterpolateClamp(r0_i, r10_i, r9_i, 0x800, 0x1000);
  }

  // loc_1745DA
  // 001745DE
  r0_i = (r6_i - s_80) / AttributeInterpolate(EPlayerAttribute_4, 0x2D, 0x44);
  if (r0_i >= 2) {
    // 001745FC
    r7_i = 4096;
    r1_i = r0_i / 2;
    // 00174606
    if (r5_i > r1_i) {
      // 0017460A
      r0_i = (r6_i * r5_i) / (r5_i - r1_i);
      if (r0_i < 4096) r7_i = r0_i;
    }
  } else {
    // loc_17461E
    r7_i = r6_i;
  }

  // loc_174620
  r0_i = (0x493E000 + (field_11C * 4096)) / 56250;
  if (r7_i > r0_i) {
    r7_i = r0_i;
  }
  s_82 = r7_i;
}
//-------------------------------------------------------------------------------------------------
// 0017464C ^_- 经过单元测试，功能正常
void CPlayer::UpdateUrgency() {
  // LOGI("CPlayer::UpdateUrgency %p", this);
  // 00174652
}
//-------------------------------------------------------------------------------------------------
// 001746EE
__attribute__((noinline)) void CPlayer::GetDirMoveX() {
  LOGI("CPlayer::GetCurrentRunSpeed %p", this);
}
//-------------------------------------------------------------------------------------------------
// 00174702
__attribute__((noinline)) void CPlayer::GetDirMoveY() {
  LOGI("CPlayer::GetCurrentRunSpeed %p", this);
}
//-------------------------------------------------------------------------------------------------
// 0017471E
void CPlayer::NewPlayerStateX(int i1, int i2, int i3) {}
//-------------------------------------------------------------------------------------------------
// 0017472E ^_^
void CPlayer::NewPlayerStateXF(int i1, int i2, int i3, int i4) {}
//-------------------------------------------------------------------------------------------------
// 00174778
__attribute__((noinline)) void CPlayer::NewPlayerStateGen(int i1) {
  LOGI("CPlayer::NewPlayerStateGen %p %d", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 001747A8
__attribute__((noinline)) void CPlayer::NewPlayerStateData(int i1, int i2,
                                                           int i3, int i4) {
  LOGI("CPlayer::NewPlayerStateData %p %d %d %d %d", this, i1, i2, i3, i4);
}
//-------------------------------------------------------------------------------------------------
// 001748A8 初步测试调用不到
void CPlayer::NewPlayerStateDataNIS(int i1, int i2, int i3, int i4) {
  LOGI("CPlayer::NewPlayerStateDataNIS %p %d %d %d %d %d", this, i1, i2, i3, i4,
       tStr32_44.uc_2);
}
//-------------------------------------------------------------------------------------------------
// 001749A0 ^_^
__attribute__((noinline)) bool CPlayer::CheckBlockedOff(int i1) {
  // 00174A0E
  return false;
}
//-------------------------------------------------------------------------------------------------
// 00174A24 没有测试到
__attribute__((noinline)) bool CPlayer::NewPlayerStateXFKick(
    TPoint3D point3D1, int i2, int i3, TActionSetup *pActionSetup4, int i5,
    int i6) {
  // LOGI("CPlayer::NewPlayerStateXFKick %p poiint %d %d %d", this,
  // point3D1.point_0.dx_0, point3D1.point_0.dy_4, point3D1.dz_8);
  LOGI("CPlayer::NewPlayerStateXFKick %d %d %p %d %d", i2, i3, pActionSetup4,
       i5, i6);
  // loc_174ACE
  return false;
}
//-------------------------------------------------------------------------------------------------
// 00174ADC
__attribute__((noinline)) void CPlayer::UpdateTake() {
  LOGI("CPlayer::UpdateTake %p", this);
}
//-------------------------------------------------------------------------------------------------
// 00174C9C
__attribute__((noinline)) void CPlayer::ControlTakeBall(int i1) {
  LOGI("CPlayer::ControlTakeBall %p %d", this, i1);
}
//-------------------------------------------------------------------------------------------------
// 00174FBC
__attribute__((noinline)) void CPlayer::SetAnimControl(
    int i1, int i2, int i3, int i4, int i5, int i6, int i7,
    TActionSetup *pActionSetup) {
  LOGI("CPlayer::SetAnimControl %p %d %d %d %d %d %d %d %p", this, i1, i2, i3,
       i4, i5, i6, i7, pActionSetup);
}
//-------------------------------------------------------------------------------------------------
// 0017555C
__attribute__((noinline)) void CPlayer::ControlFinish(int i1, int i2, int i3) {
  LOGI("CPlayer::ControlTakeBall %p %d %d %d", this, i1, i2, i3);
}
//-------------------------------------------------------------------------------------------------
// 00175968
int CPlayer::SetAnimTurn(int i1, int i2, int i3, int i4, int i5, int i6, int i7,
                         TActionSetup *pActionSetup) {
  short i_r6;                 // r6
  unsigned int i_r11;         // r11
  unsigned int v12;           // r2
  TStateList *i_r5;           // r5
  int i_r4;                   // r4
  int i_r7;                   // r7
  int iVal_r6;                // r6
  TAnimData *p_tAnimData_r3;  // r3
  int i_r2;                   // r2
  int v24;                    // r2
  short v27;                  // r2
  int i_value3_r3;            // r3
  int i_value4_r1;            // r1
  int i_value2_r2;            // r2
  int i_value5_r2;            // r2
  int i_tmp_r1;               // r1
  int i_tmp1_r0;              // r0
  int result;                 // r0
  int i_value1_4;             // [sp+4h] [bp-4Ch]
  int i_C;                    // [sp+Ch] [bp-44h]
  short i_10;                 // [sp+10h] [bp-40h]
  short i_14;                 // [sp+14h] [bp-3Ch]
  short i_18;                 // [sp+18h] [bp-38h]
  unsigned int i_1C;          // [sp+1Ch] [bp-34h]
  CPlayer *pThis;             // [sp+20h] [bp-30h]
  int i_24;                   // [sp+24h] [bp-2Ch]
  short i_28;                 // [sp+28h] [bp-28h]

  // 0017596C
  i_28 = i1 + 8192 - i2;
  i_r6 = 8192 - i2 + i3;
  i_10 = i4 + 8192 - i2;
  i_r11 = (i7 >> 7) & 0x200;
  v12 = this->tStr32_44.field_8;
  this->tStr32_44.field_8 = 5;
  i_14 = i4 + 8192 - i3;
  i_1C = v12;
  i_r5 = CAnimManager::StateInfoGet(5);  // call 001564D8
  i_r4 = CAnimManager::StateInfoGetAnimCount(
      this->tStr32_44.field_8);  // call 001564EC
  i_24 = -1;
  i_r7 = 0;
  i_C = 0x7FFFFFFF;
  i_18 = i_r6 + 0x2000;

  // 001759D2
  for (int i = 0; i < i_r4; i++)  // 001759E4
  {
    // 001759E8
    iVal_r6 = i_r5->filed_8[i_r7++];
    p_tAnimData_r3 = &CAnimManager::s_tAnimData[iVal_r6];
    i_r2 = p_tAnimData_r3->u_C.filed_C;

    // 001759FE
    if (i_r11 == (i_r2 & i_r11) &&
        (i_r2 & (i_r11 ^ 0x200)) == 0)  // 2个条件合并
    {
      // 00175A0C
      if (p_tAnimData_r3->s_74 == i5 &&
          (short)p_tAnimData_r3->s_76 == i6)  // 2个条件合并
      {
        v24 = 0;
        if (i5 >= 2)  // 00175A18
        {
          // 00175A1E
          v24 = abs(((i_28 - p_tAnimData_r3->s_70) & 16383) -
                    8192);  //优化后的结果,汇编并没有abs函数调用
        }

        // 00175A3C
        if (v24 <= 2730) {
          // 00175A44
          i_value1_4 = v24 << 7;
          v27 =
              (p_tAnimData_r3->us_1E + 0x2000 - p_tAnimData_r3->us_1C) & 16383;
          i_value3_r3 = abs(((i_18 - (p_tAnimData_r3->s_64 + v27)) & 0x3FFF) -
                            8192);  //优化后的结果,汇编并没有abs函数调用

          // 00175A7E
          if (i_value3_r3 <= 2730) {
            // 00175A86
            i_value4_r1 = abs(((i_14 + p_tAnimData_r3->s_64) & 16383) -
                              8192);  //优化后的结果,汇编并没有abs函数调用

            // 00175A7E
            if (i_value4_r1 <= 2730) {
              // 00175A86
              i_value2_r2 = abs(((i_10 + 8192 - v27) & 16383) -
                                8192);  //优化后的结果,汇编并没有abs函数调用

              // 00175AA4
              if (i_value2_r2 <= 0xAAA) {
                // 00175AAA
                i_value5_r2 = i_value1_4 + (i_value2_r2 << 7) +
                              ((i_value3_r3 + i_value4_r1) << 7);
                if (i_value5_r2 < i_C) {
                  // 00175AE2
                  i_value5_r2 += XSYS_Random(0x200);  // call 001F4F44
                }

                // 00175AF0
                i_tmp_r1 = i_C;
                i_tmp1_r0 = i_24;

                if (i_value5_r2 < i_C) {
                  i_tmp1_r0 = iVal_r6;
                }
                i_24 = i_tmp1_r0;
                if (i_value5_r2 < i_C) {
                  i_tmp_r1 = i_value5_r2;
                }

                i_C = i_tmp_r1;
              }
            }
          }
          i++;  // 00175A7C 原始是NEG,但是他以用负数计算,我这用正数计算,就+1即可
        }
      }
    }
  }

  // 00175B06
  if (i_24 < 0) {
    // 00175B14
    this->tStr32_44.field_8 = i_1C;
    result = 0;
  } else {
    // 00175B0A
    LOGI("CPlayer::SetAnimTurn: %p %d", this, i_24);
    this->SetAnim(i_24);  // call 001704F4
    result = 1;
  }
  return result;
}
//-------------------------------------------------------------------------------------------------
// 00175B2C
__attribute__((noinline)) bool CPlayer::Turn(int i1, int i2, bool b3) {
  LOGI("CPlayer::ControlTakeBall %p %d %d %d", this, i1, i2, b3);
  return rand() % 2;
}
//-------------------------------------------------------------------------------------------------
// 00178AAC 经过单元测试，功能正常
__attribute__((noinline)) CPlayer &CPlayer::operator=(CPlayer const &other) {
  return *this;
}
//-------------------------------------------------------------------------------------------------

/*
001700E4
*/