Cześć.
Mam taką oto funkcję oparta na algorytmie Bresenhama.

[PHP] pobierz, plaintext 
function bresenham(Tile $tileStart, Tile $tileEnd): Array
    {
 
        $x1 = $tileStart->row;
        $y1 = $tileStart->column;
 
        $x2 = $tileEnd->row;
        $y2 = $tileEnd->column;
 
        $xBegin = $x1;
        $yBegin = $y1;
        $xEnd = $x2;
        $yEnd = $y2;
        $dots = [];
        $dots[] = [$xBegin, $yBegin];
        $steep = abs($y2 - $y1) > abs($x2 - $x1);
 
        if ($steep) {
            $tmp = $x1;
            $x1 = $y1;
            $y1 = $tmp;
            $tmp = $x2;
            $x2 = $y2;
            $y2 = $tmp;
        }
 
        if ($x1 > $x2) {
            $tmp = $x1;
            $x1 = $x2;
            $x2 = $tmp;
            $tmp = $y1;
            $y1 = $y2;
            $y2 = $tmp;
        }
        $deltax = floor($x2 - $x1);
        $deltay = floor(abs($y2 - $y1));
        $error = 0;
        $deltaerr = $deltay / $deltax;
        $y = $y1;
        $ystep = ($y1 < $y2) ? 1 : -1;
 
        for ($x = $x1; $x < $x2; $x++) {
            $dots[] = $steep ? [$y, $x] : [$x, $y];
            $error += $deltaerr;
            if ($error >= 0.5) {
                $y += $ystep;
                $error -= 1;
            }
        }
        $dots[] = [$xEnd, $yEnd];
 
        return $dots;
    }
[PHP] pobierz, plaintext 

Kod służy do wyznaczania trasy a właściwie do rysowania linii między punktem A a punktem B na układzie współrzędnych.

Jednak nie działa tak jakbym chciał.
Od wskazanego punktu w PRAWO, PRAWA GÓRA, PRAWY DÓŁ odpowiednio pokazuje przejścia przez punkty w układzie współrzędnych.

Ale jeśli wykonuję rysowanie "do tyłu" to pokazuje mi odpowiednie punkty- ale zawsze rosnąco-- co przy rysowaniu w LEWO, LEWO GÓRA i LEWO DÓŁ powinno być na odwrót.
Jak zmodyfikować kod aby pokazywał mi odpowiednie pola?

Już daję przykłady:

Startuję z punktu [34,62]. 3 pól w prawo.
System pokazuje mi poszczególne kroki: route=[[34,62],[34,63],[34,64],[34,65]] i to jest git

Ale jeśli z tego samego punktu chcę rysować linię w lewo to system pokazuje mi punkty: route=[[34,59],[34,60],[34,61],[34,62]]

I same pola są oki- ale jak zmodyfikować kod aby pokazywał mi pola w kolejności malejącej jeśli rysuję w LEWO, LEWO GÓRA, LEWO DÓŁ? route=[[34,62],[34,61],[34,60],[34,59]]


Oto jest pytanie!

Odwrócić tablicę?

Ale czy na pewno to jest kwestia pokazanego kodu? Z tego co widzę, jako pierwszy do tablicy wpada właśnie punkt początkowy.

No tak, i ostatni też wpada właściwie.
Ale te wewnątrz już są uporządkowane rosnąco ( co jest super w ruchu w PRAWO )- ale w LEWO już niekoniecznie

Odwrócić tablicę nie ma problemu- ale skąd system ma wiedzieć kiedy ma odwrócić tablicę a kiedy ma pokazać prawidłową ścieżkę ?

Tego nie potrafię mu przekazać

Nie widzę, aby pierwszy i ostatni wpadały właściwie.
Startujesz z [34,62] w lewo o 3 punkty i ten jest ostatni w tablicy, a pierwszy w tablicy jest ostatnim punktem ścieżki.
Wszystkie punkty są w odwrotnej kolejności.

Albo przed wyliczaniem zamień współrzędne, jeśli Y1>Y2.
Albo odwróć kolejność tablicy, jeśli punkt początkowy nie jest pierwszym elementem w tablicy.

Przy tworzeniu tablicy bez algorytmu wrzucam pierwszy krok (

[PHP] pobierz, plaintext 
$dots[] = [$xBegin, $yBegin];
[PHP] pobierz, plaintext 

) i ostatni krok (

[PHP] pobierz, plaintext 
$dots[] = [$xEnd, $yEnd];
[PHP] pobierz, plaintext 

)

Przez to mogą być "nie po kolei".
Jeśli nie dodam tych punktów "ręcznie" to otrzymuję tylko pola pośrednie - co też nie jest złym rozwiązaniem bo dwa pola mogę domyślnie wstawić i też będzie.
Problem jednak jest z tym odwracaniem.



Oki, ale Y'ki mogą być malejące a X'ksy rosnące

Hm.
Nie zrozumiałem co do mnie napisałeś

Z tego co widzę, to przy podaniu punktu startowego: 34,62 a końcowego: 34,59, wynikiem jest:

34,62
34,59
34,60
34,61
34,59

a nie to co podałeś w pierwszym poście:
34,59
34,60
34,61
34,62

