in seoparate thread i wrote my thoughts about how
how some things (i mean managng array of variants of
some entites) should be done and it led me to
a two dimensuonal array where the second dimension is
tag-signature...and this is in fact what is so called dictionary

i wrote this (though not tested to much) ..i wonder how people
write analogon of such dictionaries in c, they must use something but i
dont know what so im not able to say what thsi i wrote si oryginal
but possibly find it natbe somewhat oryginal

heres the whole dictionary code :

struct Dict_KeyEntry { int key; int el_size; void* tab; int slen; };
Dict_KeyEntry* dict = NULL; int dict_keys = 0;

int dict_Add(int key, void* el, int el_size)
{ find_key: int k; for(k=0; k<dict_keys; k++) if( dict[k].key == key ) goto upsize_tab ;
upsize_keys: dict = (Dict_KeyEntry*) realloc(dict, ++dict_keys*sizeof(Dict_KeyEntry) );
dict[k] = {key, el_size, NULL, 0};
upsize_tab: dict[k].tab = realloc(dict[k].tab, ++dict[k].slen * dict[k].el_size);
insert_element: memcpy((char*)(dict[k].tab)+(dict[k].slen-1)*dict[k].el_size, el, el_size);
}

inline void* dict_el(int s, int i) {return (dict[s].tab + i*dict[s].el_size);}

sobota, 5 sierpnia 2023 o 22:12:01 UTC+2 fir napisał(a):
> in seoparate thread i wrote my thoughts about how
> how some things (i mean managng array of variants of
> some entites) should be done and it led me to
> a two dimensuonal array where the second dimension is
> tag-signature...and this is in fact what is so called dictionary
>
> i wrote this (though not tested to much) ..i wonder how people
> write analogon of such dictionaries in c, they must use something but i
> dont know what so im not able to say what thsi i wrote si oryginal
> but possibly find it natbe somewhat oryginal
>
> heres the whole dictionary code :
>
> struct Dict_KeyEntry { int key; int el_size; void* tab; int slen; };
> Dict_KeyEntry* dict = NULL; int dict_keys = 0;
>
> int dict_Add(int key, void* el, int el_size)
> {
> find_key: int k; for(k=0; k<dict_keys; k++) if( dict[k].key == key ) goto upsize_tab ;
> upsize_keys: dict = (Dict_KeyEntry*) realloc(dict, ++dict_keys*sizeof(Dict_KeyEntry) );
> dict[k] = {key, el_size, NULL, 0};
> upsize_tab: dict[k].tab = realloc(dict[k].tab, ++dict[k].slen * dict[k]..el_size);
> insert_element: memcpy((char*)(dict[k].tab)+(dict[k].slen-1)*dict[k].el_size, el, el_size);
> }
>
> inline void* dict_el(int s, int i) {return (dict[s].tab + i*dict[s].el_size);}

sadly there is some unconvenience of using this but the code above is somewhat curious (curious is its few lines for whole dictionary)

as tu usage inserting is somewhat standable becouse its understandable as i decided to insert by memcopy i need to pass sizeof

struct Human {char* name; float x,y,HP;};
struct Alien {char* name; float x,y,HP, a,b,c;};

void TestDictionary()
{

Human adam = {"adam", 100,0,10};
Human beata = {"beata", 200,100,20};
Human chloe = {"chloae",300,30,30};
Alien zzxzz = {"zzxzz", 40,0,44,1,1,1};
Alien ssyss = {"ssyss", 50,100,55,2,2,2};
Alien bbnbb = {"bbnbb", 60,20,66,3,3,3};

dict_Add('human', &adam, sizeof(Human));
dict_Add('alien', &zzxzz, sizeof(Alien));
dict_Add('alien', &ssyss, sizeof(Alien));
dict_Add('alien', &bbnbb, sizeof(Alien));
dict_Add('human', &beata, sizeof(Human));
dict_Add('human', &chloe, sizeof(Human));

extern void PrintOutDictionary(); PrintOutDictionary();
}

