(kiedys juz o tym pisalem ale jeszcze raz)

spacjala kolizyjna ma pewna wadę :->

o ile normalnie wspolrzednymi przestrzennymi
obiektow (na scenie/mapie/planszy) mozna
dowolnie manipulowac

to kiedy robi sie pomocnicza strukture
(np wlasnie owa 'spacjale' kolizyjna)
(ktora ma pewien charakter jakby 'cache')
to trzeba nieustannie bardzo pilnowac
sie by nie doszlo do 'desynchronizacji'
tych dwu zbiorow danych

- o to moge powiedziec z doswiadczenia
jest latwo (da sie to zrobic ale z gory mozna
sie spodziewac nowego zrodla potencjalnych
bledow przy robieniu progsa)

chodzi mi tez o to ze to zagadnienie
(setow danych w progsie ktore trzeba
synchronizowac) mozna potraktowac
ogolniej - pytanie jak to zagadnienie
sie nazywa, jak to nazwac - bo nie wiem
czy jest to jakies zagadnienie z 'teorii
cache' (o ile jest cos takiego) czy
jakies zagadnienie dot 'synchronizacji
stanow czy zbiorow' itp - nie wiem
jak to sie nazywa

ma to tez cos wspolnego powiedzialbym z
zagadnieniami 'interfejsow' bo w momencie
gdy dodaje sie taka cachujaca strukture
to moze pojawic sie np wyrazna potrzeba
zamkniecia pewnej grupy operacji (tj np
tu konkretnie zmian pozycji obiektow na
planszy) i wydzielenia wylacznego interfejsu
gdzie pod spodem automatycznie dbano
by o to by duplikowany zbior sie nie
rozsynchronizowal - przy czym mozna zauwazyc
ze ta potrzeba pojawia sie dopiero tutaj
(wczesniej w normalnym programowaniu ktore
zwykle obywa sie bez takich cacheowanych setow
tej potrzeby nie ma)


(kenobi)















--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

> ma to tez cos wspolnego powiedzialbym z
> zagadnieniami 'interfejsow' bo w momencie

konkretne zagadnienie dodatkowe

powiedzmy ze mam wlasnie taki przypadek:

1) tablice postaci ktore maja zapisane w polach
swoje pozycje na mapie

postac[id].x
postac[id].y

2) pomocnicza strukture zapisujaca duplikaty powyzszych
wspolrzednych postaci w przestrzennej tablicy (nazwanej
tutaj plansza)

int id = plansza[y][x]

jak wydzielic 'interfejs' niezbednych operacji tak by
bylo wzglednie ok (i nie doszlo do desynchronizacji itp)
?

(kenobi)


--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

>
> (1) postac[id].x
> postac[id].y
>
> (2) id = plansza[y][x]

przy okazji ciekawostka,

w tutorialach Gourleya dot symulacji fluidow
(ciekawych ale za trudnych dla mnie),

pierwszy sposob trzymania obiektow (tam konkretnie
czastek) nazywa sie lagranzowskim a drugi eulerowskim

("...here in contrast with the Eulerian view, where position
is fixed to the grid. This treatment of fluids is called
a Lagrangian view...")





--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@W...gazeta.pl> napisał(a):

>
> > ma to tez cos wspolnego powiedzialbym z
> > zagadnieniami 'interfejsow' bo w momencie
>
> konkretne zagadnienie dodatkowe
>
> powiedzmy ze mam wlasnie taki przypadek:
>
> 1) tablice postaci ktore maja zapisane w polach
> swoje pozycje na mapie
>
> postac[id].x
> postac[id].y
>
> 2) pomocnicza strukture zapisujaca duplikaty powyzszych
> wspolrzednych postaci w przestrzennej tablicy (nazwanej
> tutaj plansza)
>
> int id = plansza[y][x]
>
> jak wydzielic 'interfejs' niezbednych operacji tak by
> bylo wzglednie ok (i nie doszlo do desynchronizacji itp)
> ?
>

mozna pomyslec tak (acz nie jestempewien czy to jest do konca
dobre pomyslenie), ze zwykly dostep do tego

postac[id].x
postac[id].y

int id = plansza[y][x]

powinien zostac zablokowany a w zamian za to powinien byc
wystawiony jakis minimalny interfejs, ale jaki bylby ten
minimalny interfejs?

ew mysle czy mogloby byc np

bool movePostacTo(int id, int x, int y) //fajlujacy i dajacy tez mozliwosc
//ewentualnego wyrzucenia poza plansze

to obslugiwaloby wiekszosc przypadkow ale chyab tez byloby
potrzebne

int id = PostacAt(x,y);

nie wiem czybyto wystarczylo - do tego w realnym przypadku
jest nieladniej bo na mapie moze byc wiecej encji roznych typow





--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

wychodzi ze to moze byloby cos w stylu:


const int pole_puste = -1;
const int postac_none = -1;

inline bool wPlanszy(int x, int y)
{
return (x>=0 && x<plansza_maxx && y>=0 && y<plansza_maxy );
}


bool movePostacTo(int id, int x, int y)
{
if(plansza[y][x] == pole_puste)
{
int oldx = postac[id].x;
int oldy = postac[id].y;

if(wPlanszy(oldx, oldy))
plansza[oldy][oldx] = pole_puste;

postac[id].x = x;
postac[id].y = y;

if(wPlanszy(x, y))
plansza[y][x] = id;

return true;

}

return false;

}

inline int getPostacAt(int x, int y)
{
return plansza[y][x];
}

//int getPostacAt(int x, int y) // odrzucone bo spr zakresow jednak
niepotrzebne
//{

// if(wPlanszy(x,y)
// return plansza[y][x];
//
// return postac_none;
//}



pamietam ze kiedys bylem o wiele madrzejszy bo staralbym sie
to ew przemyslec poprawiac wydajnosciowo a dzis mi sie nie chce

'abstrakcyjnie' to by bylo cos zachaczajacego o wygibasy jak

postac(i).poz=xy;
i=postac.poz(xy);

ale poki co nie ma chyba czegos takiego






--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry