How to Fix my Character Controller #984

cuppajoeman · 2024-03-17T05:33:26Z

cuppajoeman
Mar 17, 2024

Hi, I recently built a project in isolation from my game, I want to use this project to make the character controller feel right.

As of right now I am using a CharacterVirtual without much configuration. I also found out that godot has a plugin to switch to jolt, so I compared the two:

https://streamable.com/axfb3y

As you can see there are various unwanted things that occur with the pure CharacterVirtual implementation, such as:

"locking in" to edges
"bouncing" when sitting in a V shape wedge
gravity applying weirdly when falling off an object (not jumping off)
just generally doesn't feel smooth
being able to "wall jump" (I think it's detecting on-ground state when it shouldn't)
the jump height doesn't feel consistent (I do a simple on-ground state check, maybe it's activated for longer than I think?), I'd have to actually test this first.

Do I have any issues with my code which are causing these problems? Here are the relevant files:

create_character()
update - contains jump logic and gravity application.

The version of this project where the jolt-godot plugin is used feels extremely good out of the box and doesn't have many glaring issues in comparsion.

I looked at the godot-jolt and couldn't find any relevant info about a character controller. From what I understand, godot will use their own character controller logic defined here which just sits atop jolt.

If these issues are not related to my code, then maybe there's things to learn from the godot implementation? I'd be willing to help contribute if improvements to the character controller (virtual) are in scope.

Answered by jrouwe

Apr 1, 2024

Hello,

The problem with your solution is that you never reset the vertical velocity of the character (unless you jump). If you add:

mDebugRenderer->DrawArrow(mCharacter->GetPosition(), mCharacter->GetPosition() + updated_velocity, Color::sRed, 0.01f);

at the end of CharacterVirtualTest::HandleInput you'll see that the updated_velocity vector is ever increasing. If we for example go to the ramp:

You'll see that moving into this ramp results in a tiny bit of movement towards the ramp and a very large movement towards the floor. So you'll slide down the ramp rather than up.

This is why the example separates the velocity in a horizontal and a vertical velocity and resets the vertical veloci…

View full answer

jrouwe · 2024-03-17T08:23:25Z

jrouwe
Mar 17, 2024
Maintainer

You're using a cylinder shape for the character, please switch to a capsule shape instead (much more stable).
You're not using CharacterBaseSettings::mSupportingVolume which means any contact point can be considered a ground contact (hence you can wall jump)

For an example please look at the CharacterVirtual demo:

JoltPhysics/Samples/Tests/Character/CharacterVirtualTest.cpp

