< Summary

Class:DCLCharacterController
Assembly:CharacterController
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/CharacterController/DCLCharacterController.cs
Covered lines:194
Uncovered lines:62
Coverable lines:256
Total lines:578
Line coverage:75.7% (194 of 256)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
DCLCharacterController()0%110100%
Awake()0%44096.3%
SubscribeToInput()0%110100%
OnDestroy()0%110100%
OnWorldReposition(...)0%330100%
SetPosition(...)0%990100%
Teleport(...)0%110100%
Teleport(...)0%3.033085.71%
SetPosition(...)0%2100%
SetEnabled(...)0%110100%
Moved(...)0%220100%
LateUpdate()0%41.4629075.44%
SaveLateUpdateGroundTransforms()0%6200%
Jump()0%12300%
ResetGround()0%2.022083.33%
CheckGround()0%28.4112051.52%
CastGroundCheckingRays()0%220100%
CastGroundCheckingRays(...)0%220100%
CastGroundCheckingRay(...)0%2100%
CastGroundCheckingRays(...)0%660100%
CastGroundCheckingRay(...)0%220100%
ReportMovement()0%330100%
PauseGravity()0%110100%
ResumeGravity()0%2100%
OnRenderingStateChanged(...)0%110100%
IsLastCollisionGround()0%2100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/CharacterController/DCLCharacterController.cs

