------------------------------
Βασικός Κώδικας Unity C#

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BasicScript : MonoBehaviour
{
    // Εκτελείται όταν ξεκινά το παιχνίδι
    void Start()
    {
        
    }

    // Εκτελείται κάθε frame
    void Update()
    {
        
    }
}
------------------------------
Εξήγηση του Βασικού Κώδικα
Ο κώδικας έχει δύο βασικές μεθόδους:

void Start()
Εκτελείται μία φορά όταν ξεκινά το παιχνίδι.
Χρησιμοποιείται για αρχικοποίηση μεταβλητών ή για να ορίσουμε αρχικές καταστάσεις του αντικειμένου.

void Update()
Εκτελείται κάθε frame, δηλαδή συνέχεια.
Χρησιμοποιείται για την κίνηση, την περιστροφή και γενικά την αλλαγή του αντικειμένου κατά τη διάρκεια του παιχνιδιού.

Το MonoBehaviour είναι η βασική κλάση από την οποία κληρονομούν όλα τα scripts στο Unity.
Ουσιαστικά, αν γράψεις ένα script χωρίς MonoBehaviour, δεν θα μπορεί να προστεθεί σε GameObject.

Τι κάνει το MonoBehaviour;
Το MonoBehaviour δίνει στο script τη δυνατότητα να χρησιμοποιήσει βασικές συμπεριφορές του Unity, όπως:
Start() και Update()
FixedUpdate() και LateUpdate()
OnCollisionEnter2D(), OnTriggerEnter2D()
Destroy(gameObject), Instantiate(object)
Debug.Log()
Χωρίς MonoBehaviour, αυτά δεν δουλεύουν!

Τι είναι το frame;
Ένα frame είναι ένα καρέ εικόνας που σχεδιάζεται στην οθόνη.
Αν ένα παιχνίδι τρέχει στα 60 FPS (Frames Per Second), σημαίνει ότι σχεδιάζει 60 εικόνες το δευτερόλεπτο.
Αν τρέχει στα 30 FPS, σημαίνει 30 εικόνες το δευτερόλεπτο.

------------------------------
------------------------------
1. Μετακίνηση σε συγκεκριμένη θέση στην εκκίνηση (Start)

    void Start()
    {
        transform.position = new Vector3(2, 3, 0); // Μετακινείται στη θέση (2,3,0)
    }

------------------------------
------------------------------
2. Περιστροφή σε συγκεκριμένη γωνία στην εκκίνηση (Start)

    void Start()
    {
        transform.rotation = Quaternion.Euler(0, 0, 45); // Στρέφεται στις 45 μοίρες
    }

------------------------------
------------------------------
3. Αλλαγή μεγέθους στην εκκίνηση (Start)

    void Start()
    {
        transform.localScale = new Vector3(2, 2, 1); // Διπλασιάζει το μέγεθος
    }

------------------------------
------------------------------
4. Κίνηση προς τα δεξιά συνεχώς (Update)

    void Update()
    {
        transform.position += new Vector3(0.05f, 0, 0);
    }

------------------------------
------------------------------
5. Κίνηση προς τα πάνω συνεχώς (Update)

    void Update()
    {
        transform.position += new Vector3(0, 0.05f, 0);
    }
------------------------------
------------------------------
6. Περιστροφή συνεχώς (Update)

    void Update()
    {
        transform.Rotate(0, 0, 1);
    }
------------------------------
------------------------------
7. Συνεχής μείωση μεγέθους (Update)

    void Update()
    {
        transform.localScale -= new Vector3(0.01f, 0.01f, 0);
    }

------------------------------
------------------------------
8. Συνεχής αύξηση μεγέθους (Update)

    void Update()
    {
        transform.localScale += new Vector3(0.01f, 0.01f, 0);
    }
------------------------------
------------------------------
9. Αύξηση μεγέθους μέχρι τα όρια της οθόνης (μέχρι το πενταπλάσιο του αντικειμένου)

    void Update()
    {
        if (transform.localScale.x < 5)
        {
            transform.localScale += new Vector3(0.01f, 0.01f, 0);
        }
    }

------------------------------
------------------------------
10. Αύξηση και μετά μείωση μεγέθους

    private bool growing = true;

    void Update()
    {
        if (growing)
            transform.localScale += new Vector3(0.01f, 0.01f, 0);
        else
            transform.localScale -= new Vector3(0.01f, 0.01f, 0);

        if (transform.localScale.x > 5) growing = false;
        if (transform.localScale.x < 1) growing = true;
    }

