denis/riz-au-lait-ui
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Copie depuis Unity VCS vers GitHub

Browse Source
This commit is contained in:
Denis L.
2025-12-10 18:51:40 +01:00
parent 5cfd9de581
commit 7383621db3
902 changed files with 588195 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

348
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/CharacterMover.cs Normal file
View File

@@ -0,0 +1,348 @@
using System;
using UnityEngine;
namespace Controller
{
[RequireComponent(typeof(CharacterController))]
[RequireComponent(typeof(Animator))]
[DisallowMultipleComponent]
public class CharacterMover : MonoBehaviour
{
[Header("Movement")]
[SerializeField]
private float m_WalkSpeed = 1f;
[SerializeField]
private float m_RunSpeed = 4f;
[SerializeField, Range(0f, 360f)]
private float m_RotateSpeed = 90f;
[SerializeField]
private Space m_Space = Space.Self;
[SerializeField]
private float m_JumpHeight = 5f;
[Header("Animator")]
[SerializeField]
private string m_HorizontalID = "Hor";
[SerializeField]
private string m_VerticalID = "Vert";
[SerializeField]
private string m_StateID = "State";
[SerializeField]
private string m_JumpID = "IsJump";
[SerializeField]
private LookWeight m_LookWeight = new(1f, 0.3f, 0.7f, 1f);
private Transform m_Transform;
private CharacterController m_Controller;
private Animator m_Animator;
private MovementHandler m_Movement;
private AnimationHandler m_Animation;
private Vector2 m_Axis;
private Vector3 m_Target;
private bool m_IsRun;
private bool m_IsJump;
private bool m_IsMoving;
public Vector2 Axis => m_Axis;
public Vector3 Target => m_Target;
public bool IsRun => m_IsRun;
private void OnValidate()
{
m_WalkSpeed = Mathf.Max(m_WalkSpeed, 0f);
m_RunSpeed = Mathf.Max(m_RunSpeed, m_WalkSpeed);
m_Movement?.SetStats(m_WalkSpeed / 3.6f, m_RunSpeed / 3.6f, m_RotateSpeed, m_JumpHeight, m_Space);
}
private void Awake()
{
m_Transform = transform;
m_Controller = GetComponent<CharacterController>();
m_Animator = GetComponent<Animator>();
m_Movement = new MovementHandler(m_Controller, m_Transform, m_WalkSpeed, m_RunSpeed, m_RotateSpeed, m_JumpHeight, m_Space);
m_Animation = new AnimationHandler(m_Animator, m_HorizontalID, m_VerticalID, m_StateID, m_JumpID);
}
private void Update()
{
m_Movement.Move(Time.deltaTime, in m_Axis, in m_Target, m_IsRun, m_IsJump, m_IsMoving, out var animAxis, out var isAir);
m_Animation.Animate(in animAxis, m_IsRun? 1f : 0f, isAir, Time.deltaTime);
}
private void OnAnimatorIK()
{
m_Animation.AnimateIK(in m_Target, m_LookWeight);
}
public void SetInput(in Vector2 axis, in Vector3 target, in bool isRun, in bool isJump)
{
m_Axis = axis;
m_Target = target;
m_IsRun = isRun;
m_IsJump = isJump;
if (m_Axis.sqrMagnitude < Mathf.Epsilon)
{
m_Axis = Vector2.zero;
m_IsMoving = false;
}
else
{
m_Axis = Vector3.ClampMagnitude(m_Axis, 1f);
m_IsMoving = true;
}
}
private void OnControllerColliderHit(ControllerColliderHit hit)
{
if(hit.normal.y > m_Controller.stepOffset)
{
m_Movement.SetSurface(hit.normal);
}
}
[Serializable]
private struct LookWeight
{
public float weight;
public float body;
public float head;
public float eyes;
public LookWeight(float weight, float body, float head, float eyes)
{
this.weight = weight;
this.body = body;
this.head = head;
this.eyes = eyes;
}
}
#region Handlers
private class MovementHandler
{
private readonly CharacterController m_Controller;
private readonly Transform m_Transform;
private float m_WalkSpeed;
private float m_RunSpeed;
private float m_RotateSpeed;
private float m_JumpHeight;
private Space m_Space;
private readonly float m_Luft = 75f;
private readonly float m_JumpReload = 1f;
private float m_TargetAngle;
private bool m_IsRotating = false;
private Vector3 m_Normal;
private Vector3 m_GravityAcelleration = Physics.gravity;
private float m_jumpTimer;
public MovementHandler(CharacterController controller, Transform transform, float walkSpeed, float runSpeed, float rotateSpeed, float jumpHeight, Space space)
{
m_Controller = controller;
m_Transform = transform;
m_WalkSpeed = walkSpeed;
m_RunSpeed = runSpeed;
m_RotateSpeed = rotateSpeed;
m_JumpHeight = jumpHeight;
m_Space = space;
}
public void SetStats(float walkSpeed, float runSpeed, float rotateSpeed, float jumpHeight, Space space)
{
m_WalkSpeed = walkSpeed;
m_RunSpeed = runSpeed;
m_RotateSpeed = rotateSpeed;
m_JumpHeight = jumpHeight;
m_Space = space;
}
public void SetSurface(in Vector3 normal)
{
m_Normal = normal;
}
public void Move(float deltaTime, in Vector2 axis, in Vector3 target, bool isRun, bool isJump, bool isMoving, out Vector2 animAxis, out bool isAir)
{
var targetForward = Vector3.Normalize(target - m_Transform.position);
ConvertMovement(in axis, in targetForward, out var movement);
CaculateGravity(isJump, deltaTime, out isAir);
Displace(deltaTime, in movement, isRun);
Turn(in targetForward, isMoving);
UpdateRotation(deltaTime);
GenAnimationAxis(in movement, out animAxis);
}
private void ConvertMovement(in Vector2 axis, in Vector3 targetForward, out Vector3 movement)
{
Vector3 forward;
Vector3 right;
if (m_Space == Space.Self)
{
forward = new Vector3(targetForward.x, 0f, targetForward.z).normalized;
right = Vector3.Cross(Vector3.up, forward).normalized;
}
else
{
forward = Vector3.forward;
right = Vector3.right;
}
movement = axis.x * right + axis.y * forward;
movement = Vector3.ProjectOnPlane(movement, m_Normal);
}
private void Displace(float deltaTime, in Vector3 movement, bool isRun)
{
Vector3 displacement = (isRun ? m_RunSpeed : m_WalkSpeed) * movement;
displacement += m_GravityAcelleration;
displacement *= deltaTime;
m_Controller.Move(displacement);
}
private void CaculateGravity(bool isJump, float deltaTime, out bool isAir)
{
m_jumpTimer = Mathf.Max(m_jumpTimer - deltaTime, 0f);
if (m_Controller.isGrounded)
{
if (isJump && m_jumpTimer <= 0)
{
var gravity = Physics.gravity;
var length = gravity.magnitude;
m_GravityAcelleration += -(gravity / length) * Mathf.Sqrt(m_JumpHeight * 6f * length);
m_jumpTimer = m_JumpReload;
isAir = true;
return;
}
m_GravityAcelleration = Physics.gravity;
isAir = false;
return;
}
isAir = true;
m_GravityAcelleration += Physics.gravity * deltaTime;
return;
}
private void GenAnimationAxis(in Vector3 movement, out Vector2 animAxis)
{
if(m_Space == Space.Self)
{
animAxis = new Vector2(Vector3.Dot(movement, m_Transform.right), Vector3.Dot(movement, m_Transform.forward));
}
else
{
animAxis = new Vector2(Vector3.Dot(movement, Vector3.right), Vector3.Dot(movement, Vector3.forward));
}
}
private void Turn(in Vector3 targetForward, bool isMoving)
{
var angle = Vector3.SignedAngle(m_Transform.forward, Vector3.ProjectOnPlane(targetForward, Vector3.up), Vector3.up);
if (!m_IsRotating)
{
if (!isMoving && Mathf.Abs(angle) < m_Luft)
{
m_IsRotating = false;
return;
}
m_IsRotating = true;
}
m_TargetAngle = angle;
}
private void UpdateRotation(float deltaTime)
{
if(!m_IsRotating)
{
return;
}
var rotDelta = m_RotateSpeed * deltaTime;
if (rotDelta + Mathf.PI * 2f + Mathf.Epsilon >= Mathf.Abs(m_TargetAngle))
{
rotDelta = m_TargetAngle;
m_IsRotating = false;
}
else
{
rotDelta *= Mathf.Sign(m_TargetAngle);
}
m_Transform.Rotate(Vector3.up, rotDelta);
}
}
private class AnimationHandler
{
private readonly Animator m_Animator;
private readonly string m_HorizontalID;
private readonly string m_VerticalID;
private readonly string m_StateID;
private readonly string m_JumpID;
private readonly float k_InputFlow = 4.5f;
private float m_FlowState;
private Vector2 m_FlowAxis;
public AnimationHandler(Animator animator, string horizontalID, string verticalID, string stateID, string jumpID)
{
m_Animator = animator;
m_HorizontalID = horizontalID;
m_VerticalID = verticalID;
m_StateID = stateID;
m_JumpID = jumpID;
}
public void Animate(in Vector2 axis, float state, bool isJump, float deltaTime)
{
m_Animator.SetFloat(m_HorizontalID, m_FlowAxis.x);
m_Animator.SetFloat(m_VerticalID, m_FlowAxis.y);
m_Animator.SetFloat(m_StateID, Mathf.Clamp01(m_FlowState));
m_Animator.SetBool(m_JumpID, isJump);
m_FlowAxis = Vector2.ClampMagnitude(m_FlowAxis + k_InputFlow * deltaTime * (axis - m_FlowAxis).normalized, 1f);
m_FlowState = Mathf.Clamp01(m_FlowState + k_InputFlow * deltaTime * Mathf.Sign(state - m_FlowState));
}
public void AnimateIK(in Vector3 target, in LookWeight lookWeight)
{
m_Animator.SetLookAtPosition(target);
m_Animator.SetLookAtWeight(lookWeight.weight, lookWeight.body, lookWeight.head, lookWeight.eyes);
}
}
#endregion
}
}

