Skip to content
This repository was archived by the owner on Jan 5, 2024. It is now read-only.

Commit 150a4e4

Browse files
fourZKfourZK
committed
ACrab walkpath cleanup according to previous work on AHuman 
1 parent 2877a83 commit 150a4e4

File tree

1 file changed

+51
-136
lines changed

1 file changed

+51
-136
lines changed

‎Entities/ACrab.cpp

Lines changed: 51 additions & 136 deletions
Original file line numberDiff line numberDiff line change
@@ -2188,6 +2188,8 @@ void ACrab::Update()
21882188
////////////////////////////////////
21892189
// Movement direction
21902190

2191+
bool isStill = (m_Vel + m_PrevVel).GetMagnitude() < 1.0F;
2192+
21912193
if (m_Controller.IsState(MOVE_RIGHT) || m_Controller.IsState(MOVE_LEFT) || m_MoveState == JUMP && m_Status != INACTIVE) {
21922194
if (m_MoveState != JUMP)
21932195
{
@@ -2385,159 +2387,72 @@ void ACrab::Update()
23852387
float RFGLegProg = m_Paths[RIGHTSIDE][FGROUND][WALK].GetRegularProgress();
23862388
float RBGLegProg = m_Paths[RIGHTSIDE][BGROUND][WALK].GetRegularProgress();
23872389

2388-
bool playStride = false;
2390+
bool restarted = false;
23892391

2390-
// Make sure we are starting a stride if we're basically stopped
2391-
if (fabs(m_Vel.GetLargest()) < 0.25)
2392-
m_StrideStart[LEFTSIDE] = true;
2392+
// Make sure we are starting a stride if we're basically stopped.
2393+
if (isStill) { m_StrideStart[LEFTSIDE] = true; }
23932394

23942395
//////////////////
23952396
// LEFT LEGS
23962397

2397-
if (m_pLFGLeg && (!m_pLBGLeg || (!(m_Paths[LEFTSIDE][FGROUND][WALK].PathEnded() && LBGLegProg < 0.5) || m_StrideStart[LEFTSIDE])))
2398-
{
2399-
// m_StrideStart[LEFTSIDE] = false;
2400-
m_StrideTimer[LEFTSIDE].Reset();
2401-
m_pLFGFootGroup->PushAsLimb(m_Pos +
2402-
RotateOffset(m_pLFGLeg->GetParentOffset()),
2403-
m_Vel,
2404-
m_Rotation,
2405-
m_Paths[LEFTSIDE][FGROUND][WALK],
2406-
// mass,
2407-
deltaTime,
2408-
&playStride);
2409-
}
2398+
if (m_pLFGLeg && (!m_pLBGLeg || (!(m_Paths[LEFTSIDE][FGROUND][WALK].PathEnded() && LBGLegProg < 0.5F) || m_StrideStart[LEFTSIDE]))) {
2399+
m_StrideTimer[LEFTSIDE].Reset();
2400+
m_pLFGFootGroup->PushAsLimb(m_pLFGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[LEFTSIDE][FGROUND][WALK], deltaTime, &restarted);
2401+
}
24102402

2411-
if (m_pLBGLeg && (!m_pLFGLeg || !(m_Paths[LEFTSIDE][BGROUND][WALK].PathEnded() && LFGLegProg < 0.5)))
2412-
{
2413-
m_StrideStart[LEFTSIDE] = false;
2414-
m_StrideTimer[LEFTSIDE].Reset();
2415-
m_pLBGFootGroup->PushAsLimb(m_Pos +
2416-
RotateOffset(m_pLBGLeg->GetParentOffset()),
2417-
m_Vel,
2418-
m_Rotation,
2419-
m_Paths[LEFTSIDE][BGROUND][WALK],
2420-
// mass,
2421-
deltaTime);
2422-
}
2403+
if (m_pLBGLeg) {
2404+
if (!m_pLFGLeg || !(m_Paths[LEFTSIDE][BGROUND][WALK].PathEnded() && LFGLegProg < 0.5F)) {
2405+
m_StrideStart[LEFTSIDE] = false;
2406+
m_StrideTimer[LEFTSIDE].Reset();
2407+
m_pLBGFootGroup->PushAsLimb(m_pLBGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[LEFTSIDE][BGROUND][WALK], deltaTime);
2408+
} else {
2409+
m_pLBGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pLBGLeg->GetParentOffset()), m_pLBGLeg->GetMaxLength(), m_PrevVel, m_AngularVel, m_pLBGLeg->GetMass(), deltaTime);
2410+
}
2411+
}
24232412