more normal would be to comment line with memcopy and write a custom
functions for inserting using args to assign to record fields

acces is imo maybe kinda less standable as you need the function
returnig pointer to element ram..this is becoyse this dictionary holds different size
structures under different keys (there is an option to hold uniwersal one type structure then simply pointer tu subarray can be returned

well here also poiners to subarrays can be returned though it needs
type reckognizing switch

void PrintOutDictionary()
{ for(int s=0; s<dict_keys;s++)
for(int i=0; i<dict[s].slen; i++)
{
Human* h = (Human*) dict_el(s,i);
printf("\n name %s, HP %f ", (*h).name, (*h).HP);
}

}

some notes
1) it may seem to look ugly but in fact when koding such things you need to do such things (like this key-based switch) anyway
2) it shows the lacks of c as if c would be mendad as i propose those things can be both written ad use much nicer

in reallity with custom add functions it would look nicer fortunatelly

struct Asteroid {float x,y,r, HP;};

void AddAsteroid(float x, float y, float r, float HP)
{ Asteroid* as = (Asteroid*) dict_AddEmpty('asteroid', sizeof(Asteroid));
as[0].x = x;
as[0].y = y;
as[0].r = r;
as[0].HP = HP;

}

struct AlienShip {float x,y,r, speed, HP;};

void AddAlienShip(float x, float y, float r, float speed, float HP)
{ AlienShip* al = (AlienShip*) dict_AddEmpty('alien', sizeof(AlienShip));
al[0].x = x;
al[0].y = y;
al[0].r = r;
al[0].speed =speed;
al[0].HP = HP;
}

void TestDictionary()
{

for(int i=0; i<1000; i++) AddAsteroid(rand2(-1000,1000), rand2(-1000,1000), 10, rand2(60,100));
for(int i=0; i<20; i++) AddAlienShip(rand2(-1000, 1000), rand2(0,1000), 10, rand2(10,12), rand2(20,25));

PrintOutAlienAsteroidCollisions();
} and those functions are needed anyway... this dictionary as it holds main game data dont need to be referenced by name as its just global inviosible container

the code to loop and use them is liek that

void PrintOutAlienAsteroidCollisions()
{ int alien_len, asteroid_len ;

AlienShip* alien = (AlienShip*) dict_Array('alien', &alien_len);
Asteroid* asteroid = (Asteroid*) dict_Array('asteroid', &asteroid_len);

for(int j=0; j<alien_len; j++)
for(int i=0; i<asteroid_len; i++)
{
float dx = alien[j].x - asteroid[i].x;
float dy = alien[j].y - asteroid[i].y;

if(sqrt(dx*dx + dy*dy)< alien[j].r + asteroid[i].r )
printf("\n collision of alien %d with asteroid %d", j,i);
}

}

ehere code for dictionaty

struct Dict_KeyEntry { int key; int el_size; void* tab; int slen; };
Dict_KeyEntry* dict = NULL; int dict_keys = 0;

void* dict_AddEmpty(int key, int el_size)
{ find_key: int k; for(k=0; k<dict_keys; k++) if( dict[k].key == key ) goto upsize_tab ;
upsize_keys: dict = (Dict_KeyEntry*) realloc(dict, ++dict_keys*sizeof(Dict_KeyEntry) );
dict[k] = {key, el_size, NULL, 0};
upsize_tab: dict[k].tab = realloc(dict[k].tab, ++dict[k].slen * dict[k].el_size);
return_adress: return (char*)(dict[k].tab)+(dict[k].slen-1)*dict[k].el_size;
} void* dict_Array(int key, int* len)
{ for(int k=0; k<dict_keys; k++)
if( dict[k].key == key ) { *len = dict[k].slen; return dict[k].tab; }

printf("ERROR (dict_Array): array not found for such key"); exit(-1);
}