Creating a Text-Background that Resizes According to the Text

Labels:

Avoiding Obstacles While Moving to a Point Using NavMesh


NavMeshPointMovement.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using UnityEngine;
using UnityEngine.AI;
 
public class NavMeshPointMovement : MonoBehaviour
{
    NavMeshAgent agent;
    RaycastHit hit;
 
    void Awake()
    {
        agent = GetComponent<NavMeshAgent>();
    }
 
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, 100, LayerMask.GetMask("Ground")))
            {
                agent.SetDestination(hit.point);
            }
        }
    }
}
Labels:

Drawing Connected Straight Lines on a Surface Using Line Renderer


LineCreator.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using System.Linq;
using UnityEngine;
 
public class LineCreator : MonoBehaviour
{
    LineRenderer lineRenderer;
    RaycastHit hit;
 
    void Awake()
    {
        lineRenderer = gameObject.AddComponent<LineRenderer>();
        lineRenderer.startWidth = 0.1f;
        lineRenderer.material = Resources.FindObjectsOfTypeAll<Material>().SingleOrDefault(m => m.name == "Line");
        lineRenderer.positionCount = 0;
    }
 
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit))
            {
                AddLinePoints(hit.point + hit.normal.normalized * 0.1f);
            }
        }
 
        if (Input.GetMouseButtonDown(1))
        {
            ClearLinePoints();
        }
    }
 
    void AddLinePoints(Vector3 point)
    {
        lineRenderer.positionCount++;
        lineRenderer.SetPosition(lineRenderer.positionCount-1, point);
    }
 
    void ClearLinePoints()
    {
        lineRenderer.positionCount = 0;
    }
}
Labels:

Moving Player through Collection of Clicked Points on a Surface


ClickedPointsMovement.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class ClickedPointsMovement : MonoBehaviour
{
    public float speed = 15;
    Queue<Vector3> targetPointsQueue = new Queue<Vector3>();
    RaycastHit hit;
    Camera mainCam;
    Coroutine _MoveCR;
    int layerMask;
 
    void Awake()
    {
        mainCam = Camera.main;
        layerMask = LayerMask.GetMask("Ground");
    }
 
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (Physics.Raycast(mainCam.ScreenPointToRay(Input.mousePosition), out hit, 100, layerMask))
            {
                targetPointsQueue.Enqueue(hit.point);
                if (_MoveCR == null)
                {
                    _MoveCR = StartCoroutine(MoveThroughPoints(targetPointsQueue));
                }
            }
        }
    }
 
    IEnumerator MoveThroughPoints(Queue<Vector3> points)
    {
        while (points.Count > 0)
        {
            Vector3 targetPoint = points.Dequeue();
            targetPoint = new Vector3(targetPoint.x, transform.position.y, targetPoint.z);
            while (Vector3.Distance(transform.position, targetPoint) > 0.01f)
            {
                transform.position = Vector3.MoveTowards(transform.position, targetPoint, speed * Time.deltaTime);
                yield return null;
            }
        }
        _MoveCR = null;
    }
}
Labels:

Moving Player to a Point Clicked by the Mouse on a Surface


ClickedPointMovement.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System.Collections;
using UnityEngine;
 
public class ClickedPointMovement : MonoBehaviour
{
    public float speed = 30;
    RaycastHit hit;
    Camera mainCam;
    Coroutine _MoveCR;
    int layerMask;
 
    void Awake()
    {
        mainCam = Camera.main;
        layerMask = LayerMask.GetMask("Ground");
    }
 
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (Physics.Raycast(mainCam.ScreenPointToRay(Input.mousePosition), out hit, 100, layerMask))
            {
                if(_MoveCR != null)
                {
                    StopCoroutine(_MoveCR);
                }
                _MoveCR = StartCoroutine(MoveToPosition(hit.point));
            }
        }
    }
 
    IEnumerator MoveToPosition(Vector3 targetPoint)
    {
        targetPoint = new Vector3(targetPoint.x, transform.position.y, targetPoint.z);
        while (Vector3.Distance(transform.position, targetPoint) > 0.01f)
        {
            transform.position = Vector3.MoveTowards(transform.position, targetPoint, speed * Time.deltaTime);
            yield return null;
        }
    }
}
Labels:

Use of Raycast to detect an object in Unity


RaycastDetection.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using UnityEngine;
using UnityEngine.UI;
 
public class RaycastDetection : MonoBehaviour
{
    Ray ray;
    RaycastHit raycastHit;
    Text textUI;
 
    void Awake()
    {
        textUI = GameObject.FindObjectOfType<Text>();
    }
 
    void Update()
    {
        ray = new Ray(transform.position, transform.forward);
        if(Physics.Raycast(ray, out raycastHit))
        {
            textUI.text = raycastHit.collider.gameObject.name;
        }
        else
        {
            textUI.text = "";
        }
    }
}
Labels:

Updating player health using event in Unity



Player.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System;
using UnityEngine;
 
public class Player : MonoBehaviour
{
    public static event Action<int> _HealthUpdateEvent;
    int health = 100;
 
    public void GainHealth()
    {
        health = Mathf.Clamp(health + 10,0,100);
        if(_HealthUpdateEvent!=null)
        {
            _HealthUpdateEvent(health);
        }
    }
 