2424-
// Restart the left stride if the current one seems to be taking too long
2425-
if (m_StrideTimer[LEFTSIDE].IsPastSimMS(m_Paths[LEFTSIDE][FGROUND][WALK].GetTotalPathTime()))
2426-
m_StrideStart[LEFTSIDE] = true;
2413+
// Reset the left-side walking stride if it's taking longer than it should.
2414+
if (m_StrideTimer[LEFTSIDE].IsPastSimMS(static_cast<double>(m_Paths[LEFTSIDE][FGROUND][WALK].GetTotalPathTime() * 1.1F))) { m_StrideStart[LEFTSIDE] = true; }
24272415

24282416
///////////////////
24292417
// RIGHT LEGS
24302418

2431-
if (m_pRFGLeg && (!m_pRBGLeg || !(m_Paths[RIGHTSIDE][FGROUND][WALK].PathEnded() && RBGLegProg < 0.5)))
2432-
{
2433-
m_StrideStart[RIGHTSIDE] = false;
2434-
m_StrideTimer[RIGHTSIDE].Reset();
2435-
m_pRFGFootGroup->PushAsLimb(m_Pos +
2436-
RotateOffset(m_pRFGLeg->GetParentOffset()),
2437-
m_Vel,
2438-
m_Rotation,
2439-
m_Paths[RIGHTSIDE][FGROUND][WALK],
2440-
// mass,
2441-
deltaTime,
2442-
&playStride);
2443-
}
2419+
if (m_pRFGLeg) {
2420+
if (!m_pRBGLeg || !(m_Paths[RIGHTSIDE][FGROUND][WALK].PathEnded() && RBGLegProg < 0.5F)) {
2421+
m_StrideStart[RIGHTSIDE] = false;
2422+
m_StrideTimer[RIGHTSIDE].Reset();
2423+
m_pRFGFootGroup->PushAsLimb(m_pRFGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[RIGHTSIDE][FGROUND][WALK], deltaTime, &restarted);
2424+
} else {
2425+
m_pRFGFootGroup->FlailAsLimb(m_Pos, RotateOffset(m_pRFGLeg->GetParentOffset()), m_pRFGLeg->GetMaxLength(), m_PrevVel, m_AngularVel, m_pRFGLeg->GetMass(), deltaTime);
2426+
}
2427+
}
24442428

2445-
if (m_pRBGLeg && (!m_pRFGLeg || (!(m_Paths[RIGHTSIDE][BGROUND][WALK].PathEnded() && RFGLegProg < 0.5) || m_StrideStart[RIGHTSIDE])))
2446-
{
2447-
// m_StrideStart[RIGHTSIDE] = false;
2448-
m_StrideTimer[RIGHTSIDE].Reset();
2449-
m_pRBGFootGroup->PushAsLimb(m_Pos +
2450-
RotateOffset(m_pRBGLeg->GetParentOffset()),
2451-
m_Vel,
2452-
m_Rotation,
2453-
m_Paths[RIGHTSIDE][BGROUND][WALK],
2454-
// mass,
2455-
deltaTime);
2456-
}
2429+
if (m_pRBGLeg && (!m_pRFGLeg || (!(m_Paths[RIGHTSIDE][BGROUND][WALK].PathEnded() && RFGLegProg < 0.5F) || m_StrideStart[RIGHTSIDE]))) {
2430+
m_StrideTimer[RIGHTSIDE].Reset();
2431+
m_pRBGFootGroup->PushAsLimb(m_pRBGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[RIGHTSIDE][BGROUND][WALK], deltaTime);
2432+
}
24572433

2458-
// Restart the right stride if the current one seems to be taking too long
2459-
if (m_StrideTimer[RIGHTSIDE].IsPastSimMS(m_Paths[RIGHTSIDE][FGROUND][WALK].GetTotalPathTime()))
2460-
m_StrideStart[RIGHTSIDE] = true;
2434+
// Reset the right-side walking stride if it's taking longer than it should.
2435+
if (m_StrideTimer[RIGHTSIDE].IsPastSimMS(static_cast<double>(m_Paths[RIGHTSIDE][FGROUND][WALK].GetTotalPathTime() * 1.1F))) { m_StrideStart[RIGHTSIDE] = true; }
24612436

