Struktury — małe wartości, które kopiujemy

struct Licznik
{
    public int Wartosc;

    public void Zwieksz()
    {
        Wartosc++;
    }
}

Licznik a = new Licznik();
a.Zwieksz();
a.Zwieksz();
Console.WriteLine(a.Wartosc);       // 2

Licznik[] tab = new Licznik[1];
tab[0].Zwieksz();
tab[0].Zwieksz();
Console.WriteLine(tab[0].Wartosc);  // 2

List<Licznik> lista = new List<Licznik> { new Licznik() };
lista[0].Zwieksz();
lista[0].Zwieksz();
Console.WriteLine(lista[0].Wartosc);   // 0  ???

// lista[0].Wartosc = 5;        // BLAD CS1612 - nie mozna zmieniac wyniku metody

Pozycja a = new Pozycja(2, 3);
Pozycja b = a;
b.Rzad = 9;

Console.WriteLine($"a = {a}, b = {b}");

struct Pozycja                      // STRUKTURA
{
    public int Rzad;
    public int Kolumna;

    public Pozycja(int rzad, int kolumna) { Rzad = rzad; Kolumna = kolumna; }

    public override string ToString() { return $"({Rzad},{Kolumna})"; }
}

Pozycja a = new Pozycja(2, 3);
Pozycja b = a;
b.Rzad = 9;

Console.WriteLine($"a = {a}, b = {b}");

class Pozycja                       // KLASA - jedyna zmiana
{
    public int Rzad;
    public int Kolumna;

    public Pozycja(int rzad, int kolumna) { Rzad = rzad; Kolumna = kolumna; }

    public override string ToString() { return $"({Rzad},{Kolumna})"; }
}

Pozycja a = new Pozycja(2, 3);
Pozycja b = a;                 // kopia

static void Bez(Pozycja p)
{
    p.Rzad = 100;              // zmienia kopie
}

static void Z(ref Pozycja p)
{
    p.Rzad = 100;              // zmienia zmienna wywolujacego
}

Pozycja x = new Pozycja(1, 1);

Bez(x);
Console.WriteLine(x);          // (1,1)

Z(ref x);
Console.WriteLine(x);          // (100,1)

class Gracz
{
    public Pozycja Pozycja { get; private set; }

    public Gracz(Pozycja p) { Pozycja = p; }
}

Gracz g = new Gracz(new Pozycja(0, 0));

// g.Pozycja.Rzad = 5;         // BLAD CS1612 - wynik wlasciwosci to kopia

Pozycja p = g.Pozycja;         // trzeba wziac kopie...
p.Rzad = 5;                    // ...zmienic ja...
Console.WriteLine(g.Pozycja);  // (0,0) - a obiekt gracza sie nie zmienil

Pozycja[] tab = new Pozycja[3];
tab[0].Rzad = 7;               // WOLNO - dostep bezposredni do elementu
Console.WriteLine(tab[0]);     // (7,0)

List<Pozycja> lista = new List<Pozycja> { new Pozycja(0, 0) };

// lista[0].Rzad = 7;          // BLAD CS1612

Pozycja tmp = lista[0];        // poprawny sposob:
tmp.Rzad = 7;                  // 1. wez kopie, 2. zmien ja,
lista[0] = tmp;                // 3. wstaw z powrotem
Console.WriteLine(lista[0]);   // (7,0)

Pozycja p = new Pozycja(1, 2);
object o = p;                  // kopia trafia na sterte ("pakowanie")
Pozycja q = (Pozycja)o;        // i jest z powrotem kopiowana

struct Pozycja
{
    public int Rzad { get; }        // bez set
    public int Kolumna { get; }

    public Pozycja(int rzad, int kolumna)
    {
        Rzad = rzad;
        Kolumna = kolumna;
    }

    public override string ToString() { return $"({Rzad},{Kolumna})"; }
}

    public Pozycja Przesun(int oRzad, int oKolumne)
    {
        return new Pozycja(Rzad + oRzad, Kolumna + oKolumne);
    }

Pozycja p = new Pozycja(2, 3);
p = p.Przesun(1, 0);           // przypisanie wyniku jest konieczne
Console.WriteLine(p);          // (3,3)

