GameVsJam/3d Prototyp/Assets/Scripts/Character.cs

using System.Collections;
using System.Collections.Generic;
using Data;
using Interaction;
using TMPro.Examples;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.Serialization;
using Utility;

public class Character : MonoBehaviour
{
    [Header("Movement")]
    public float moveSpeed = 2f;
    public float groundDrag = 1f;

    private float horizontalInput, verticalInput;
    private Vector3 moveDirection;
    private Rigidbody rb;

    public float speed = 2f;

    [Header("Turning")]
    public float turningRate = 30f;
    public Quaternion _targetRotation = Quaternion.identity;

    [Header("Keybindings")]
    public KeyCode jumpKey = KeyCode.Space;

    public float jumpForce;
    public float jumpCooldown;
    bool readyToJump = true;

    [Header("Groud Check")]
    public float playerHeight;
    public LayerMask whatIsGround;
    public bool grounded;

    [Header("Hold item")]
    [SerializeField] private Transform _hand;
    [FormerlySerializedAs("_carriedItem")] [SerializeField] private GameObject _carriedItemModel;
    [SerializeField] private PickupInteractible _carriedInteractible;
    [FormerlySerializedAs("_throwAsideForce")] [SerializeField, Tooltip("Die Kraft mit der der Gegenstand fallen gelassen wird.")]
    private float _dropItemForce = 3.0f;

    [SerializeField]
    private GottfriedData _data;

    [SerializeField]
    private AudioSource _audioSource;
    
    public bool CarriesItem => _carriedInteractible;

    public PickupInteractible CarriedItem => _carriedInteractible;
    
    // Start is called before the first frame update
    void Start()
    {
        rb = gameObject.GetComponent<Rigidbody>();
    }

    // Update is called once per frame
    void Update()
    {
        grounded = Physics.Raycast(transform.position, Vector3.down, playerHeight * 0.5f + 0.2f, whatIsGround);

        SpeedControl();

        transform.rotation = Quaternion.RotateTowards(transform.rotation, _targetRotation, turningRate * Time.deltaTime);

        if (grounded)
        {
            rb.drag = groundDrag;
        }
        else
        {
            rb.drag = 0.3f;
        }

    }

    public void PickupItem(PickupInteractible itemToPickup)
    {
        if (_carriedInteractible)
        {
            _carriedInteractible.gameObject.SetActive(true);
            _carriedInteractible.transform.parent = null;

            _carriedInteractible.transform.position = _carriedItemModel.transform.position;
            _carriedInteractible.transform.rotation = _carriedItemModel.transform.rotation;
            
            Rigidbody rigidbody = _carriedInteractible.GetComponent<Rigidbody>();
            
            rigidbody.AddForce(Random.insideUnitSphere * _dropItemForce, ForceMode.Impulse);
            
            Destroy(_carriedItemModel);
            
            _carriedItemModel = null;
            _carriedInteractible = null;
        }

        if (itemToPickup)
        {
            GameObject model = Instantiate(itemToPickup.Model, _hand);

            itemToPickup.transform.parent = model.transform;
            itemToPickup.gameObject.SetActive(false);
            
            _carriedItemModel = model;
            _carriedInteractible = itemToPickup;
        }
    }

    private void FixedUpdate()
    {
        MovePlayer();
    }

    public void DoMove(InputAction.CallbackContext context)
    {
        Vector2 movement = context.ReadValue<Vector2>();

        horizontalInput = movement.x;
        verticalInput = movement.y;
        
        if(horizontalInput != 0f || verticalInput != 0f)
        {
            _targetRotation = Quaternion.Euler(new Vector3(0f, Mathf.Atan2(horizontalInput, verticalInput) * Mathf.Rad2Deg, 0f));
        }
    }
    
    public void DoJump(InputAction.CallbackContext context)
    {
        if (!context.performed || !readyToJump || !grounded)
            return;
        
        Jump();

        Invoke(nameof(ResetJump), jumpCooldown);
    }

    public void DoDropItem(InputAction.CallbackContext context)
    {
        if (!context.performed)
            return;
        
        PickupItem(null);
    }

    private void MovePlayer()
    {
        moveDirection = new Vector3(0, 0, verticalInput) + new Vector3(horizontalInput, 0, 0);
        
        rb.AddForce(moveDirection.normalized * moveSpeed * 10f, ForceMode.Force);
    }

    private void SpeedControl()
    {
        Vector3 flatVel = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

        if (flatVel.magnitude > moveSpeed)
        {
            Vector3 limitedVel = flatVel.normalized * moveSpeed;
            rb.velocity = new Vector3(limitedVel.x, rb.velocity.y, limitedVel.z);
        }
    }

    private void Jump()
    {
        rb.velocity = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

        rb.AddForce(transform.up * jumpForce, ForceMode.Impulse);
    }

    private void ResetJump()
    {
        readyToJump = true;
    }

    public void GiveItemTo(Developer developer)
    {
        Debug.Log($"Gebe {_carriedInteractible.Name} an {developer.Name}");

        PickupInteractible item = _carriedInteractible;

        if (item == null)
            return;
        
        switch (item.ItemType)
        {
            case ItemType.Coffee:
                developer.GiveDrink(0.4, WantedConsumable.Drink);
                break;
            case ItemType.Mate:
                developer.GiveDrink(0.4, WantedConsumable.Mate);
                break;
            case ItemType.Pizza:
                developer.GiveFood(0.25, WantedConsumable.Pizza);
                break;
        }

        item.UsesLeft--;

        if (item.UsesLeft <= 0)
        {
            PickupItem(null);
        
            Destroy(item.gameObject);   
        }
    }

    public void SayItsImpossible()
    {
        _audioSource.PlayOneShot(_data.VoiceSayItsImpossible.GetRandomElement());
    }
}