Source Engine Movement Basics Implemented in Godot and Unity

SimpleCameraController.cs

using UnityEngine;

namespace UnityTemplateProjects
{
    public class SimpleCameraController : MonoBehaviour
    {
        class CameraState
        {
            public float yaw;
            public float pitch;
            public float roll;
            public float x;
            public float y;
            public float z;

            public void SetFromTransform(Transform t)
            {
                pitch = t.eulerAngles.x;
                yaw = t.eulerAngles.y;
                roll = t.eulerAngles.z;
                x = t.position.x;
                y = t.position.y;
                z = t.position.z;
            }

            public void Translate(Vector3 translation)
            {
                Vector3 rotatedTranslation = Quaternion.Euler(pitch, yaw, roll) * translation;

				x += rotatedTranslation.x;
				y += rotatedTranslation.y;
                z += rotatedTranslation.z;
            }

            public void LerpTowards(CameraState target, float positionLerpPct, float rotationLerpPct)
            {
                yaw = Mathf.Lerp(yaw, target.yaw, rotationLerpPct);
                pitch = Mathf.Lerp(pitch, target.pitch, rotationLerpPct);
                roll = Mathf.Lerp(roll, target.roll, rotationLerpPct);
                
                x = Mathf.Lerp(x, target.x, positionLerpPct);
                y = Mathf.Lerp(y, target.y, positionLerpPct);
                z = Mathf.Lerp(z, target.z, positionLerpPct);
            }

            public void UpdateTransform(Transform t)
            {
                t.eulerAngles = new Vector3(pitch, yaw, roll);
                t.position = new Vector3(x, y, z);
            }
        }
        
        CameraState m_TargetCameraState = new CameraState();
        CameraState m_InterpolatingCameraState = new CameraState();

        [Header("Movement Settings")]
        [Tooltip("Exponential boost factor on translation, controllable by mouse wheel.")]
        public float boost = 3.5f;

        [Tooltip("Time it takes to interpolate camera position 99% of the way to the target."), Range(0.001f, 1f)]
        public float positionLerpTime = 0.2f;

        [Header("Rotation Settings")]
        [Tooltip("X = Change in mouse position.\nY = Multiplicative factor for camera rotation.")]
        public AnimationCurve mouseSensitivityCurve = new AnimationCurve(new Keyframe(0f, 0.5f, 0f, 5f), new Keyframe(1f, 2.5f, 0f, 0f));

        [Tooltip("Time it takes to interpolate camera rotation 99% of the way to the target."), Range(0.001f, 1f)]
        public float rotationLerpTime = 0.01f;

        [Tooltip("Whether or not to invert our Y axis for mouse input to rotation.")]
        public bool invertY = false;

        void OnEnable()
        {
            m_TargetCameraState.SetFromTransform(transform);
            m_InterpolatingCameraState.SetFromTransform(transform);
        }

        Vector3 GetInputTranslationDirection()
        {
            Vector3 direction = new Vector3();
            if (Input.GetKey(KeyCode.W))
            {
                direction += Vector3.forward;
            }
            if (Input.GetKey(KeyCode.S))
            {
                direction += Vector3.back;
            }
            if (Input.GetKey(KeyCode.A))
            {
                direction += Vector3.left;
            }
            if (Input.GetKey(KeyCode.D))
            {
                direction += Vector3.right;
            }
            if (Input.GetKey(KeyCode.Q))
            {
                direction += Vector3.down;
            }
            if (Input.GetKey(KeyCode.E))
            {
                direction += Vector3.up;
            }
            return direction;
        }
        
        void Update()
        {
            // Exit Sample  

            if (Input.GetKey(KeyCode.Escape))
            {
                Application.Quit();
				#if UNITY_EDITOR
				UnityEditor.EditorApplication.isPlaying = false; 
				#endif
            }
            // Hide and lock cursor when right mouse button pressed
            if (Input.GetMouseButtonDown(1))
            {
                Cursor.lockState = CursorLockMode.Locked;
            }

            // Unlock and show cursor when right mouse button released
            if (Input.GetMouseButtonUp(1))
            {
                Cursor.visible = true;
                Cursor.lockState = CursorLockMode.None;
            }

            // Rotation
            if (Input.GetMouseButton(1))
            {
                var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));
                
                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }
            
            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (Input.GetKey(KeyCode.LeftShift))
            {
                translation *= 10.0f;
            }
            
            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost += Input.mouseScrollDelta.y * 0.2f;
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
    }

}

source movement.gd

extends KinematicBody