    public void LooseHealth()
    {
        health = Mathf.Clamp(health - 10, 0, 100);
        if (_HealthUpdateEvent != null)
        {
            _HealthUpdateEvent(health);
        }
    }
}

HealthDisplay.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using UnityEngine;
using UnityEngine.UI;
 
[RequireComponent(typeof(Text))]
public class HealthDisplay : MonoBehaviour
{
    Text healthValueText;
 
    void Awake()
    {
        healthValueText = GetComponent<Text>();
    }
 
    void OnEnable()
    {
        Player._HealthUpdateEvent += UpdateHealth;
    }
 
    void OnDisable()
    {
        Player._HealthUpdateEvent -= UpdateHealth;
    }
 
    void UpdateHealth(int value)
    {
        healthValueText.text = value.ToString("000") + " / 100";
    }
}
Labels:

Correct way to start and stop a Coroutine



CoroutineDemo.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System.Collections;
using UnityEngine;
 
public class CoroutineDemo : MonoBehaviour
{
    IEnumerator coroutine;
 
    void Start()
    {
        Debug.Log(">>> Coroutine Started. <<<");
        coroutine = PintEvery1Sec();
        StartCoroutine(coroutine);
    }
 
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            if (coroutine != null)
            {
                StopCoroutine(coroutine);
                coroutine = null;
                Debug.Log(">>> Coroutine Stopped. <<<");
            }
        }
    }
 
    IEnumerator PintEvery1Sec()
    {
        int i = 0;
        while (true)
        {
            i++;
            Debug.Log(i);
            yield return new WaitForSeconds(1);
        }
    }
}
Labels:

A simple timer using Coroutine



SimpleTimer.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using System.Collections;
using UnityEngine;
using UnityEngine.UI;
 
public class SimpleTimer : MonoBehaviour
{
    public Text timerTxt;
    public Button startTimerBtn;
    public Button stopTimerBtn;
    IEnumerator _timerCR;
 
    void Awake()
    {
        startTimerBtn.onClick.AddListener(StartTimerClick);
        stopTimerBtn.onClick.AddListener(StopTimerClick);
        ResetTimer();
    }
 
    #region button clicks
    void StartTimerClick()
    {
        _timerCR = StartTimer();
        StartCoroutine(_timerCR);
    }
 
    void StopTimerClick()
    {
        if(_timerCR!=null)
        {
            StopCoroutine(_timerCR);
            _timerCR = null;
        }
        ResetTimer();
    }
    #endregion
 
    #region start/reset timer
    IEnumerator StartTimer(int timeRemaining = 10)
    {
        startTimerBtn.interactable = false;
        stopTimerBtn.interactable = true;
        for (int i = timeRemaining; i > 0; i--)
        {
            timerTxt.text = i.ToString("00");
            yield return new WaitForSeconds(1);
        }
        ResetTimer();
    }
 
    void ResetTimer()
    {
        startTimerBtn.interactable = true;
        stopTimerBtn.interactable = false;
        timerTxt.text = "00";
    }
    #endregion
}
Labels:

Player movement using character controller based on front facing direction

PlayerMovement.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using UnityEngine;
 
public class PlayerMovement : MonoBehaviour
{
    CharacterController characterController;
 
    public float speed = 5;
    public float turnSpeed = 90;
 
    void Awake()
    {
        characterController = GetComponent<CharacterController>();
    }
 
    void Update()
    {
        characterController.Move(transform.forward * Input.GetAxis("Vertical") * speed * Time.deltaTime);
        transform.Rotate(Vector3.up, Input.GetAxis("Horizontal") * turnSpeed * Time.deltaTime);
    }
}
Labels:

Player simple movement based on input direction

PlayerSimpleMovement.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using UnityEngine;
 
public class PlayerSimpleMovement : MonoBehaviour
{
    float h = 0;
    float v = 0;
    public float speed = 5;
 
    void Update()
    {
        h = Input.GetAxis("Horizontal");
        v = Input.GetAxis("Vertical");
 
        transform.position += new Vector3(h * Time.deltaTime * speed, 0, v * Time.deltaTime * speed);
    }
}
Labels:

Control your camera to look around using mouse


MouseLookAround.cs
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using UnityEngine;
 
public class MouseLookAround : MonoBehaviour
{
    float rotationX = 0f;
    float rotationY = 0f;
 
    public float sensitivity = 15f;
 
    void Update()
    {
        rotationY += Input.GetAxis("Mouse X") * sensitivity;
        rotationX += Input.GetAxis("Mouse Y") * -1 * sensitivity;
        transform.localEulerAngles = new Vector3(rotationX,rotationY,0);
    }
}
Improved Script(Smooth Rotation & Sensitivity Axis Control)
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using UnityEngine;
 
public class MouseLookAround : MonoBehaviour
{
    float rotationX = 0f;
    float rotationY = 0f;
 
    public Vector2 sensitivity = Vector2.one * 360f;
 
    void Update()
    {
        rotationY += Input.GetAxis("Mouse X") * Time.deltaTime * sensitivity.x;
        rotationX += Input.GetAxis("Mouse Y") * Time.deltaTime * -1 * sensitivity.y;
        transform.localEulerAngles = new Vector3(rotationX, rotationY, 0);
    }
}
Labels:
Subscribe to: Posts (Atom)