#LineLine coverage
 1using DCL;
 2using DCL.Configuration;
 3using DCL.Helpers;
 4using UnityEngine;
 5using Cinemachine;
 6
 7public class DCLCharacterController : MonoBehaviour
 8{
 09    public static DCLCharacterController i { get; private set; }
 10
 11    private const float CONTROLLER_DRIFT_OFFSET = 0.15f;
 12
 13    [Header("Movement")]
 60614    public float minimumYPosition = 1f;
 15
 60616    public float groundCheckExtraDistance = 0.1f;
 60617    public float gravity = -55f;
 60618    public float jumpForce = 12f;
 60619    public float movementSpeed = 8f;
 60620    public float runningSpeedMultiplier = 2f;
 21
 22    public DCLCharacterPosition characterPosition;
 23
 24    [Header("Collisions")]
 25    public LayerMask groundLayers;
 26
 27    [Header("Additional Camera Layers")]
 28    public LayerMask cameraLayers;
 29
 30    [System.NonSerialized]
 31    public bool initialPositionAlreadySet = false;
 32
 33    [System.NonSerialized]
 60634    public bool characterAlwaysEnabled = true;
 35
 36    [System.NonSerialized]
 37    public CharacterController characterController;
 38
 39    FreeMovementController freeMovementController;
 40
 41    new Collider collider;
 42
 43    float lastUngroundedTime = 0f;
 44    float lastJumpButtonPressedTime = 0f;
 45    float lastMovementReportTime;
 46    float originalGravity;
 47    Vector3 lastLocalGroundPosition;
 48
 49    Vector3 lastCharacterRotation;
 50    Vector3 lastGlobalCharacterRotation;
 51
 60652    Vector3 velocity = Vector3.zero;
 53
 054    public bool isWalking { get; private set; } = false;
 055    public bool isMovingByUserInput { get; private set; } = false;
 056    public bool isJumping { get; private set; } = false;
 057    public bool isGrounded { get; private set; }
 058    public bool isOnMovingPlatform { get; private set; }
 59
 60    internal Transform groundTransform;
 61
 62    Vector3 lastPosition;
 63    Vector3 groundLastPosition;
 64    Quaternion groundLastRotation;
 65    bool jumpButtonPressed = false;
 66
 67    [Header("InputActions")]
 68    public InputAction_Hold jumpAction;
 69
 70    public InputAction_Hold sprintAction;
 71
 72    public Vector3 moveVelocity;
 73
 74    private InputAction_Hold.Started jumpStartedDelegate;
 75    private InputAction_Hold.Finished jumpFinishedDelegate;
 76    private InputAction_Hold.Started walkStartedDelegate;
 77    private InputAction_Hold.Finished walkFinishedDelegate;
 78
 1025779    private Vector3NullableVariable characterForward => CommonScriptableObjects.characterForward;
 80
 81    public static System.Action<DCLCharacterPosition> OnCharacterMoved;
 82    public static System.Action<DCLCharacterPosition> OnPositionSet;
 83    public event System.Action<float> OnUpdateFinish;
 84
 85    public GameObject avatarGameObject;
 86    public GameObject firstPersonCameraGameObject;
 87
 88    [SerializeField]
 89    private InputAction_Measurable characterYAxis;
 90
 91    [SerializeField]
 92    private InputAction_Measurable characterXAxis;
 93
 987794    private Vector3Variable cameraForward => CommonScriptableObjects.cameraForward;
 2795    private Vector3Variable cameraRight => CommonScriptableObjects.cameraRight;
 96
 60697    private readonly DataStore_Player dataStorePlayer = DataStore.i.player;
 98
 99    [System.NonSerialized]
 100    public float movingPlatformSpeed;
 101    private CollisionFlags lastCharacterControllerCollision;
 102
 103    public event System.Action OnJump;
 104    public event System.Action OnHitGround;
 105    public event System.Action<float> OnMoved;
 106
 107    void Awake()
 108    {
 592109        if (i != null)
 110        {
 23111            Destroy(gameObject);
 23112            return;
 113        }
 114
 569115        i = this;
 569116        originalGravity = gravity;
 117
 569118        SubscribeToInput();
 569119        CommonScriptableObjects.playerUnityPosition.Set(Vector3.zero);
 569120        dataStorePlayer.playerWorldPosition.Set(Vector3.zero);
 569121        CommonScriptableObjects.playerCoords.Set(Vector2Int.zero);
 569122        dataStorePlayer.playerGridPosition.Set(Vector2Int.zero);
 569123        CommonScriptableObjects.playerUnityEulerAngles.Set(Vector3.zero);
 124
 569125        characterPosition = new DCLCharacterPosition();
 569126        characterController = GetComponent<CharacterController>();
 569127        freeMovementController = GetComponent<FreeMovementController>();
 569128        collider = GetComponent<Collider>();
 129
 569130        CommonScriptableObjects.worldOffset.OnChange += OnWorldReposition;
 131
 569132        lastPosition = transform.position;
 569133        transform.parent = null;
 134
 569135        CommonScriptableObjects.rendererState.OnChange += OnRenderingStateChanged;
 569136        OnRenderingStateChanged(CommonScriptableObjects.rendererState.Get(), false);
 137
 569138        if (avatarGameObject == null || firstPersonCameraGameObject == null)
 139        {
 0140            throw new System.Exception("Both the avatar and first person camera game objects must be set.");
 141        }
 142
 569143        var worldData = DataStore.i.Get<DataStore_World>();
 569144        worldData.avatarTransform.Set(avatarGameObject.transform);
 569145        worldData.fpsTransform.Set(firstPersonCameraGameObject.transform);
 146
 569147        dataStorePlayer.lastTeleportPosition.OnChange += Teleport;
 569148    }
 149
 150    private void SubscribeToInput()
 151    {
 569152        jumpStartedDelegate = (action) =>
 153        {
 0154            lastJumpButtonPressedTime = Time.time;
 0155            jumpButtonPressed = true;
 0156        };
 569157        jumpFinishedDelegate = (action) => jumpButtonPressed = false;
 569158        jumpAction.OnStarted += jumpStartedDelegate;
 569159        jumpAction.OnFinished += jumpFinishedDelegate;
 160
 569161        walkStartedDelegate = (action) => isWalking = true;
 569162        walkFinishedDelegate = (action) => isWalking = false;
 569163        sprintAction.OnStarted += walkStartedDelegate;
 569164        sprintAction.OnFinished += walkFinishedDelegate;
 569165    }
 166
 167    void OnDestroy()
 168    {
 592169        CommonScriptableObjects.worldOffset.OnChange -= OnWorldReposition;
 592170        jumpAction.OnStarted -= jumpStartedDelegate;
 592171        jumpAction.OnFinished -= jumpFinishedDelegate;
 592172        sprintAction.OnStarted -= walkStartedDelegate;
 592173        sprintAction.OnFinished -= walkFinishedDelegate;
 592174        CommonScriptableObjects.rendererState.OnChange -= OnRenderingStateChanged;
 592175        dataStorePlayer.lastTeleportPosition.OnChange -= Teleport;
 592176        i = null;
 592177    }
 178
 179    void OnWorldReposition(Vector3 current, Vector3 previous)
 180    {
 2181        Vector3 oldPos = this.transform.position;
 2182        this.transform.position = characterPosition.unityPosition; //CommonScriptableObjects.playerUnityPosition;
 183
 2184        if (CinemachineCore.Instance.BrainCount > 0)
 185        {
 2186            CinemachineCore.Instance.GetActiveBrain(0).ActiveVirtualCamera?.OnTargetObjectWarped(transform, transform.po
 187        }
 2188    }
 189
 190    public void SetPosition(Vector3 newPosition)
 191    {
 192        // failsafe in case something teleports the player below ground collisions
 5329193        if (newPosition.y < minimumYPosition)
 194        {
 150195            newPosition.y = minimumYPosition + 2f;
 196        }
 197
 5329198        lastPosition = characterPosition.worldPosition;
 5329199        characterPosition.worldPosition = newPosition;
 5329200        transform.position = characterPosition.unityPosition;
 5329201        Environment.i.platform.physicsSyncController?.MarkDirty();
 202
 5329203        CommonScriptableObjects.playerUnityPosition.Set(characterPosition.unityPosition);
 5329204        dataStorePlayer.playerWorldPosition.Set(characterPosition.worldPosition);
 5329205        Vector2Int playerPosition = Utils.WorldToGridPosition(characterPosition.worldPosition);
 5329206        CommonScriptableObjects.playerCoords.Set(playerPosition);
 5329207        dataStorePlayer.playerGridPosition.Set(playerPosition);
 5329208        dataStorePlayer.playerUnityPosition.Set(characterPosition.unityPosition);
 209
 5329210        if (Moved(lastPosition))
 211        {
 4892212            if (Moved(lastPosition, useThreshold: true))
 4892213                ReportMovement();
 214
 4892215            OnCharacterMoved?.Invoke(characterPosition);
 216
 4892217            float distance = Vector3.Distance(characterPosition.worldPosition, lastPosition) - movingPlatformSpeed;
 218
 4892219            if (distance > 0f && isGrounded)
 24220                OnMoved?.Invoke(distance);
 221        }
 222
 5329223        lastPosition = transform.position;
 5329224    }
 225
 226    public void Teleport(string teleportPayload)
 227    {
 40228        var payload = Utils.FromJsonWithNulls<Vector3>(teleportPayload);
 40229        dataStorePlayer.lastTeleportPosition.Set(payload, notifyEvent: true);
 40230    }
 231
 232    private void Teleport(Vector3 newPosition, Vector3 prevPosition)
 233    {
 41234        ResetGround();
 235
 41236        SetPosition(newPosition);
 237
 41238        if (OnPositionSet != null)
 239        {
 0240            OnPositionSet.Invoke(characterPosition);
 241        }
 242
 41243        if (!initialPositionAlreadySet)
 244        {
 37245            initialPositionAlreadySet = true;
 246        }
 41247    }
 248
 249    [System.Obsolete("SetPosition is deprecated, please use Teleport instead.", true)]
 0250    public void SetPosition(string positionVector) { Teleport(positionVector); }
 251
 2278252    public void SetEnabled(bool enabled) { this.enabled = enabled; }
 253
 254    bool Moved(Vector3 previousPosition, bool useThreshold = false)
 255    {
 10221256        if (useThreshold)
 4892257            return Vector3.Distance(characterPosition.worldPosition, previousPosition) > 0.001f;
 258        else
 5329259            return characterPosition.worldPosition != previousPosition;
 260    }
 261
 262    internal void LateUpdate()
 263    {
 5289264        if(!dataStorePlayer.canPlayerMove.Get())
 2265            return;
 266
 5287267        if (transform.position.y < minimumYPosition)
 268        {
 0269            SetPosition(characterPosition.worldPosition);
 0270            return;
 271        }
 272
 5287273        if (freeMovementController.IsActive())
 274        {
 0275            velocity = freeMovementController.CalculateMovement();
 0276        }
 277        else
 278        {
 5287279            velocity.x = 0f;
 5287280            velocity.z = 0f;
 5287281            velocity.y += gravity * Time.deltaTime;
 282
 5287283            bool previouslyGrounded = isGrounded;
 284
 5287285            if (!isJumping || velocity.y <= 0f)
 5287286                CheckGround();
 287
 5287288            if (isGrounded)
 289            {
 45290                isJumping = false;
 45291                velocity.y = gravity * Time.deltaTime; // to avoid accumulating gravity in velocity.y while grounded
 45292            }
 5242293            else if (previouslyGrounded && !isJumping)
 294            {
 3295                lastUngroundedTime = Time.time;
 296            }
 297
 5287298            if (characterForward.HasValue())
 299            {
 300                // Horizontal movement
 27301                var speed = movementSpeed * (isWalking ? runningSpeedMultiplier : 1f);
 302
 27303                transform.forward = characterForward.Get().Value;
 304
 27305                var xzPlaneForward = Vector3.Scale(cameraForward.Get(), new Vector3(1, 0, 1));
 27306                var xzPlaneRight = Vector3.Scale(cameraRight.Get(), new Vector3(1, 0, 1));
 307
 27308                Vector3 forwardTarget = Vector3.zero;
 309
 27310                if (characterYAxis.GetValue() > CONTROLLER_DRIFT_OFFSET)
 0311                    forwardTarget += xzPlaneForward;
 27312                if (characterYAxis.GetValue() < -CONTROLLER_DRIFT_OFFSET)
 0313                    forwardTarget -= xzPlaneForward;
 314
 27315                if (characterXAxis.GetValue() > CONTROLLER_DRIFT_OFFSET)
 0316                    forwardTarget += xzPlaneRight;
 27317                if (characterXAxis.GetValue() < -CONTROLLER_DRIFT_OFFSET)
 0318                    forwardTarget -= xzPlaneRight;
 319
 27320                if (forwardTarget.Equals(Vector3.zero))
 27321                    isMovingByUserInput = false;
 322                else
 0323                    isMovingByUserInput = true;
 324
 325
 27326                forwardTarget.Normalize();
 27327                velocity += forwardTarget * speed;
 27328                CommonScriptableObjects.playerUnityEulerAngles.Set(transform.eulerAngles);
 329            }
 330
 5287331            bool jumpButtonPressedWithGraceTime = jumpButtonPressed && (Time.time - lastJumpButtonPressedTime < 0.15f);
 332
 5287333            if (jumpButtonPressedWithGraceTime) // almost-grounded jump button press allowed time
 334            {
 0335                bool justLeftGround = (Time.time - lastUngroundedTime) < 0.1f;
 336
 0337                if (isGrounded || justLeftGround) // just-left-ground jump allowed time
 338                {
 0339                    Jump();
 340                }
 341            }
 342
 343            //NOTE(Mordi): Detecting when the character hits the ground (for landing-SFX)
 5287344            if (isGrounded && !previouslyGrounded && (Time.time - lastUngroundedTime) > 0.4f)
 345            {
 19346                OnHitGround?.Invoke();
 347            }
 348        }
 349
 5287350        if (characterController.enabled)
 351        {
 352            //NOTE(Brian): Transform has to be in sync before the Move call, otherwise this call
 353            //             will reset the character controller to its previous position.
 5287354            Environment.i.platform.physicsSyncController?.Sync();
 5287355            lastCharacterControllerCollision = characterController.Move(velocity * Time.deltaTime);
 356        }
 357
 5287358        SetPosition(PositionUtils.UnityToWorldPosition(transform.position));
 359
 5287360        if ((DCLTime.realtimeSinceStartup - lastMovementReportTime) > PlayerSettings.POSITION_REPORTING_DELAY)
 361        {
 39362            ReportMovement();
 363        }
 364
 5287365        if (isOnMovingPlatform)
 366        {
 0367            SaveLateUpdateGroundTransforms();
 368        }
 5287369        OnUpdateFinish?.Invoke(Time.deltaTime);
 0370    }
 371
 372    private void SaveLateUpdateGroundTransforms()
 373    {
 0374        lastLocalGroundPosition = groundTransform.InverseTransformPoint(transform.position);
 375
 0376        if (CommonScriptableObjects.characterForward.HasValue())
 377        {
 0378            lastCharacterRotation = groundTransform.InverseTransformDirection(CommonScriptableObjects.characterForward.G
 0379            lastGlobalCharacterRotation = CommonScriptableObjects.characterForward.Get().Value;
 380        }
 0381    }
 382
 383    void Jump()
 384    {
 0385        if (isJumping)
 0386            return;
 387
 0388        isJumping = true;
 0389        isGrounded = false;
 390
 0391        ResetGround();
 392
 0393        velocity.y = jumpForce;
 394        //cameraTargetProbe.damping.y = dampingOnAir;
 395
 0396        OnJump?.Invoke();
 0397    }
 398
 399    public void ResetGround()
 400    {
 10548401        if (isOnMovingPlatform)
 0402            CommonScriptableObjects.playerIsOnMovingPlatform.Set(false);
 403
 10548404        isOnMovingPlatform = false;
 10548405        groundTransform = null;
 10548406        movingPlatformSpeed = 0;
 10548407    }
 408
 409    void CheckGround()
 410    {
 5287411        if (groundTransform == null)
 5262412            ResetGround();
 413
 5287414        if (isOnMovingPlatform)
 415        {
 0416            Physics.SyncTransforms();
 417            //NOTE(Brian): This should move the character with the moving platform
 0418            Vector3 newGroundWorldPos = groundTransform.TransformPoint(lastLocalGroundPosition);
 0419            movingPlatformSpeed = Vector3.Distance(newGroundWorldPos, transform.position);
 0420            transform.position = newGroundWorldPos;
 421
 0422            Vector3 newCharacterForward = groundTransform.TransformDirection(lastCharacterRotation);
 0423            Vector3 lastFrameDifference = Vector3.zero;
 0424            if (CommonScriptableObjects.characterForward.HasValue())
 425            {
 0426                lastFrameDifference = CommonScriptableObjects.characterForward.Get().Value - lastGlobalCharacterRotation
 427            }
 428
 429            //NOTE(Kinerius) CameraStateTPS rotates the character between frames so we add the difference.
 430            //               if we dont do this, the character wont rotate when moving, only when the platform rotates
 0431            CommonScriptableObjects.characterForward.Set(newCharacterForward + lastFrameDifference);
 432        }
 433
 5287434        Transform transformHit = CastGroundCheckingRays();
 435
 5287436        if (transformHit != null)
 437        {
 42438            if (groundTransform == transformHit)
 439            {
 24440                bool groundHasMoved = (transformHit.position != groundLastPosition || transformHit.rotation != groundLas
 441
 24442                if (!characterPosition.RepositionedWorldLastFrame()
 443                    && groundHasMoved)
 444                {
 0445                    isOnMovingPlatform = true;
 0446                    CommonScriptableObjects.playerIsOnMovingPlatform.Set(true);
 0447                    Physics.SyncTransforms();
 0448                    SaveLateUpdateGroundTransforms();
 449
 0450                    Quaternion deltaRotation = groundTransform.rotation * Quaternion.Inverse(groundLastRotation);
 0451                    CommonScriptableObjects.movingPlatformRotationDelta.Set(deltaRotation);
 452                }
 0453            }
 454            else
 455            {
 18456                groundTransform = transformHit;
 18457                CommonScriptableObjects.movingPlatformRotationDelta.Set(Quaternion.identity);
 458            }
 18459        }
 460        else
 461        {
 5245462            ResetGround();
 463        }
 464
 5287465        if (groundTransform != null)
 466        {
 42467            groundLastPosition = groundTransform.position;
 42468            groundLastRotation = groundTransform.rotation;
 469        }
 470
 5287471        isGrounded = IsLastCollisionGround() || groundTransform != null && groundTransform.gameObject.activeInHierarchy;
 5287472    }
 473
 474    public Transform CastGroundCheckingRays()
 475    {
 476        RaycastHit hitInfo;
 477
 5287478        var result = CastGroundCheckingRays(transform, collider, groundCheckExtraDistance, 0.9f, groundLayers, out hitIn
 479
 5287480        if ( result )
 481        {
 42482            return hitInfo.transform;
 483        }
 484
 5245485        return null;
 486    }
 487
 488    public bool CastGroundCheckingRays(float extraDistance, float scale, out RaycastHit hitInfo)
 489    {
 5253490        if (CastGroundCheckingRays(transform, collider, extraDistance, scale, groundLayers | cameraLayers , out hitInfo)
 325491            return true;
 492
 4928493        return IsLastCollisionGround();
 494    }
 495
 496    public bool CastGroundCheckingRay(float extraDistance, out RaycastHit hitInfo)
 497    {
 0498        Bounds bounds = collider.bounds;
 0499        float rayMagnitude = (bounds.extents.y + extraDistance);
 0500        bool test = CastGroundCheckingRay(transform.position, out hitInfo, rayMagnitude, groundLayers);
 0501        return IsLastCollisionGround() || test;
 502    }
 503
 504    // We secuentially cast rays in 4 directions (only if the previous one didn't hit anything)
 505    public static bool CastGroundCheckingRays(Transform transform, Collider collider, float extraDistance, float scale, 
 506    {
 10540507        Bounds bounds = collider.bounds;
 508
 10540509        float rayMagnitude = (bounds.extents.y + extraDistance);
 10540510        float originScale = scale * bounds.extents.x;
 511
 10540512        if (!CastGroundCheckingRay(transform.position, out hitInfo, rayMagnitude, groundLayers) // center
 513            && !CastGroundCheckingRay( transform.position + transform.forward * originScale, out hitInfo, rayMagnitude, 
 514            && !CastGroundCheckingRay( transform.position + transform.right * originScale, out hitInfo, rayMagnitude, gr
 515            && !CastGroundCheckingRay( transform.position + -transform.forward * originScale, out hitInfo, rayMagnitude,
 516            && !CastGroundCheckingRay( transform.position + -transform.right * originScale, out hitInfo, rayMagnitude, g
 517        {
 10173518            return false;
 519        }
 520
 521        // At this point there is a guaranteed hit, so this is not null
 367522        return true;
 523    }
 524
 525    public static bool CastGroundCheckingRay(Vector3 origin, out RaycastHit hitInfo, float rayMagnitude, int groundLayer
 526    {
 51232527        var ray = new Ray();
 51232528        ray.origin = origin;
 51232529        ray.direction = Vector3.down * rayMagnitude;
 530
 51232531        var result = Physics.Raycast(ray, out hitInfo, rayMagnitude, groundLayers);
 532
 533#if UNITY_EDITOR
 51232534        if ( result )
 367535            Debug.DrawLine(ray.origin, hitInfo.point, Color.green);
 536        else
 50865537            Debug.DrawRay(ray.origin, ray.direction, Color.red);
 538#endif
 539
 50865540        return result;
 541    }
 542
 543    void ReportMovement()
 544    {
 4931545        float height = 0.875f;
 546
 4931547        var reportPosition = characterPosition.worldPosition + (Vector3.up * height);
 4931548        var compositeRotation = Quaternion.LookRotation(characterForward.HasValue() ? characterForward.Get().Value : cam
 4931549        var playerHeight = height + (characterController.height / 2);
 4931550        var cameraRotation = Quaternion.LookRotation(cameraForward.Get());
 551
 552        //NOTE(Brian): We have to wait for a Teleport before sending the ReportPosition, because if not ReportPosition e
 553        //             When the spawn point is being selected / scenes being prepared to be sent and the Kernel gets cra
 554
 555        //             The race conditions that can arise from not having this flag can result in:
 556        //                  - Scenes not being sent for loading, making ActivateRenderer never being sent, only in WSS m
 557        //                  - Random teleports to 0,0 or other positions that shouldn't happen.
 4931558        if (initialPositionAlreadySet)
 47559            DCL.Interface.WebInterface.ReportPosition(reportPosition, compositeRotation, playerHeight, cameraRotation);
 560
 4931561        lastMovementReportTime = DCLTime.realtimeSinceStartup;
 4931562    }
 563
 564    public void PauseGravity()
 565    {
 40566        gravity = 0f;
 40567        velocity.y = 0f;
 40568    }
 569
 0570    public void ResumeGravity() { gravity = originalGravity; }
 571
 2278572    void OnRenderingStateChanged(bool isEnable, bool prevState) { SetEnabled(isEnable); }
 573
 574    bool IsLastCollisionGround()
 575    {
 0576        return (lastCharacterControllerCollision & CollisionFlags.Below) != 0;
 577    }
 578}
Generated by: ReportGenerator 4.8.9.0
09/09/2022 - 13:27:10
GitHub | www.palmmedia.de

Methods/Properties

i()
i(DCLCharacterController)
DCLCharacterController()
isWalking()
isWalking(System.Boolean)
isMovingByUserInput()
isMovingByUserInput(System.Boolean)
isJumping()
isJumping(System.Boolean)
isGrounded()
isGrounded(System.Boolean)
isOnMovingPlatform()
isOnMovingPlatform(System.Boolean)
characterForward()
cameraForward()
cameraRight()
Awake()
SubscribeToInput()
OnDestroy()
OnWorldReposition(UnityEngine.Vector3, UnityEngine.Vector3)
SetPosition(UnityEngine.Vector3)
Teleport(System.String)
Teleport(UnityEngine.Vector3, UnityEngine.Vector3)
SetPosition(System.String)
SetEnabled(System.Boolean)
Moved(UnityEngine.Vector3, System.Boolean)
LateUpdate()
SaveLateUpdateGroundTransforms()
Jump()
ResetGround()
CheckGround()
CastGroundCheckingRays()
CastGroundCheckingRays(System.Single, System.Single, UnityEngine.RaycastHit&)
CastGroundCheckingRay(System.Single, UnityEngine.RaycastHit&)
CastGroundCheckingRays(UnityEngine.Transform, UnityEngine.Collider, System.Single, System.Single, System.Int32, UnityEngine.RaycastHit&)
CastGroundCheckingRay(UnityEngine.Vector3, UnityEngine.RaycastHit&, System.Single, System.Int32)
ReportMovement()
PauseGravity()
ResumeGravity()
OnRenderingStateChanged(System.Boolean, System.Boolean)
IsLastCollisionGround()