Pozycja q = new Pozycja(2, 3);
q.Przesun(1, 0);               // wynik wyrzucony - ostrzezenie i zero skutku
Console.WriteLine(q);          // (2,3)

readonly struct Pozycja
{
    public int Rzad { get; }
    public int Kolumna { get; }

    public Pozycja(int rzad, int kolumna)
    {
        Rzad = rzad;
        Kolumna = kolumna;
    }

    // public void Przesun() { Rzad++; }      // BLAD CS1604 - nie wolno zmieniac pola

    public Pozycja Przesun(int oRzad, int oKolumne)
    {
        return new Pozycja(Rzad + oRzad, Kolumna + oKolumne);
    }

    public override string ToString() { return $"({Rzad},{Kolumna})"; }
}

readonly record struct Pozycja(int Rzad, int Kolumna);

Pozycja a = new Pozycja(2, 3);
Pozycja b = new Pozycja(2, 3);

Console.WriteLine(a);              // Pozycja { Rzad = 2, Kolumna = 3 }
Console.WriteLine(a == b);         // True - operator dostales za darmo
Console.WriteLine(a.Equals(b));    // True

Pozycja c = a with { Rzad = 9 };   // kopia z jedna zmieniona wartoscia
Console.WriteLine(c);              // Pozycja { Rzad = 9, Kolumna = 3 }

struct PozycjaS { public int R; public int K; }
class  PozycjaK { public int R; public int K; }

PozycjaS s1 = new PozycjaS { R = 1, K = 1 };
PozycjaS s2 = new PozycjaS { R = 1, K = 1 };
Console.WriteLine(s1.Equals(s2));      // True  - porownanie PO POLACH
// Console.WriteLine(s1 == s2);        // BLAD CS0019 - operatora nie ma

PozycjaK k1 = new PozycjaK { R = 1, K = 1 };
PozycjaK k2 = new PozycjaK { R = 1, K = 1 };
Console.WriteLine(k1.Equals(k2));      // False - porownanie PO ADRESIE
Console.WriteLine(k1 == k2);           // False - to samo
Console.WriteLine(k1 == k1);           // True  - ten sam obiekt

readonly struct Pozycja
{
    public int Rzad { get; }
    public int Kolumna { get; }

    public Pozycja(int rzad, int kolumna) { Rzad = rzad; Kolumna = kolumna; }

    public static bool operator ==(Pozycja a, Pozycja b)
    {
        return a.Rzad == b.Rzad && a.Kolumna == b.Kolumna;
    }

    public static bool operator !=(Pozycja a, Pozycja b)
    {
        return !(a == b);
    }

    public override bool Equals(object? obj)
    {
        return obj is Pozycja p && this == p;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Rzad, Kolumna);
    }
}

// Program.cs - pelny plik
Console.WriteLine("=== 1. przypisanie: struktura kontra klasa ===");
Pozycja p1 = new Pozycja(2, 3);
Pozycja p2 = p1;
p2 = p2.Przesun(1, 0);
Console.WriteLine($"struct:  p1 = {p1}, p2 = {p2}");

Znacznik z1 = new Znacznik(2, 3);
Znacznik z2 = z1;
z2.Rzad = 9;
Console.WriteLine($"class:   z1 = {z1}, z2 = {z2}");

Console.WriteLine();
Console.WriteLine("=== 2. przekazanie do metody ===");
Pozycja p3 = new Pozycja(5, 5);
SprobujZmienic(p3);
Console.WriteLine($"bez ref: {p3}");
ZmienNaPewno(ref p3);
Console.WriteLine($"z ref:   {p3}");

Console.WriteLine();
Console.WriteLine("=== 3. rownosc ===");
Pozycja a = new Pozycja(1, 1);
Pozycja b = new Pozycja(1, 1);
Console.WriteLine($"struct a.Equals(b) = {a.Equals(b)}");

Znacznik m = new Znacznik(1, 1);
Znacznik n = new Znacznik(1, 1);
Console.WriteLine($"class  m.Equals(n) = {m.Equals(n)}");
Console.WriteLine($"class  m == n      = {m == n}");
Console.WriteLine($"class  m == m      = {m == m}");