------------------------------
------------------------------
11. Μείωση μεγέθους μέχρι ένα μικρό όριο και σταματά

    void Update()
    {
        if (transform.localScale.x > 0.1)
        {
            transform.localScale -= new Vector3(0.01f, 0.01f, 0);
        }
    }

------------------------------
------------------------------
12. Μείωση και μετά αύξηση μεγέθους

    private bool shrinking = true;

    void Update()
    {
        if (shrinking)
            transform.localScale -= new Vector3(0.01f, 0.01f, 0);
        else
            transform.localScale += new Vector3(0.01f, 0.01f, 0);

        if (transform.localScale.x < 1) shrinking = false;
        if (transform.localScale.x > 5) shrinking = true;
    }
------------------------------
------------------------------
13. Να αλλάζει το χρώμα σε πράσινο κατά την εκκίνηση (Start)


    void Start()
    {
        GetComponent<SpriteRenderer>().color = new Color(Random.value, Random.value, Random.value);
    }

13.1. Χρήση της έτοιμης τιμής Color.green

void Start()
{
    GetComponent<SpriteRenderer>().color = Color.green;
}

13.2. Χρήση του new Color(r, g, b) με RGB τιμές
Το Color.green αντιστοιχεί στο (0,1,0) στο RGB.

void Start()
{
    GetComponent<SpriteRenderer>().color = new Color(0, 1, 0);
}

13.3. Χρήση του new Color(r, g, b, a) με άλφα (διαφάνεια)
Το 1 στο τέλος είναι η διαφάνεια (1 = πλήρης αδιαφάνεια).

void Start()
{
    GetComponent<SpriteRenderer>().color = new Color(0, 1, 0, 1);
}

13.4. Χρήση Color.HSVToRGB(h, s, v)
Το 0.33f αντιστοιχεί στο πράσινο στο μοντέλο HSV

Color.HSVToRGB(h, s, v)
Αυτή η μέθοδος μετατρέπει ένα χρώμα από το HSV (Hue, Saturation, Value) χρωματικό μοντέλο στο RGB (Red, Green, Blue) μοντέλο που χρησιμοποιεί το Unity.
Παράμετροι:
h (float) → Απόχρωση (Hue), κυμαίνεται από 0 έως 1.
s (float) → Κορεσμός (Saturation), κυμαίνεται από 0 έως 1.
v (float) → Φωτεινότητα (Value), κυμαίνεται από 0 έως 1.


void Start()
{
    GetComponent<SpriteRenderer>().color = Color.HSVToRGB(0.33f, 1f, 1f);
}

13.5. Χρήση Material με πράσινο χρώμα

void Start()
{
    GetComponent<Renderer>().material.color = Color.green;
}

------------------------------
------------------------------
14. Να αλλάζει το χρώμα συνεχώς (Update)

    void Update()
    {
        GetComponent<SpriteRenderer>().color = new Color(Random.value, Random.value, Random.value);
    }
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
Μάθαμε πως αλλάζουμε τις μεταβλητές.
Τώρα θα δούμε πως θα τις αλλάζουμε με ρυθμιζόμενη ταχύτητα:


1. Κίνηση προς τα δεξιά με ταχύτητα ρυθμιζόμενη μέσω μεταβλητής
Το Time.deltaTime είναι ο χρόνος που πέρασε από το τελευταίο frame και βοηθάει να διατηρηθεί η ταχύτητα σταθερή σε όλες τις συσκευές.

    public float speed = 1f; // Ταχύτητα, ρυθμιζόμενη από το Unity Inspector

    void Update()
    {
        transform.position += new Vector3(speed * Time.deltaTime, 0, 0);
    }

2. Κίνηση προς τα πάνω με ταχύτητα ρυθμιζόμενη μέσω μεταβλητής

    public float speed = 1f;

    void Update()
    {
        transform.position += new Vector3(0, speed * Time.deltaTime, 0);
    }

3. Περιστροφή με ταχύτητα ρυθμιζόμενη μέσω μεταβλητής

    public float speed = 50f; // Μοίρες ανά δευτερόλεπτο

    void Update()
    {
        transform.Rotate(0, 0, speed * Time.deltaTime);
    }


4. Μείωση μεγέθους με ταχύτητα ρυθμιζόμενη μέσω μεταβλητής

    public float speed = 1f;

    void Update()
    {
        transform.localScale -= new Vector3(speed * Time.deltaTime, speed * Time.deltaTime, 0);
    }

5. Αύξηση μεγέθους με ταχύτητα ρυθμιζόμενη μέσω μεταβλητής

    public float speed = 1f;

    void Update()
    {
        transform.localScale += new Vector3(speed * Time.deltaTime, speed * Time.deltaTime, 0);
    }

6. Εναλλαγή χρώματος με ταχύτητα ρυθμιζόμενη μέσω μεταβλητής

    public float speed = 1f;
    private bool isGreen = true;
    private float timer = 0f;

    void Update()
    {
        timer += Time.deltaTime;
        if (timer > speed)
        {
            timer = 0f;
            isGreen = !isGreen;
            GetComponent<SpriteRenderer>().color = isGreen ? Color.green : Color.red;
        }
    }

7. Κίνηση αντικειμένου υπό γωνία στα όρια της οθόνης

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BouncingObject : MonoBehaviour
{
    public float speed = 5f; // Ταχύτητα κίνησης
    private Vector2 direction;

    void Start()
    {
        // Ξεκινά με γωνία 45 μοιρών
        direction = new Vector2(1, 1).normalized;
        transform.rotation = Quaternion.Euler(0, 0, 45);
    }

    void Update()
    {
        // Μετακίνηση συνεχώς μπροστά
        transform.position += (Vector3)(direction * speed * Time.deltaTime);

        // Ανίχνευση των ορίων της οθόνης και αντανάκλαση
        CheckScreenBounds();
    }

    void CheckScreenBounds()
    {
        Vector2 screenPosition = Camera.main.WorldToViewportPoint(transform.position);

        if (screenPosition.x <= 0 || screenPosition.x >= 1)
        {
            direction.x = -direction.x; // Αντανάκλαση στον άξονα X
        }
        if (screenPosition.y <= 0 || screenPosition.y >= 1)
        {
            direction.y = -direction.y; // Αντανάκλαση στον άξονα Y
        }
    }
}

------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
Μάθαμε πως αλλάζουμε τις μεταβλητές.
Μάθαμε πως τις αλλάζουμε με ρυθμιζόμενη ταχύτητα.
Τώρα θα μάθουμε πως τις αλλάζουμε με keyboard events:

1. Όταν πατηθεί το space

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        transform.position += new Vector3(0.1f, 0, 0);
    }
}

2. Όταν πατηθεί ένα από τα πλήκτρα A, B, C

void Update()
{
    if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.B) || Input.GetKeyDown(KeyCode.C))
    {
        transform.position += new Vector3(0.1f, 0, 0);
    }
}

3. Όταν πατηθεί στο πληκτρολόγιο βελάκι προς τα δεξιά

void Update()
{
    if (Input.GetKeyDown(KeyCode.RightArrow))
    {
        transform.position += new Vector3(0.1f, 0, 0);
    }
}

4. Όταν είναι (σταθερά) πατημένο στο πληκτρολόγιο βελάκι προς τα δεξιά

void Update()
{
    if (Input.GetKey(KeyCode.RightArrow))
    {
        transform.position += new Vector3(0.1f, 0, 0);
    }
}


5. Άσκηση: Να κινείται πάνω κάτω δεξιά κι αριστερά με τα arrow keys:

if (Input.GetKey(KeyCode.RightArrow)) // Δεξιά
{
    transform.position += new Vector3(0.1f, 0, 0);
}

if (Input.GetKey(KeyCode.LeftArrow)) // Αριστερά
{
    transform.position += new Vector3(-0.1f, 0, 0);
}

if (Input.GetKey(KeyCode.UpArrow)) // Πάνω
{
    transform.position += new Vector3(0, 0.1f, 0);
}

if (Input.GetKey(KeyCode.DownArrow)) // Κάτω
{
    transform.position += new Vector3(0, -0.1f, 0);
}


6. Άσκηση: Να κινείται πάνω κάτω δεξιά κι αριστερά και να αυξάνει / μειώνει ταχύτητα μέσω πλήκτρων

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class NewBehaviourScript : MonoBehaviour
{
    // Μεταβλητή ταχύτητας
    private float speed = 1f;

    // Start is called before the first frame update
    void Start()
    {
        Debug.Log("Starting Speed: " + speed);
    }

    // Update is called once per frame
    void Update()
    {
        // Μετακίνηση με τα A, B, C, D
        if (Input.GetKeyDown(KeyCode.A))
        {
            transform.position += new Vector3(-1f * speed, 0, 0);
        }
        if (Input.GetKeyDown(KeyCode.B))
        {
            transform.position += new Vector3(1f * speed, 0, 0);
        }
        if (Input.GetKeyDown(KeyCode.C))
        {
            transform.position += new Vector3(0, 1f * speed, 0);
        }
        if (Input.GetKeyDown(KeyCode.D))
        {
            transform.position += new Vector3(0, -1f * speed, 0);
        }

        // Διπλασιασμός ταχύτητας με το E
        if (Input.GetKeyDown(KeyCode.E))
        {
            speed *= 2f;
            Debug.Log("Speed increased to: " + speed);
        }

        // Υποδιπλασιασμός ταχύτητας με το F
        if (Input.GetKeyDown(KeyCode.F))
        {
            speed /= 2f;
            Debug.Log("Speed decreased to: " + speed);
        }
    }



}