W zależności od wartości Y1 i Y2 wystarczy wstawić koniec punkt początkowy, albo końcowy.
Nie unikniesz tego, że X1 może być większe od X2 - przecież linia może znaleźć się w każdej ćwiartce układu współrzędnych, a nie tylko w pierwszej, więc nie zawsze X1<X2 i jednocześnie Y1<Y2.

No tak, pytanie dlaczego się zdublowały dwa elementy 34,59?

trochę to zagmatwane, ze studiów pamiętam, że algorytm Bresenhama jest trochę inny (chyba, że masz to zrobić po swojemu), ale jak Ci się przyda to masz:


oczywiście to wszystko na szybkości, tablica jest na sztywno, kod jaki jest każdy widzi ale na szybkości i przerobić to tak jak potrzebujesz to pikuś.

edit: ten kod jest dla warunków kiedy odcinek (x1,y1)-(x2,y2) tworzył z osią OX kąt w przedziale od 0 do 45° inne przypadki da się zrobić przez transformacje współrzędnych, ale musisz poczytać, bo dzisiaj nie mam głowy do tego

Generalnie to próbuję ustalić ścieżkę od punktu A do punktu B na układzie współrzędnych.


Mam układ z rozpisanymi wierszami,
Wierszy jest 11, kolumn 25.

I ta takim schemacie chcę ustalić jakie koordynaty znajdują się między polem np. [34,20] a [38,20].

No i dobrze. I to opiera się na algorytmie Bresenhama.

A jakie to ma znaczenie ile jest kolumn a ile wierszy? To dalej traktujemy jak układ współrzędnych.

Nie dodawaj do tablicy punktów początkowych i końcowych, wyświetl wynik i dowiesz się.

Tak, doszedłem do tego.
Ale jeśli nie dodam ich- to albo są- albo ich nie ma i nie wiem dlaczego

Jak dam linie w PRAWO to jest punkt początkowy i końcowy, ale w lewo jest już tylko końcowy ( bez początkowego ), jak dam w lewo dół to nie ma ani początkowego, ani końcowego...
Coś ten algorytm nie działa ( mówię o kodzie który wkleiłem, bo algorytm Breshenhama na pewno działa:) )

Dla: 30,32 i 10,5, czyli lewo-dół, w tablicy jest punkt [10,5];

Oki, to zrób symulację [34,62] do [36,60] , u mnie jest startowy ale końcowego nie ma ;/
wynik = [34,62],[35,61]


Jak zrobisz [34,62] do [36,59] to nie ma startowego
wynik = [36,59],[35,60],[35,61]


Jak zrobisz [34,62] do [32,60] to nie ma startowego.
wynik = [32,60],[33,61] i w tym przypadku chciałbym aby tablice były [33,61],[32,60]

Przez to planowąłem dodać ręcznie startowy i końcowy, a gdyby on się zdublował to przez funkcję multi_unique

[PHP] pobierz, plaintext 
public function multi_unique($array): Array
    {
        foreach ($array as $k=>$na)
        $new[$k] = serialize($na);
        $uniq = array_unique($new);
        foreach($uniq as $k=>$ser)
            $new1[$k] = unserialize($ser);
        return ($new1);
    }
 
[PHP] pobierz, plaintext 

usuwam duplikaty.

I to mw. spełnia moje wymagania- poza faktem że tablice chciałbym odwrócone przy y2 > y1 ale nie wiem jak to zaprogramować ;/

Przed napisaniem postu wykonałem sporą ilości testów, może jeden czy da trafią się prawidłowe- ale przyznasz że to nie tak powinno działać?
Stąd mój post tutaj

A ja się odnoszę do tego:

Co nie jest prawdą, zresztą powyżej to potwierdziłeś - albo brak początkowego, albo końcowego.

Problem tkwi w tym, że wstawiasz współrzędne dostarczone na początku algorytmu, pomimo, że algorytm może zamieniać współrzędne początkowe i końcowe.
Wystarczy dodać na końcu:

[PHP] pobierz, plaintext 
$dots[] = [$x2, $y2];
[PHP] pobierz, plaintext 

Nie rozumiemy się

Start [34,62]
Meta [34,58]

Wynik: [34,58], [34,59], [34,60], [34,61], [62,34]

Pomijam fakt że ostatni powinien być [34, 62] ścieżka od 34,62 powinna być taka jak w wyniku ( czyli właściwe piksele podano ) ale powinna być odwrócona czyli [34, 62], [34,61], [34,60], [34,59], [34,58] więc algorytm niewłaściwie podstawia dane początkujące i końcowe ;/

Tylko jak się tego nauczyć aby napisać dobry algorytm?
Gdzie szukać pomocy?

Kto mi pomoże ?

Dodaj na końcu:

[PHP] pobierz, plaintext 
$dots[] = $steep ? [$y2, $x2] : [$x2, $y2];
[PHP] pobierz, plaintext 

Odwrócenia możesz dokonać sam, o czym pisałem wcześniej.

Napisałem że odwrócenie to nie problem, pytanie w jaki sposób poinformować system kiedy należy odwrócić tablicę.

Przecież widzisz jaki wynik otrzymujesz - czy punkt początkowy jest na końcu tablicy, czy na początku.

Dziękuję Trueblue.

No bez ciebie bym nie ogarnął.

Teraz działa ładnie