protected override void OnUpdate()
        {
            var deltaTime = Time.deltaTime;

            for (int i = 0; i != m_Group.Length; i++)
            {
                var entity            = m_Group.Entities[i];
                var component         = m_Group.Components[i];
                var transform         = new DWorldTransformData(m_Group.Positions[i].Value, m_Group.Rotations[i].Value);
                var rigidbody         = m_Group.Rigidbodies[i];
                var character         = m_Group.Characters[i];
                var detail            = m_Group.Details[i];
                var characterCollider = m_Group.CharacterColliders[i];
                var movementCollider  = characterCollider.MovementCollider;

                var addedVelocity = character.EditableCurrent.AddedVelocity;
                var rbVelocity    = rigidbody.velocity;
                var newPosition   = transform.Position;
                var newRotation   = transform.Rotation;
                var isGrounded    = character.EditableCurrent.IsGrounded;
                var wasJumping    = component.IsJumping;

                component.WantToJump = detail.WantToJump;
                if (component.WantToJump)
                {
                    component.IsJumping = false;
                    if (!wasJumping)
                    {
                        isGrounded = false;

                        //</ IncreaseJump()
                        addedVelocity.y += component.JumpPower;
                        rbVelocity.y     = component.JumpPower;
                        //>/

                        component.IsJumping        = true;
                        component.HasDoneExtraJump = false;
                    }
                }

                /*if (component.IsJumping && component.WantToJump && component.JumpTime > 0.175f && !component.HasDoneExtraJump
                 *  && rbVelocity.y >= 0)
                 * {
                 *  component.HasDoneExtraJump = true;
                 *
                 *  //</ IncreaseJump() (a little)
                 *  runVelocity.y += (component.AfterJumpPower) * 1;
                 *  rbVelocity.y  += (component.AfterJumpPower) * 1;
                 *  //>/
                 * }*/

                if (component.IsJumping)
                {
                    component.JumpTime += deltaTime;
                }
                else
                {
                    component.JumpTime         = 0f;
                    component.HasDoneExtraJump = false;
                }

                // Do we like... care about velocities?
                //newPosition += rbVelocity * deltaTime;

                rigidbody.velocity = rbVelocity;
                character.EditableCurrent.IsGrounded    = isGrounded;
                character.EditableCurrent.AddedVelocity = addedVelocity;
                transform.Position = newPosition;
                transform.Rotation = newRotation;
                characterCollider.RotateGameObject.rotation = newRotation;

                entity.SetComponentData(component);

                m_TransformManager.UpdateTransform(entity, transform);
                m_CharacterManager.UpdateCharacter(entity, character);
            }
        }
        protected override void OnUpdate()
        {
            var deltaTime = Time.deltaTime;
            var jumpInput = Input.GetButtonDown("Jump");

            for (int i = 0; i != m_Group.Length; i++)
            {
                var entity               = m_Group.Entities[i];
                var detail               = m_Group.Details[i];
                var component            = m_Group.Components[i];
                var transform            = new DWorldTransformData(m_Group.Positions[i].Value, m_Group.Rotations[i].Value);
                var rigidbody            = m_Group.Rigidbodies[i];
                var character            = m_Group.Characters[i];
                var characterInformation = m_Group.CharacterInformations[i];
                var characterCollider    = m_Group.CharacterColliders[i];
                var movementCollider     = characterCollider.MovementCollider;

                var charFrameInfo = character.EditableCurrent;

                var runVelocity = charFrameInfo.AddedVelocity;
                var rbVelocity  = rigidbody.velocity;
                var newPosition = transform.Position;
                var newRotation = transform.Rotation;

                var scaledVector = new Vector3
                                   (
                    charFrameInfo.Direction.x,
                    charFrameInfo.Direction.y,
                    charFrameInfo.Direction.z
                                   );
                var n = transform.Rotation * Vector3.forward;

                /*scaledVector.x = ClampAbs(scaledVector.x, n.x);
                *  scaledVector.y = n.y;
                *  scaledVector.z = ClampAbs(scaledVector.z, n.z);*/

                scaledVector = scaledVector.normalized;
                // flatten the ray Y
                scaledVector.y = 0;
                //scaledVector = characterInformation.CurrentVelocity;

                var ray = new Ray(movementCollider.GetWorldCenter(transform.Position, transform.Rotation),
                                  scaledVector);
                Debug.DrawRay(ray.origin, ray.direction, Color.blue, 0.25f);



                if (detail.WantToWalljump && !charFrameInfo.IsGrounded)
                {
                    if (Physics.Raycast(ray, out var hitInfo, 1.5f))
                    {
                        //Debug.DrawRay(hitInfo.point, hitInfo.normal, Color.red, 0.25f);
                        //</ IncreaseJump()
                        var normal = hitInfo.normal;
                        normal.y = normal.y;


                        var dirPower = scaledVector;

                        var jumpPowerY = entity.GetComponentData <STDefault_Jump>().JumpPower;

                        var result = Vector3.Reflect(dirPower * (characterInformation.PreviousVelocity.magnitude / rigidbody.mass), hitInfo.normal);
                        result.y += jumpPowerY / rigidbody.mass;
                        Debug.Log($"{result} {ray.direction}");
                        //result.y += 1 / component.WallJumpPower;

                        Debug.DrawRay(hitInfo.point, result, Color.red, 0.25f);

                        runVelocity += (result);
                        rbVelocity  += (result);

                        charFrameInfo.Direction = result.normalized;
                        //>/
                    }
                }

                rigidbody.velocity          = rbVelocity;
                charFrameInfo.AddedVelocity = runVelocity;
                transform.Position          = newPosition;
                transform.Rotation          = newRotation;

                character.EditableCurrent = charFrameInfo;
                characterCollider.RotateGameObject.rotation = newRotation;

                entity.SetComponentData(component);

                m_TransformManager.UpdateTransform(entity, transform);
                m_CharacterManager.UpdateCharacter(entity, character);
            }
        }