18
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/CharacterMover.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: f75db5b538eef814b9775d744f05e3b5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 304841
packageName: Creative Characters FREE - Animated Low Poly 3D Models
packageVersion: 2.2
assetPath: Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/CharacterMover.cs
uploadId: 780839

86
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/MovePlayerInput.cs Normal file
View File

@@ -0,0 +1,86 @@
using UnityEngine;
namespace Controller
{
[RequireComponent(typeof(CharacterMover))]
public class MovePlayerInput : MonoBehaviour
{
[Header("Character")]
[SerializeField]
private string m_HorizontalAxis = "Horizontal";
[SerializeField]
private string m_VerticalAxis = "Vertical";
[SerializeField]
private string m_JumpButton = "Jump";
[SerializeField]
private KeyCode m_RunKey = KeyCode.LeftShift;
[Header("Camera")]
[SerializeField]
private PlayerCamera m_Camera;
[SerializeField]
private string m_MouseX = "Mouse X";
[SerializeField]
private string m_MouseY = "Mouse Y";
[SerializeField]
private string m_MouseScroll = "Mouse ScrollWheel";
private CharacterMover m_Mover;
private Vector2 m_Axis;
private bool m_IsRun;
private bool m_IsJump;
private Vector3 m_Target;
private Vector2 m_MouseDelta;
private float m_Scroll;
private void Awake()
{
m_Mover = GetComponent<CharacterMover>();
if(m_Camera == null )
{
m_Camera = Camera.main == null ? null : Camera.main.GetComponent<PlayerCamera>();
}
if(m_Camera != null) {
m_Camera.SetPlayer(transform);
}
}
private void Update()
{
GatherInput();
SetInput();
}
public void GatherInput()
{
m_Axis = new Vector2(Input.GetAxis(m_HorizontalAxis), Input.GetAxis(m_VerticalAxis));
m_IsRun = Input.GetKey(m_RunKey);
m_IsJump = Input.GetButton(m_JumpButton);
m_Target = (m_Camera == null) ? Vector3.zero : m_Camera.Target;
m_MouseDelta = new Vector2(Input.GetAxis(m_MouseX), Input.GetAxis(m_MouseY));
m_Scroll = Input.GetAxis(m_MouseScroll);
}
public void BindMover(CharacterMover mover)
{
m_Mover = mover;
}
public void SetInput()
{
if (m_Mover != null)
{
m_Mover.SetInput(in m_Axis, in m_Target, in m_IsRun, m_IsJump);
}
if (m_Camera != null)
{
m_Camera.SetInput(in m_MouseDelta, m_Scroll);
}
}
}
}

