Because our current navigation system is quite difficult to modify. We were looking for a way to add navigation that would be, on the one hand, quick to add and, on the other hand, easy to modify. This can be achieved in two ways:

• add a simple behavior that contains the most basic functions (e.g. limited to moving and jumping) and let game programmer add/modify anything other he needs - this gives full control but also need a lot of work
• create a system that can be expanded using smaller modules - in this case we have main behavior and a lot smaller that does only one thing like head bobbing, flying support, crouch support and game programmer add these modules to player transform and can implement his own modules when he need something that works different

This PR adds two such possibilities. In all cases we assume that player transform has rigid body and collider.

In the case of the first approach, I implemented two behaviors TSimplestFpsPlayerMovement and TSimpleFpsPlayerMovementWithRotation intended only for FPS games.

TSimplestFpsPlayerMovement

This is the simplest one it assumes that rigid body has blocked rotations and movement direction is determined by the camera direction.

It has few properties:

In this case Player (TCastleTransform) should have camera as his child:

For camera rotations we use TRotateCamera behavior .

TSimplestFpsPlayerMovement will only work well in the simplest of situations when we do not care about (invisible in FPS game) player rotation. And as I wrote it has only base functions (move and jump) and it is intended to be copied and modified by the game developer.

TSimpleFpsPlayerMovementWithRotation

This behavior is similar to TSimplestFpsPlayerMovement but horizontal rotation (x axis) is made by rotating rigid body (using new TRotateRigidBody behavior.

The properties are the same like in TSimplestFpsPlayerMovement:

In this case Player (TCastleTransform) should have camera as his child and be configured like that:

The only difference is using TRotateRigidBody for horizontal rotation (y axis) and now in TRotateCamera we rotate camera only vertical (x axis).

But this behavior is also only a start point for game developer that wants do anything in his own way. But what if we don't want implement everything by ourself but still want modify it? We should use TModularMovement

TModularMovement

TModularMovement is navigation system that can be used for all types of games like FPS, TPP and also 2D games.
For most usecases, it is enough to use the modules that we have prepared, and if something is missing or should work differently, game programmer can create another module or modify the existing one.

How does it work?

At first we add TModularMovement and then other modules depending on your needs e.g.

For 2D platformer like game we add TPlatformer2DWalkSupport - that covers jumping, moving left and right out of the box. When we want add double jump we just add TDoubleJumpSupport. All modules have also Exists property so when we want add double jump when player achieve something we simply set exists to false in editor and set to true in right moment.

Similarly for an FPS game we will add TWalk3DSupport for player moving if we want head bobbing simply add THeadBobbing for crouch TFpsCrouch et cetera.

How it works underneath?

TModularMovement has only three functions:

• gets input
• checks player is on ground
• search all modules and run them in update.

All modules inherit from TAbstractMovementModule and implements/overides UpdateMovement() function.

Properties

Configuration

This all may seem complicated it is really easy and a lot of things can be achieved without coding any single line of code.

FPS game

See castle-engine/examples/physics/physics_3d_shooter example.

TPP game:

Here we also use TFollowingTargetForCamera behavior in camera that supports following an object by 3d camera without writing any line of code.

See castle-engine/examples/physics/physics_3d_third_person example.

Platformer game

See examples/physics/physics_2d_movement

All modules list

Other behaviors

Behaviors that can be usable in many use cases:

Input Axis

I implemented simple Input Axis that observes some keys/mouse and returns a value. More info in docs. How to use check other behaviors. (this PR description is getting to long)

Simple way to use mouse look

There are tow new functions in TCastleContainer: StartMouseLook() and StopMouseLook(); After StartMouseLook() Container starts update MouseLookLastDelta that can be used everywhere in your game. See TCastleInputAxis Value function and castle-engine/examples/physics/physics_3d_shooter main unit for example

Simple way to use mouse drag

There are tow new functions in TCastleContainer: StartMouseDrag() and StopMouseDrag(); After StartMouseLook() Container starts update MouseDragDelta that can be used everywhere in your game. See TCastleInputAxis.Value() function and castle-engine/examples/physics/physics_3d_shooter man unit for example

Simple way to use mouse wheel everywhere

There is LastUpdateMouseWheelDirection in TCastleContainer that contains mose wheel direction change from latest frame

Cached Collider and RigidBody in TCastleTransform

Now you don't need call FindBehavior every frame just get it by using cached pointers from TCastleTransform.

Some screenshots

Platformer game without writing any code:

TPP example:

FPS game:

More tips for TModularMovement

FPS - How To Use it:
- Player rigid body can rotate only in Y axis (horizontal), other axes
  should be blocked in rigid body
- Y is always up
- Friction in player collider should be 0 - with other friction values
  using stairs needs extra code like TStairsSupportByColliderCapsuleRadius,
  and can have other undesirable problems during contact, e.g. with walls
- Rotate player horizontal using angular velocity (do not change transform
  Rotation directly that leads to physics objects synchronization and
  can make your player can fall off the level - especially when it's done
  every frame) You can use TRotateRigidBody behavior for that purpose.
- Do not rotate player vertical - rotate camera. You can use TRotateCamera
  behavior for that.
- Do not change player translation every frame - use rigid body velocities/forces
- After adding TModularMovement add some movement modules e.g. TWalk3DSupport
- Do not afraid to change/add your own movement modules - this class is
  designed for that :)
- Camera should be rotated by pi in y axis for FPS movement
- See /examples/physics/physics_3d_shooter
- For mouse look use Container.StartMouseLook(Viewport); and Container.StopMouseLook;

TPP - How To Use:
- Player rigid body can rotate only in Y axis (horizontal), other axes
  should be blocked in rigid body
- Y is always up
- Friction in player collider should be 0 - with other friction values
  using stairs needs extra code like TStairsSupportByColliderCapsuleRadius,
  and can have other undesirable problems during contact, e.g. with walls
- Rotate player horizontal using angular velocity (do not change transform
  Rotation directly that leads to physics objects synchronization and
  can make your player can fall off the level - especially when it's done
  every frame) You can use TRotateRigidBody behavior for that purpose.
- For cammera following you can use TFollowingTargetForCamera behavior (add it
  to your camera )
- After adding TModularMovement add some movement modules e.g. TWalk3DSupport
- Do not afraid to change/add your own movement modules - this class is
  designed for that :)
- For mouse look use Container.StartMouseLook(Viewport); and Container.StopMouseLook;
- See /examples/physics/physics_3d_third_person

2D Platformer Game - How To Use:
- Player rigid body rotation should be blocked in all directions
- Player translation in Z axis should be blocked
- GravityStrength should be about 1200 (9.81 is good for 3D games)
- After adding TModularMovement add some movement modules e.g. TPlatformer2DWalkSupport
- Do not afraid to change/add your own movement modules - this class is
  designed for that :)
- See /examples/physics/physics_2d_movement