export(float) var maxAccel = 10
export(float) var maxAirAccel = 300
export(float) var friction = 4.0
export(float) var maxSpeed = 6.096
var stopSpeed: float = (5.0/16.0) * maxSpeed
export(float) var mouseSensitivity = 2.5
export(float) var gravity = -15.24
var crouch = false setget SetCrouch
var onGround := true
var velocity := Vector3()
var speed := 0.0
var accelDir := Vector3()
var hasJumped := false
onready var camera := $Camera
onready var speedLabel := $UI/Speed
onready var bullet := preload("res://Scenes/Bullet.tscn")
var isFiring = false


func _ready():
	Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

func _exit_tree():
	Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

func _physics_process(delta):
	# Add half gravity. (We add the rest later. This is
	# the correct way to integrate gravity into the physics through leapfrog integration.)
	velocity.y += delta*gravity*.5
	
	
	# Calculate inputVector from input:
	var inputVector = Vector3()
	
	if Input.is_action_pressed("ui_forward"):
		inputVector.z += 1
	if Input.is_action_pressed("ui_backward"):
		inputVector.z -= 1
	if Input.is_action_pressed("ui_right"):
		inputVector.x -= 1
	if Input.is_action_pressed("ui_left"):
		inputVector.x += 1

	if Input.is_action_just_pressed("ui_crouch"):
		SetCrouch(true)
	elif Input.is_action_just_released("ui_crouch"):
		SetCrouch(false)

	if Input.is_action_pressed("attack1"):
		tryFire()
	elif Input.is_action_just_released("attack1"):
		isFiring = false
	
	inputVector = inputVector.normalized()
	
	# Translate inputVector to world-space based on camera:
	accelDir = Vector3()
	var cameraTransform: Transform = camera.get_global_transform()
	var camBasisZ = Vector3(cameraTransform.basis.z.x, 0, cameraTransform.basis.z.z) # gets rid of the vertical part
	accelDir -= camBasisZ.normalized() * inputVector.z
	accelDir -= cameraTransform.basis.x.normalized() * inputVector.x
	accelDir = accelDir.normalized()

	# Apply friction:
	speed = Vector2(velocity.x, velocity.z).length() # We only really care about lateral speed
	Friction(delta)



	var projectedSpeed: float  = velocity.dot(accelDir) # How much our current speed applies to our desired direction
	var addSpeed:       float  = (maxSpeed if onGround else (3.0/40.0) * maxSpeed) - projectedSpeed
	if addSpeed < 0.0:
		addSpeed = 0.0
	var accelSpeed:     float  = clamp((maxAccel if onGround else maxAirAccel) * maxSpeed * delta, 0.0, addSpeed)
	
	velocity += accelDir * accelSpeed

	if onGround:
		if Input.is_action_pressed("ui_jump") and !hasJumped:
			velocity.y += 5.1111
			hasJumped = true

	# Apply other half of gravity:
	velocity.y += delta*gravity*.5
	
	velocity = move_and_slide(velocity, Vector3(0,1,0), true, 4, deg2rad(45.0),false)
	if is_on_floor():
		onGround = true
		hasJumped = false
	if !is_on_floor():
		onGround = false
	speedLabel.text = str(Vector2(velocity.x,velocity.z).length())
	

func Friction(delta):
	var control
	var drop = 0.0
	if speed < 0.00191:
		return
	if onGround && !Input.is_action_pressed("ui_jump"):
		control = stopSpeed if speed < stopSpeed else speed
		drop = control*friction*delta
	var newSpeed = speed - drop
	if newSpeed < 0:
		newSpeed = 0
	newSpeed /= speed
	velocity *= newSpeed

func SetCrouch(newVal):
	crouch = newVal
	if crouch:
		self.scale = Vector3(1.0, (16.0/21.0), 1.0)
		self.translate_object_local(Vector3(0.0,2.648/2.0,0.0))
	else:
		self.scale = Vector3(1.0, 1.0, 1.0)
		#self.translate_object_local(Vector3(0.0,-16.0/21.0,0.0))


func _input(event):
	var actualMouseSensitivity: float = mouseSensitivity * 0.022
	if event is InputEventMouseMotion and Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED:
		self.rotation.y -= deg2rad(event.relative.x * actualMouseSensitivity)
		camera.rotation.x = deg2rad(clamp(camera.rotation_degrees.x - event.relative.y * actualMouseSensitivity,-89.9,89.9))

signal shootBullet(bulletResource, dir, pos)
func tryFire():
	if isFiring == true:
		return
	else:
		isFiring = true
		emit_signal("shootBullet", bullet, Vector3(-1*camera.rotation.x, rotation.y, 0), translation+camera.translation)
		yield(get_tree().create_timer(.1), "timeout")
		isFiring = false