18
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/MovePlayerInput.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: b2c67ce836140b4479603ebcf944cddd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 304841
packageName: Creative Characters FREE - Animated Low Poly 3D Models
packageVersion: 2.2
assetPath: Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/MovePlayerInput.cs
uploadId: 780839

64
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/PlayerCamera.cs Normal file
View File

@@ -0,0 +1,64 @@
using UnityEngine;
namespace Controller
{
public abstract class PlayerCamera : MonoBehaviour
{
private const float MIN_DISTANCE = 1f;
private const float MAX_DISTANCE = 10f;
private const float TARGET_DISTANCE = MAX_DISTANCE * 2f;
protected Transform m_Player;
[SerializeField, Range(0f, 1f)]
private float m_SensitivityX = 0.1f;
[SerializeField, Range(0f, 1f)]
private float m_SensitivityY = 0.1f;
[SerializeField, Range(0f, 1f)]
private float m_Zoom = 0.5f;
[SerializeField, Range(0f, 1f)]
private float m_SensetivityZoom = 0.1f;
[SerializeField, Range(0, 90f)]
private float m_MinAngle = 0f;
[SerializeField, Range(0, 90f)]
private float m_MaxAngle = 50f;
protected Transform m_Target;
protected Transform m_Transform;
protected Vector2 m_Angles;
protected float m_Distance;
public Vector3 Target => m_Target.position;
public float TargetDistance => TARGET_DISTANCE;
protected virtual void Awake()
{
m_Transform = transform;
m_Target = new GameObject($"Target_{gameObject.name}").transform;
if(m_Transform.parent != null)
{
m_Target.transform.parent = m_Transform.parent;
}
}
public void SetPlayer(Transform player) {
m_Player = player;
}
public virtual void SetInput(in Vector2 delta, float scroll)
{
m_Angles += new Vector2(delta.y * m_SensitivityY, delta.x * m_SensitivityX) * 360f;
m_Angles.x = Mathf.Clamp(m_Angles.x, m_MinAngle, m_MaxAngle);
m_Zoom += scroll * m_SensetivityZoom;
m_Zoom = Mathf.Clamp01(m_Zoom);
m_Distance = (1f - m_Zoom) * (MAX_DISTANCE - MIN_DISTANCE) + MIN_DISTANCE;
}
}
}