Lines 37 to 160 in de3517e

    
           void CharacterVirtualTest::PrePhysicsUpdate(const PreUpdateParams &inParams) 
        
           { 
        
           	CharacterBaseTest::PrePhysicsUpdate(inParams); 
        
           	// Draw character pre update (the sim is also drawn pre update) 
        
           	RMat44 com = mCharacter->GetCenterOfMassTransform(); 
        
           	RMat44 world_transform = mCharacter->GetWorldTransform(); 
        
           #ifdef JPH_DEBUG_RENDERER 
        
           	mCharacter->GetShape()->Draw(mDebugRenderer, com, Vec3::sReplicate(1.0f), Color::sGreen, false, true); 
        
           #endif // JPH_DEBUG_RENDERER 
        
           	// Draw shape including padding (only implemented for capsules right now) 
        
           	if (static_cast<const RotatedTranslatedShape *>(mCharacter->GetShape())->GetInnerShape()->GetSubType() == EShapeSubType::Capsule) 
        
           	{ 
        
           		if (mCharacter->GetShape() == mStandingShape) 
        
           			mDebugRenderer->DrawCapsule(com, 0.5f * cCharacterHeightStanding, cCharacterRadiusStanding + mCharacter->GetCharacterPadding(), Color::sGrey, DebugRenderer::ECastShadow::Off, DebugRenderer::EDrawMode::Wireframe); 
        
           		else 
        
           			mDebugRenderer->DrawCapsule(com, 0.5f * cCharacterHeightCrouching, cCharacterRadiusCrouching + mCharacter->GetCharacterPadding(), Color::sGrey, DebugRenderer::ECastShadow::Off, DebugRenderer::EDrawMode::Wireframe); 
        
           	} 
        
           	// Remember old position 
        
           	RVec3 old_position = mCharacter->GetPosition(); 
        
           	// Settings for our update function 
        
           	CharacterVirtual::ExtendedUpdateSettings update_settings; 
        
           	if (!sEnableStickToFloor) 
        
           		update_settings.mStickToFloorStepDown = Vec3::sZero(); 
        
           	else 
        
           		update_settings.mStickToFloorStepDown = -mCharacter->GetUp() * update_settings.mStickToFloorStepDown.Length(); 
        
           	if (!sEnableWalkStairs) 
        
           		update_settings.mWalkStairsStepUp = Vec3::sZero(); 
        
           	else 
        
           		update_settings.mWalkStairsStepUp = mCharacter->GetUp() * update_settings.mWalkStairsStepUp.Length(); 
        
           	// Update the character position 
        
           	mCharacter->ExtendedUpdate(inParams.mDeltaTime, 
        
           		-mCharacter->GetUp() * mPhysicsSystem->GetGravity().Length(), 
        
           		update_settings, 
        
           		mPhysicsSystem->GetDefaultBroadPhaseLayerFilter(Layers::MOVING), 
        
           		mPhysicsSystem->GetDefaultLayerFilter(Layers::MOVING), 
        
           		{ }, 
        
           		{ }, 
        
           		*mTempAllocator); 
        
           	// Calculate effective velocity 
        
           	RVec3 new_position = mCharacter->GetPosition(); 
        
           	Vec3 velocity = Vec3(new_position - old_position) / inParams.mDeltaTime; 
        
           	// Draw state of character 
        
           	DrawCharacterState(mCharacter, world_transform, velocity); 
        
           	// Draw labels on ramp blocks 
        
           	for (size_t i = 0; i < mRampBlocks.size(); ++i) 
        
           		mDebugRenderer->DrawText3D(mBodyInterface->GetPosition(mRampBlocks[i]), StringFormat("PushesPlayer: %s\nPushable: %s", (i & 1) != 0? "True" : "False", (i & 2) != 0? "True" : "False"), Color::sWhite, 0.25f); 
        
           } 
        
           void CharacterVirtualTest::HandleInput(Vec3Arg inMovementDirection, bool inJump, bool inSwitchStance, float inDeltaTime) 
        
           { 
        
           	bool player_controls_horizontal_velocity = sControlMovementDuringJump || mCharacter->IsSupported(); 
        
           	if (player_controls_horizontal_velocity) 
        
           	{ 
        
           		// Smooth the player input 
        
           		mDesiredVelocity = sEnableCharacterInertia? 0.25f * inMovementDirection * sCharacterSpeed + 0.75f * mDesiredVelocity : inMovementDirection * sCharacterSpeed; 
        
           		// True if the player intended to move 
        
           		mAllowSliding = !inMovementDirection.IsNearZero(); 
        
           	} 
        
           	else 
        
           	{ 
        
           		// While in air we allow sliding 
        
           		mAllowSliding = true; 
        
           	} 
        
           	// Update the character rotation and its up vector to match the up vector set by the user settings 
        
           	Quat character_up_rotation = Quat::sEulerAngles(Vec3(sUpRotationX, 0, sUpRotationZ)); 
        
           	mCharacter->SetUp(character_up_rotation.RotateAxisY()); 
        
           	mCharacter->SetRotation(character_up_rotation); 
        
           	// A cheaper way to update the character's ground velocity, 
        
           	// the platforms that the character is standing on may have changed velocity 
        
           	mCharacter->UpdateGroundVelocity(); 
        
           	// Determine new basic velocity 
        
           	Vec3 current_vertical_velocity = mCharacter->GetLinearVelocity().Dot(mCharacter->GetUp()) * mCharacter->GetUp(); 
        
           	Vec3 ground_velocity = mCharacter->GetGroundVelocity(); 
        
           	Vec3 new_velocity; 
        
           	bool moving_towards_ground = (current_vertical_velocity.GetY() - ground_velocity.GetY()) < 0.1f; 
        
           	if (mCharacter->GetGroundState() == CharacterVirtual::EGroundState::OnGround	// If on ground 
        
           		&& (sEnableCharacterInertia? 
        
           			moving_towards_ground													// Inertia enabled: And not moving away from ground 
        
           			: !mCharacter->IsSlopeTooSteep(mCharacter->GetGroundNormal())))			// Inertia disabled: And not on a slope that is too steep 
        
           	{ 
        
           		// Assume velocity of ground when on ground 
        
           		new_velocity = ground_velocity; 
        
           		// Jump 
        
           		if (inJump && moving_towards_ground) 
        
           			new_velocity += sJumpSpeed * mCharacter->GetUp(); 
        
           	} 
        
           	else 
        
           		new_velocity = current_vertical_velocity; 
        
           	// Gravity 
        
           	new_velocity += (character_up_rotation * mPhysicsSystem->GetGravity()) * inDeltaTime; 
        
           	if (player_controls_horizontal_velocity) 
        
           	{ 
        
           		// Player input 
        
           		new_velocity += character_up_rotation * mDesiredVelocity; 
        
           	} 
        
           	else 
        
           	{ 
        
           		// Preserve horizontal velocity 
        
           		Vec3 current_horizontal_velocity = mCharacter->GetLinearVelocity() - current_vertical_velocity; 
        
           		new_velocity += current_horizontal_velocity; 
        
           	} 
        
           	// Update character velocity 
        
           	mCharacter->SetLinearVelocity(new_velocity); 
        
           	// Stance switch 
        
           	if (inSwitchStance) 
        
           		mCharacter->SetShape(mCharacter->GetShape() == mStandingShape? mCrouchingShape : mStandingShape, 1.5f * mPhysicsSystem->GetPhysicsSettings().mPenetrationSlop, mPhysicsSystem->GetDefaultBroadPhaseLayerFilter(Layers::MOVING), mPhysicsSystem->GetDefaultLayerFilter(Layers::MOVING), { }, { }, *mTempAllocator); 
        
           }