------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
Μάθαμε πως αλλάζουμε τις μεταβλητές.
Μάθαμε πως τις αλλάζουμε με ρυθμιζόμενη ταχύτητα.
Μάθαμε πως τις αλλάζουμε με keyboard events.
Τώρα θα χρησιμοποιήσουμε mouse events:

Χρειαζόμαστε:
α. Collider (Σύστημα Ανίχνευσης Σύγκρουσης)
β. Rigidbody (Σύστημα Φυσικής)

ΕΙΚΟΝΑ: 1.jpg

Το Collider είναι ένα αόρατο περίγραμμα που καθορίζει το σχήμα του αντικειμένου για να μπορεί να ανιχνεύει συγκρούσεις.
Τι κάνει;
Επιτρέπει στα αντικείμενα να ανιχνεύουν και να αντιδρούν σε συγκρούσεις.
Χωρίς Collider, το αντικείμενο δεν μπορεί να ανιχνεύσει σύγκρουση ακόμα και αν έχει Rigidbody2D.
Χρησιμοποιείται για το OnCollisionEnter2D και το OnTriggerEnter2D.

Το Rigidbody2D είναι το σύστημα φυσικής που επιτρέπει στα αντικείμενα να επηρεάζονται από δυνάμεις, βαρύτητα και συγκρούσεις.
Τι κάνει;
Χρησιμοποιείται για να επιτρέπει φυσική κίνηση και συγκρούσεις.
Δίνει στο αντικείμενο ιδιότητες όπως μάζα, βαρύτητα, αντίσταση, ταχύτητα.
Απαιτεί Collider2D για να ανιχνεύει συγκρούσεις.


1. Ανίχνευση Κλικ (OnMouseDown)

void OnMouseDown()
{
    Debug.Log("Έγινε κλι στο αντικείμενο!");
}


2. Ανίχνευση Διπλού Κλικ (OnMouseDown με Timer)

private float lastClickTime = 0f;
private float doubleClickThreshold = 0.3f;

void OnMouseDown()
{
    if (Time.time - lastClickTime < doubleClickThreshold)
    {
        Debug.Log("Διπλό κλικ!");
    }
    lastClickTime = Time.time;
}

3. Ανίχνευση Hover (OnMouseOver)

void OnMouseOver()
{
    Debug.Log("Το ποντίκι είναι πάνω στο αντικείμενο!");
}

4. Ανίχνευση Mouse Out (OnMouseExit)

void OnMouseExit()
{
    Debug.Log("Το ποντίκι έφυγε από το αντικείμενο!");
}


5. Ανίχνευση Σύγκρουσης (OnCollisionEnter2D)


5α. Αν έχει επιλεγεί Dynamic:
void OnCollisionEnter2D(Collision2D collision)
{
    Debug.Log("Το αντικείμενο συγκρούστηκε με: " + collision.gameObject.name);
}

5β. Αν έχει επιλεγεί Kinematic:
void OnTriggerEnter2D(Collider2D collision)
{
    Debug.Log("Το αντικείμενο πέρασε από: " + collision.gameObject.name);
}

6. Κίνηση με arrow keys και ανίχνευση σύγκρουσης:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BouncingObject : MonoBehaviour
{
    void OnTriggerEnter2D(Collider2D collision)
    {
        Debug.Log("Το αντικείμενο πέρασε από: " + collision.gameObject.name);
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            transform.position += new Vector3(0.1f, 0, 0);
        }
        if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            transform.position += new Vector3(-0.1f, 0, 0);
        }


    }
}

Σε αυτό το παράδειγμα χρησιμοποιούμε Kinematic και όχι Dynamic

Η κύρια διαφορά μεταξύ Kinematic και Dynamic στο Rigidbody2D της Unity αφορά τον τρόπο με τον οποίο η μηχανή φυσικής της Unity χειρίζεται τα αντικείμενα:

6α. Dynamic (Δυναμικό)
Επηρεάζεται από τη φυσική (βάρος, τριβή, δυνάμεις, βαρύτητα).
Συγκρούεται κανονικά με άλλα αντικείμενα.
Μπορεί να μετακινηθεί μέσω δυνάμεων (AddForce, velocity, MovePosition).

Χρησιμοποιεί τα συμβάντα:
OnCollisionEnter2D
OnCollisionStay2D
OnCollisionExit2D

Ιδανικό για:
Αντικείμενα που πρέπει να ακολουθούν τους κανόνες της φυσικής (π.χ. μια μπάλα, ένα κουτί που πέφτει).

6β. Kinematic (Κινηματικό)
Δεν επηρεάζεται από τη φυσική (ούτε από βαρύτητα, ούτε από δυνάμεις).
ΔΕΝ συγκρούεται με Dynamic αντικείμενα αν το μετακινήσεις με transform.position.
Μετακινείται μόνο μέσω transform.position ή Rigidbody2D.MovePosition().
Αν θέλετε να ανιχνεύσετε συγκρούσεις, πρέπει να χρησιμοποιείτε OnTriggerEnter2D και Is Trigger στο Collider.
Δεν δέχεται δυνάμεις (AddForce δεν λειτουργεί).
Δεν επηρεάζεται από άλλες συγκρούσεις (αν συγκρουστεί με Dynamic αντικείμενο, δεν το επηρεάζει).

Ιδανικό για:
Κινούμενες πλατφόρμες.
Ελεγχόμενους χαρακτήρες που δεν χρειάζονται φυσική (π.χ. ένα NPC που κινείται προγραμματισμένα).
Αντικείμενα που κινούνται με κώδικα και δεν πρέπει να δέχονται φυσική αλληλεπίδραση.

7. Παράδειγμα με :
Όταν γίνει κλικ, το αντικείμενο γίνεται μπλε
Αν γίνει διπλό κλικ, το αντικείμενο γίνεται κόκκινο
Όταν το ποντίκι μπει πάνω στο αντικείμενο, ξεκινά η περιστροφή
Όταν το ποντίκι φύγει, το αντικείμενο γίνεται πράσινο και σταματάει η περιστροφή


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ClickAndHoverEffects : MonoBehaviour
{
    private SpriteRenderer spriteRenderer;
    private float lastClickTime = 0f;
    private float doubleClickThreshold = 0.3f;
    private bool isRotating = false;

    void Start()
    {
        // Παίρνουμε το SpriteRenderer του αντικειμένου
        spriteRenderer = GetComponent<SpriteRenderer>();
    }

    void Update()
    {
        // Αν το αντικείμενο περιστρέφεται (Hover), το περιστρέφουμε συνεχώς
        if (isRotating)
        {
            transform.Rotate(0, 0, -100 * Time.deltaTime); // Περιστροφή δεξιόστροφα
        }
    }

    // Όταν γίνει κλικ, το αντικείμενο γίνεται μπλε
    void OnMouseDown()
    {
        if (Time.time - lastClickTime < doubleClickThreshold)
        {
            spriteRenderer.color = Color.red; // Αν γίνει διπλό κλικ, γίνεται κόκκινο
            Debug.Log("Διπλό κλικ! Χρώμα: Κόκκινο");
        }
        else
        {
            spriteRenderer.color = Color.blue; // Αν είναι απλό κλικ, γίνεται μπλε
            Debug.Log("Κλικ! Χρώμα: Μπλε");
        }

        lastClickTime = Time.time;
    }

    // Όταν το ποντίκι μπει πάνω στο αντικείμενο, ξεκινά η περιστροφή
    void OnMouseOver()
    {
        isRotating = true;
        Debug.Log("Mouse Over! Περιστροφή Δεξιά.");
    }

    // Όταν το ποντίκι φύγει, το αντικείμενο γίνεται πράσινο και σταματάει η περιστροφή
    void OnMouseExit()
    {
        spriteRenderer.color = Color.green;
        isRotating = false;
        Debug.Log("Mouse Out! Χρώμα: Πράσινο.");
    }
}


------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
------------------------------

ΠΑΡΑΔΕΙΓΜΑΤΑ:



Να κινείται υπό γωνία με αντανάκλαση
Δυο αντικείμενα να κινούνται υπό γωνία με αντανάκλαση (διαφορετική γωνία και διαφορετική ταχύτητα)
Να ανιχνεύει σύγκρουση
Να αλλάζει χρώμα στη σύγκρουση
Να υπάρχει counter που να θυμάται πλήθος συγκρούσεων

Απλό παιχνίδι (έχω παράδειγμα !!!!!)