2462-
// Play the stride sound, if applicable
2463-
if (playStride)
2464-
if (m_StrideSound) { m_StrideSound->Play(m_Pos); }
2465-
}
2466-
// JUMPING
2467-
else if ((m_pRFGLeg || m_pRBGLeg) && m_MoveState == JUMP)
2468-
{
2469-
/*
2470-
if (m_pRFGLeg && (!m_Paths[FGROUND][m_MoveState].PathEnded() || m_JetTimeLeft == m_JetTimeTotal))
2471-
{
2472-
m_pRFGFootGroup->PushAsLimb(m_Pos + RotateOffset(m_pRFGLeg->GetParentOffset()),
2473-
m_Vel,
2474-
m_Rotation,
2475-
m_Paths[FGROUND][m_MoveState],
2476-
// mass / 2,
2477-
deltaTime);
2478-
}
2479-
if (m_pRBGLeg && (!m_Paths[BGROUND][m_MoveState].PathEnded() || m_JetTimeLeft == m_JetTimeTotal))
2480-
{
2481-
m_pRBGFootGroup->PushAsLimb(m_Pos + RotateOffset(m_pRBGLeg->GetParentOffset()),
2482-
m_Vel,
2483-
m_Rotation,
2484-
m_Paths[BGROUND][m_MoveState],
2485-
// mass / 2,
2486-
deltaTime);
2487-
}
2437+
if (restarted && m_StrideSound) { m_StrideSound->Play(m_Pos); }
2438+
} else if (m_pLFGLeg || m_pLBGLeg || m_pRFGLeg || m_pRBGLeg) {
2439+
if (m_MoveState == JUMP) {
2440+
// TODO: Utilize jump paths in an intuitive way?
2441+
} else {
2442+
for (int side = 0; side < SIDECOUNT; ++side) {
2443+
for (int layer = 0; layer < LAYERCOUNT; ++layer) {
2444+
m_Paths[side][layer][WALK].Terminate();
2445+
}
2446+
}
2447+
if (m_pLFGLeg) { m_pLFGFootGroup->PushAsLimb(m_pLFGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[LEFTSIDE][FGROUND][STAND], deltaTime); }
24882448

2489-
if (m_JetTimeLeft <= 0)
2490-
{
2491-
m_MoveState = STAND;
2492-
m_Paths[FGROUND][JUMP].Terminate();
2493-
m_Paths[BGROUND][JUMP].Terminate();
2494-
m_Paths[FGROUND][STAND].Terminate();
2495-
m_Paths[BGROUND][STAND].Terminate();
2496-
m_Paths[FGROUND][WALK].Terminate();
2497-
m_Paths[BGROUND][WALK].Terminate();
2498-
}
2499-
*/
2500-
}
2501-
// STANDING
2502-
else if (m_pLFGLeg || m_pLBGLeg || m_pRFGLeg || m_pRBGLeg)
2503-
{
2504-
for (int side = 0; side < SIDECOUNT; ++side)
2505-
for (int layer = 0; layer < LAYERCOUNT; ++layer)
2506-
m_Paths[side][layer][WALK].Terminate();
2449+
if (m_pLBGLeg) { m_pLBGFootGroup->PushAsLimb(m_pLBGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[LEFTSIDE][BGROUND][STAND], deltaTime); }
25072450

2508-
if (m_pLFGLeg)
2509-
m_pLFGFootGroup->PushAsLimb(m_Pos.GetFloored() + RotateOffset(m_pLFGLeg->GetParentOffset()),
2510-
m_Vel,
2511-
m_Rotation,
2512-
m_Paths[LEFTSIDE][FGROUND][STAND],
2513-
// mass / 2,
2514-
deltaTime);
2515-
2516-
if (m_pLBGLeg)
2517-
m_pLBGFootGroup->PushAsLimb(m_Pos.GetFloored() + RotateOffset(m_pLBGLeg->GetParentOffset()),
2518-
m_Vel,
2519-
m_Rotation,
2520-
m_Paths[LEFTSIDE][BGROUND][STAND],
2521-
// mass / 2,
2522-
deltaTime);
2523-
2524-
if (m_pRFGLeg)
2525-
m_pRFGFootGroup->PushAsLimb(m_Pos.GetFloored() + RotateOffset(m_pRFGLeg->GetParentOffset()),
2526-
m_Vel,
2527-
m_Rotation,
2528-
m_Paths[RIGHTSIDE][FGROUND][STAND],
2529-
// mass / 2,
2530-
deltaTime);
2531-
2532-
if (m_pRBGLeg)
2533-
m_pRBGFootGroup->PushAsLimb(m_Pos.GetFloored() + RotateOffset(m_pRBGLeg->GetParentOffset()),
2534-
m_Vel,
2535-
m_Rotation,
2536-
m_Paths[RIGHTSIDE][BGROUND][STAND],
2537-
// mass / 2,
2538-
deltaTime);
2451+
if (m_pRFGLeg) { m_pRFGFootGroup->PushAsLimb(m_pRFGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[RIGHTSIDE][FGROUND][STAND], deltaTime); }
25392452

2540-
}
2453+
if (m_pRBGLeg) { m_pRBGFootGroup->PushAsLimb(m_pRBGLeg->GetJointPos(), m_Vel, m_Rotation, m_Paths[RIGHTSIDE][BGROUND][STAND], deltaTime); }
2454+
}
2455+
}
25412456
} else {
25422457
// Not stable/standing, so make sure the end of limbs are moving around limply in a ragdoll fashion.
25432458
// TODO: Make the limb atom groups fly around and react to terrain, without getting stuck etc.

0 commit comments

Comments
 (0)