If you have specific issues, please modify this test to show the problem.

6 replies

jrouwe Mar 17, 2024
Maintainer

It's quite important to have stair stepping turned on. Another thing that I can think of is that you're not using meters as units, the default settings have been tweaked for a character that's roughly 2 m tall.

Other than that I don't know what is wrong with your project. I really suggest you find someone with a Windows PC and create a repro in the Samples app.

cuppajoeman Mar 17, 2024
Author

I just went out and bought windows so I can test this myself, I'll see if I can reproduce the behavior over the next week.

cuppajoeman Mar 20, 2024
Author

@jrouwe Now that I can at least run the samples, and have been able to move around the sample map. Just to confirm, if I want to add obstacles to the map such as spiky pyramids to step on I can edit here ?

jrouwe Mar 20, 2024
Maintainer

Yes

cuppajoeman Apr 1, 2024
Author

Hi @jrouwe I got around to making a minimal working example for the strange behavior with the virtual character controller.

In this implemention I simply use a constant acceleration with friction to move the player around I have no settings set besides the shape and the supporting body.

I realize that I could have simply copied many of the the things you use in your default implementation, but my game's movement doesn't work exactly like the one specified in the example.

Also I didn't enable very many of the settings/custom logic for the character, because I'd like to be able to understand when and why we need to enable certain settings and what problems they fix. With that knowledge I would like to improve the docs for using the virtual character controller.

To test this MWE use this as source for CharacterVirtualTest.cpp

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT

#include <TestFramework.h>

#include <Tests/Character/CharacterVirtualTest.h>
#include <Jolt/Physics/Collision/Shape/CapsuleShape.h>
#include <Jolt/Physics/Collision/Shape/RotatedTranslatedShape.h>
#include <Layers.h>
#include <Renderer/DebugRendererImp.h>
#include <Application/DebugUI.h>

JPH_IMPLEMENT_RTTI_VIRTUAL(CharacterVirtualTest)
{
	JPH_ADD_BASE_CLASS(CharacterVirtualTest, CharacterBaseTest)
}

void CharacterVirtualTest::Initialize()
{
	CharacterBaseTest::Initialize();

	// Create 'player' character
	Ref<CharacterVirtualSettings> settings = new CharacterVirtualSettings();
	settings->mShape = mStandingShape;
	settings->mSupportingVolume = Plane(Vec3::sAxisY(), -cCharacterRadiusStanding); // Accept contacts that touch the lower sphere of the capsule
	mCharacter = new CharacterVirtual(settings, RVec3::sZero(), Quat::sIdentity(), 0, mPhysicsSystem);
	mCharacter->SetListener(this);
}