Console.WriteLine();
Console.WriteLine("=== 4. tablica kontra lista ===");
Pozycja[] tab = { new Pozycja(0, 0), new Pozycja(1, 1) };
tab[0] = tab[0].Przesun(3, 3);
Console.WriteLine($"tab[0] = {tab[0]}");

List<Pozycja> lista = new List<Pozycja> { new Pozycja(0, 0) };
Pozycja tmp = lista[0];
tmp = tmp.Przesun(7, 7);
lista[0] = tmp;
Console.WriteLine($"lista[0] = {lista[0]}");

Console.WriteLine();
Console.WriteLine("=== 5. plansza z pionkami ===");
Plansza plansza = new Plansza(4);
plansza.Ustaw(new Pozycja(0, 0), 'K');
plansza.Ustaw(new Pozycja(1, 2), 'p');
plansza.Ustaw(new Pozycja(3, 3), 'W');
plansza.Ustaw(new Pozycja(7, 7), 'X');
plansza.Rysuj();

Console.WriteLine($"na (1,2) stoi: {plansza.Co(new Pozycja(1, 2))}");
Console.WriteLine($"na (2,2) stoi: {plansza.Co(new Pozycja(2, 2))}");

Console.WriteLine();
Console.WriteLine("=== 6. ruch pionka ===");
Pozycja pionek = new Pozycja(1, 2);
Console.WriteLine($"start: {pionek}");

Pozycja[] ruchy = { new Pozycja(1, 0), new Pozycja(0, 1), new Pozycja(1, 1) };
foreach (Pozycja r in ruchy)
{
    Pozycja nowa = pionek.Przesun(r.Rzad, r.Kolumna);
    if (plansza.Poprawna(nowa))
    {
        pionek = nowa;
        Console.WriteLine($"ruch {r} -> {pionek}");
    }
    else
    {
        Console.WriteLine($"ruch {r} -> odrzucony, {nowa} poza plansza");
    }
}

static void SprobujZmienic(Pozycja p)
{
    p = p.Przesun(100, 100);
}

static void ZmienNaPewno(ref Pozycja p)
{
    p = p.Przesun(100, 100);
}


readonly struct Pozycja
{
    public int Rzad { get; }
    public int Kolumna { get; }

    public Pozycja(int rzad, int kolumna)
    {
        Rzad = rzad;
        Kolumna = kolumna;
    }

    public Pozycja Przesun(int oRzad, int oKolumne)
    {
        return new Pozycja(Rzad + oRzad, Kolumna + oKolumne);
    }

    public override string ToString()
    {
        return $"({Rzad},{Kolumna})";
    }
}

class Znacznik
{
    public int Rzad { get; set; }
    public int Kolumna { get; set; }

    public Znacznik(int rzad, int kolumna)
    {
        Rzad = rzad;
        Kolumna = kolumna;
    }

    public override string ToString()
    {
        return $"({Rzad},{Kolumna})";
    }
}

class Plansza
{
    private readonly char[,] pola;

    public int Rozmiar { get; }

    public Plansza(int rozmiar)
    {
        Rozmiar = rozmiar;
        pola = new char[rozmiar, rozmiar];

        for (int r = 0; r < rozmiar; r++)
        {
            for (int k = 0; k < rozmiar; k++)
            {
                pola[r, k] = '.';
            }
        }
    }

    public bool Poprawna(Pozycja p)
    {
        return p.Rzad >= 0 && p.Rzad < Rozmiar
            && p.Kolumna >= 0 && p.Kolumna < Rozmiar;
    }

    public void Ustaw(Pozycja p, char znak)
    {
        if (!Poprawna(p))
        {
            Console.WriteLine($"pominieto {p} - poza plansza");
            return;
        }
        pola[p.Rzad, p.Kolumna] = znak;
    }

    public char Co(Pozycja p)
    {
        if (!Poprawna(p))
        {
            return ' ';
        }
        return pola[p.Rzad, p.Kolumna];
    }

    public void Rysuj()
    {
        for (int r = 0; r < Rozmiar; r++)
        {
            for (int k = 0; k < Rozmiar; k++)
            {
                Console.Write(pola[r, k]);
                Console.Write(' ');
            }
            Console.WriteLine();
        }
    }
}