18
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/PlayerCamera.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 6e64ae1274b15fa4fbea3733685f5b29
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 304841
packageName: Creative Characters FREE - Animated Low Poly 3D Models
packageVersion: 2.2
assetPath: Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/PlayerCamera.cs
uploadId: 780839

65
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/ThirdPersonCamera.cs Normal file
View File

@@ -0,0 +1,65 @@
using UnityEngine;
namespace Controller
{
public class ThirdPersonCamera : PlayerCamera
{
[SerializeField, Range(0f, 2f)]
private float m_Offset = 1.5f;
[SerializeField, Range(0f, 360f)]
private float m_CameraSpeed = 90f;
private Vector3 m_LookPoint;
private Vector3 m_TargetPos;
private void LateUpdate()
{
Move(Time.deltaTime);
}
public override void SetInput(in Vector2 delta, float scroll)
{
base.SetInput(delta, scroll);
var dir = new Vector3(0, 0, -m_Distance);
var rot = Quaternion.Euler(m_Angles.x, m_Angles.y, 0f);
var playerPos = (m_Player == null) ? Vector3.zero : m_Player.position;
m_LookPoint = playerPos + m_Offset * Vector3.up;
m_TargetPos = m_LookPoint + rot * dir;
}
private void Move(float deltaTime)
{
camera();
target();
void camera()
{
var direction = m_TargetPos - m_Transform.position;
var delta = m_CameraSpeed * deltaTime;
if(delta * delta > direction.sqrMagnitude)
{
m_Transform.position = m_TargetPos;
}
else
{
m_Transform.position += delta * direction.normalized;
}
m_Transform.LookAt(m_LookPoint);
}
void target()
{
if(m_Target == null)
{
return;
}
m_Target.position = m_Transform.position + m_Transform.forward * TargetDistance;
}
}
}
}

18
Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/ThirdPersonCamera.cs.meta Normal file
View File

@@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: b7f4329458cdb464796191393167d4f9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 304841
packageName: Creative Characters FREE - Animated Low Poly 3D Models
packageVersion: 2.2
assetPath: Assets/ithappy/Creative_Characters_FREE/Scripts/Character_Controller/ThirdPersonCamera.cs
uploadId: 780839