void CharacterVirtualTest::PrePhysicsUpdate(const PreUpdateParams &inParams)
{
	CharacterBaseTest::PrePhysicsUpdate(inParams);

	// Draw character pre update (the sim is also drawn pre update)
	RMat44 com = mCharacter->GetCenterOfMassTransform();
	RMat44 world_transform = mCharacter->GetWorldTransform();
#ifdef JPH_DEBUG_RENDERER
	mCharacter->GetShape()->Draw(mDebugRenderer, com, Vec3::sReplicate(1.0f), Color::sGreen, false, true);
#endif // JPH_DEBUG_RENDERER

	// Draw shape including padding (only implemented for capsules right now)
	if (static_cast<const RotatedTranslatedShape *>(mCharacter->GetShape())->GetInnerShape()->GetSubType() == EShapeSubType::Capsule)
	{
		if (mCharacter->GetShape() == mStandingShape)
			mDebugRenderer->DrawCapsule(com, 0.5f * cCharacterHeightStanding, cCharacterRadiusStanding + mCharacter->GetCharacterPadding(), Color::sGrey, DebugRenderer::ECastShadow::Off, DebugRenderer::EDrawMode::Wireframe);
		else
			mDebugRenderer->DrawCapsule(com, 0.5f * cCharacterHeightCrouching, cCharacterRadiusCrouching + mCharacter->GetCharacterPadding(), Color::sGrey, DebugRenderer::ECastShadow::Off, DebugRenderer::EDrawMode::Wireframe);
	}

	// Remember old position
	RVec3 old_position = mCharacter->GetPosition();

	// Settings for our update function
	CharacterVirtual::ExtendedUpdateSettings update_settings;

	// Update the character position
	mCharacter->ExtendedUpdate(inParams.mDeltaTime,
		-mCharacter->GetUp() * mPhysicsSystem->GetGravity().Length(),
		update_settings,
		mPhysicsSystem->GetDefaultBroadPhaseLayerFilter(Layers::MOVING),
		mPhysicsSystem->GetDefaultLayerFilter(Layers::MOVING),
		{ },
		{ },
		*mTempAllocator);

	// Calculate effective velocity
	RVec3 new_position = mCharacter->GetPosition();
	Vec3 velocity = Vec3(new_position - old_position) / inParams.mDeltaTime;

	// Draw state of character
	DrawCharacterState(mCharacter, world_transform, velocity);

	// Draw labels on ramp blocks
	for (size_t i = 0; i < mRampBlocks.size(); ++i)
		mDebugRenderer->DrawText3D(mBodyInterface->GetPosition(mRampBlocks[i]), StringFormat("PushesPlayer: %s\nPushable: %s", (i & 1) != 0? "True" : "False", (i & 2) != 0? "True" : "False"), Color::sWhite, 0.25f);
}

void CharacterVirtualTest::HandleInput(Vec3Arg inMovementDirection, bool inJump, bool inSwitchStance, float inDeltaTime)
{
    const int movement_acceleration = 15;
    const int jump_impulse_force = 1000;
    const float friction = 0.983f;

    Vec3 updated_velocity = mCharacter->GetLinearVelocity();
    updated_velocity += movement_acceleration * inMovementDirection * inDeltaTime;

    updated_velocity *= friction;

    updated_velocity += mPhysicsSystem->GetGravity() * inDeltaTime;

    if (inJump && mCharacter->GetGroundState() == CharacterVirtual::EGroundState::OnGround) {
      updated_velocity += jump_impulse_force * mCharacter->GetUp() * inDeltaTime;
    }

    mCharacter->SetLinearVelocity(updated_velocity);

}

void CharacterVirtualTest::AddCharacterMovementSettings(DebugUI* inUI, UIElement* inSubMenu)
{
	inUI->CreateCheckBox(inSubMenu, "Enable Character Inertia", sEnableCharacterInertia, [](UICheckBox::EState inState) { sEnableCharacterInertia = inState == UICheckBox::STATE_CHECKED; });
}

void CharacterVirtualTest::AddConfigurationSettings(DebugUI *inUI, UIElement *inSubMenu)
{
	inUI->CreateComboBox(inSubMenu, "Back Face Mode", { "Ignore", "Collide" }, (int)sBackFaceMode, [=](int inItem) { sBackFaceMode = (EBackFaceMode)inItem; });
	inUI->CreateSlider(inSubMenu, "Up Rotation X (degrees)", RadiansToDegrees(sUpRotationX), -90.0f, 90.0f, 1.0f, [](float inValue) { sUpRotationX = DegreesToRadians(inValue); });
	inUI->CreateSlider(inSubMenu, "Up Rotation Z (degrees)", RadiansToDegrees(sUpRotationZ), -90.0f, 90.0f, 1.0f, [](float inValue) { sUpRotationZ = DegreesToRadians(inValue); });
	inUI->CreateSlider(inSubMenu, "Max Slope Angle (degrees)", RadiansToDegrees(sMaxSlopeAngle), 0.0f, 90.0f, 1.0f, [](float inValue) { sMaxSlopeAngle = DegreesToRadians(inValue); });
	inUI->CreateSlider(inSubMenu, "Max Strength (N)", sMaxStrength, 0.0f, 500.0f, 1.0f, [](float inValue) { sMaxStrength = inValue; });
	inUI->CreateSlider(inSubMenu, "Character Padding", sCharacterPadding, 0.01f, 0.5f, 0.01f, [](float inValue) { sCharacterPadding = inValue; });
	inUI->CreateSlider(inSubMenu, "Penetration Recovery Speed", sPenetrationRecoverySpeed, 0.0f, 1.0f, 0.05f, [](float inValue) { sPenetrationRecoverySpeed = inValue; });
	inUI->CreateSlider(inSubMenu, "Predictive Contact Distance", sPredictiveContactDistance, 0.01f, 1.0f, 0.01f, [](float inValue) { sPredictiveContactDistance = inValue; });
	inUI->CreateCheckBox(inSubMenu, "Enable Walk Stairs", sEnableWalkStairs, [](UICheckBox::EState inState) { sEnableWalkStairs = inState == UICheckBox::STATE_CHECKED; });
	inUI->CreateCheckBox(inSubMenu, "Enable Stick To Floor", sEnableStickToFloor, [](UICheckBox::EState inState) { sEnableStickToFloor = inState == UICheckBox::STATE_CHECKED; });
}

void CharacterVirtualTest::SaveState(StateRecorder &inStream) const
{
	CharacterBaseTest::SaveState(inStream);

	mCharacter->SaveState(inStream);

	bool is_standing = mCharacter->GetShape() == mStandingShape;
	inStream.Write(is_standing);

	inStream.Write(mAllowSliding);
	inStream.Write(mDesiredVelocity);
}

void CharacterVirtualTest::RestoreState(StateRecorder &inStream)
{
	CharacterBaseTest::RestoreState(inStream);

	mCharacter->RestoreState(inStream);

	bool is_standing = mCharacter->GetShape() == mStandingShape; // Initialize variable for validation mode
	inStream.Read(is_standing);
	mCharacter->SetShape(is_standing? mStandingShape : mCrouchingShape, FLT_MAX, { }, { }, { }, { }, *mTempAllocator);

	inStream.Read(mAllowSliding);
	inStream.Read(mDesiredVelocity);
}

void CharacterVirtualTest::OnAdjustBodyVelocity(const CharacterVirtual *inCharacter, const Body &inBody2, Vec3 &ioLinearVelocity, Vec3 &ioAngularVelocity)
{
	// Apply artificial velocity to the character when standing on the conveyor belt
//	if (inBody2.GetID() == mConveyorBeltBody)
//		ioLinearVelocity += Vec3(0, 0, 2);
}

void CharacterVirtualTest::OnContactAdded(const CharacterVirtual *inCharacter, const BodyID &inBodyID2, const SubShapeID &inSubShapeID2, RVec3Arg inContactPosition, Vec3Arg inContactNormal, CharacterContactSettings &ioSettings)
{
	// Draw a box around the character when it enters the sensor
	if (inBodyID2 == mSensorBody)
	{
		AABox box = inCharacter->GetShape()->GetWorldSpaceBounds(inCharacter->GetCenterOfMassTransform(), Vec3::sReplicate(1.0f));
		mDebugRenderer->DrawBox(box, Color::sGreen, DebugRenderer::ECastShadow::Off, DebugRenderer::EDrawMode::Wireframe);
	}

//	// Dynamic boxes on the ramp go through all permutations
//	Array<BodyID>::const_iterator i = find(mRampBlocks.begin(), mRampBlocks.end(), inBodyID2);
//	if (i != mRampBlocks.end())
//	{
//		size_t index = i - mRampBlocks.begin();
//		ioSettings.mCanPushCharacter = (index & 1) != 0;
//		ioSettings.mCanReceiveImpulses = (index & 2) != 0;
//	}
//
//	// If we encounter an object that can push us, enable sliding
//	if (ioSettings.mCanPushCharacter && mPhysicsSystem->GetBodyInterface().GetMotionType(inBodyID2) != EMotionType::Static)
//		mAllowSliding = true;
}

void CharacterVirtualTest::OnContactSolve(const CharacterVirtual *inCharacter, const BodyID &inBodyID2, const SubShapeID &inSubShapeID2, RVec3Arg inContactPosition, Vec3Arg inContactNormal, Vec3Arg inContactVelocity, const PhysicsMaterial *inContactMaterial, Vec3Arg inCharacterVelocity, Vec3 &ioNewCharacterVelocity)
{
//	// Don't allow the player to slide down static not-too-steep surfaces when not actively moving and when not on a moving platform
//	if (!mAllowSliding && inContactVelocity.IsNearZero() && !inCharacter->IsSlopeTooSteep(inContactNormal))
//		ioNewCharacterVelocity = Vec3::sZero();
}

With this setup you'll see that the virtual character controller seems to "twitch" around a lot more, especially when it comes to the ramps, when you try to go onto the ramp the character tends to get stuck in a similar way that occurs in my project.

https://streamable.com/huzf9i

jrouwe · 2024-04-01T15:15:54Z

jrouwe
Apr 1, 2024
Maintainer

Hello,

The problem with your solution is that you never reset the vertical velocity of the character (unless you jump). If you add:

mDebugRenderer->DrawArrow(mCharacter->GetPosition(), mCharacter->GetPosition() + updated_velocity, Color::sRed, 0.01f);

at the end of CharacterVirtualTest::HandleInput you'll see that the updated_velocity vector is ever increasing. If we for example go to the ramp:

You'll see that moving into this ramp results in a tiny bit of movement towards the ramp and a very large movement towards the floor. So you'll slide down the ramp rather than up.

This is why the example separates the velocity in a horizontal and a vertical velocity and resets the vertical velocity when you're moving into the floor.

3 replies

cuppajoeman Apr 2, 2024
Author

Hey @jrouwe that worked really well, I ended up changing the code to be:

void CharacterVirtualTest::HandleInput(Vec3Arg inMovementDirection, bool inJump, bool inSwitchStance, float inDeltaTime)
{
    const int movement_acceleration = 15;
    const int jump_impulse_force = 1000;
    const float friction = 0.983f;

    Vec3 updated_velocity = mCharacter->GetLinearVelocity();
    updated_velocity += movement_acceleration * inMovementDirection * inDeltaTime;

    updated_velocity *= friction;

    if (mCharacter->GetGroundState() == CharacterVirtual::EGroundState::OnGround) {
      updated_velocity.SetY(0.0f);
      if (inJump) {
          updated_velocity += jump_impulse_force * mCharacter->GetUp() * inDeltaTime;
      }
    }

    updated_velocity += mPhysicsSystem->GetGravity() * inDeltaTime;


    mCharacter->SetLinearVelocity(updated_velocity);

}

Would it be within scope to add this code as a minimal working implementation for the VirtualCharacter in the docs where we mention that you need to at least bind a mShape and mSupporting volume for the character to get it working as expected?

jrouwe Apr 2, 2024
Maintainer

No, I think the examples provide a better minimal example. Your code here doesn't take moving platforms into account. If you were to jump on one you'd slide off as if it were ice. Also your code doesn't support surface velocity.

cuppajoeman Apr 3, 2024
Author

Ok, sounds good.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

How to Fix my Character Controller #984

{{title}}

Replies: 2 comments 9 replies

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

Select a reply

How to Fix my Character Controller #984

cuppajoeman Mar 17, 2024

Replies: 2 comments · 9 replies

jrouwe Mar 17, 2024 Maintainer

jrouwe Mar 17, 2024 Maintainer

cuppajoeman Mar 17, 2024 Author

cuppajoeman Mar 20, 2024 Author

jrouwe Mar 20, 2024 Maintainer

cuppajoeman Apr 1, 2024 Author

jrouwe Apr 1, 2024 Maintainer

cuppajoeman Apr 2, 2024 Author

jrouwe Apr 2, 2024 Maintainer

cuppajoeman Apr 3, 2024 Author

cuppajoeman
Mar 17, 2024

Replies: 2 comments 9 replies

jrouwe
Mar 17, 2024
Maintainer

jrouwe Mar 17, 2024
Maintainer

cuppajoeman Mar 17, 2024
Author

cuppajoeman Mar 20, 2024
Author

jrouwe Mar 20, 2024
Maintainer

cuppajoeman Apr 1, 2024
Author

jrouwe
Apr 1, 2024
Maintainer

cuppajoeman Apr 2, 2024
Author

jrouwe Apr 2, 2024
Maintainer

cuppajoeman Apr 3, 2024
Author