int goc_systemFreeTimers()
{
int i;
for ( i=0; i<nHandler; i++ )
pId[i] = goc_stringFree(pId[i]);
pHandler = goc_tableClear( pHandler, &nHandler );
nHandler = i;
pId = goc_tableClear( pId, &nHandler);
return GOC_ERR_OK;
}
// teksty wywala, zostaja kolumny
static int listClear(GOC_HANDLER uchwyt)
{
GOC_StList *lista = (GOC_StList*)uchwyt;
GOC_COLUMN *k;
int j;
lista->kursor = -1;
lista->start = 0;
if ( lista->flag & GOC_LISTFLAG_EXTERNAL )
{
for ( j=0; j<lista->nKolumna; j++ )
{
k = lista->pKolumna[j];
k->pText = NULL;
k->nText = 0;
lista->flag &= ~GOC_LISTFLAG_EXTERNAL;
}
}
else
{
int i;
for ( j=0; j<lista->nKolumna; j++ )
{
k = lista->pKolumna[j];
for ( i=0; i<k->nText; i++ )
goc_stringFree(k->pText[i]);
k->pText = goc_tableClear(k->pText, &k->nText);
}
}
return GOC_ERR_OK;
}
int goc_labelRemLines(GOC_HANDLER u)
{
GOC_StLabel *napis = (GOC_StLabel*)u;
int i;
for ( i = 0; i<napis->nText; i++ )
goc_stringFree(napis->tekst[i].line);
napis->tekst = goc_tableClear(napis->tekst, &napis->nText);
return GOC_ERR_OK;
}
static int goc_listDestroy(GOC_HANDLER uchwyt)
{
GOC_StList *lista = (GOC_StList*)uchwyt;
int j;
goc_listClear(uchwyt);
goc_stringFree(lista->pTytul);
for ( j=0; j<lista->nKolumna; j++ )
free(lista->pKolumna[j]);
lista->pKolumna = goc_tableClear(
lista->pKolumna, &lista->nKolumna);
return goc_elementDestroy(uchwyt);
}
static int listAddText(GOC_HANDLER u, const char *buf)
{
GOC_LISTROW wiersz;
int retCode;
memset( &wiersz, 0, sizeof(GOC_LISTROW) );
wiersz.nRow = -1;
wiersz.pText = goc_tableAdd(wiersz.pText, &wiersz.nText,
sizeof(char *));
wiersz.pText[wiersz.nText-1] = buf;
retCode = goc_systemSendMsg(u, GOC_MSG_LISTADDROW, &wiersz, 0);
wiersz.pText = goc_tableClear(wiersz.pText, &wiersz.nText);
return retCode;
}
int goc_barListener(GOC_HANDLER uchwyt, GOC_MSG wiesc, void* pBuf, unsigned int nBuf)
{
if ( wiesc == GOC_MSG_CREATE )
{
GOC_StElement* elem = (GOC_StElement*)pBuf;
GOC_HANDLER* retuchwyt = (GOC_HANDLER*)nBuf;
GOC_StBar* pasek = (GOC_StBar*)malloc(sizeof(GOC_StBar));
memcpy(pasek, elem, sizeof(GOC_StElement));
pasek->tekst = NULL;
pasek->nText = 0;
pasek->start = 0;
pasek->kursor = -1;
*retuchwyt = (GOC_HANDLER)pasek;
pasek->kolorNieaktywny = GOC_WHITE;
pasek->kolorAktywny = pasek->color;
pasek->kolorZaznaczony = GOC_WHITE | GOC_FBOLD;
pasek->rozmiar = GOC_BAR_COUNTEDSIZE;
pasek->color = pasek->kolorNieaktywny;
goc_hkAdd(*retuchwyt, 0x600, GOC_EFLAGA_ENABLE | GOC_HKFLAG_SYSTEM,
barHotKeyNext);
goc_hkAdd(*retuchwyt, 0x601, GOC_EFLAGA_ENABLE | GOC_HKFLAG_SYSTEM,
barHotKeyPrev);
goc_hkAdd(*retuchwyt, 0x602, GOC_EFLAGA_ENABLE | GOC_HKFLAG_SYSTEM,
barHotKeyNext);
goc_hkAdd(*retuchwyt, 0x603, GOC_EFLAGA_ENABLE | GOC_HKFLAG_SYSTEM,
barHotKeyPrev);
return GOC_ERR_OK;
}
else if ( wiesc == GOC_MSG_DESTROY )
{
GOC_StBar *pasek = (GOC_StBar*)uchwyt;
int i;
for (i=0; i<pasek->nText; i++)
free(pasek->tekst[i]);
pasek->tekst = goc_tableClear(pasek->tekst, &(pasek->nText));
return goc_elementDestroy(uchwyt);
}
else if ( wiesc == GOC_MSG_PAINT )
{
return barPaint(uchwyt);
}
else if ( wiesc == GOC_MSG_FOCUS )
{
return barFocus(uchwyt);
}
else if ( wiesc == GOC_MSG_FOCUSFREE )
{
return barFreeFocus(uchwyt);
}
return GOC_ERR_UNKNOWNMSG;
}
// Dodanie nowego wierszu i ustawienie tekstu dla podanej kolumny
int goc_listAddColumnText(GOC_HANDLER u, const char *tekst, int kolumna)
{
GOC_LISTROW wiersz;
int ret;
memset( &wiersz, 0, sizeof(GOC_LISTROW));
wiersz.pText = goc_tableResize( wiersz.pText, &(wiersz.nText),
sizeof(char*), kolumna+1);
wiersz.pText[kolumna] = tekst;
wiersz.nRow = -1;
ret = goc_systemSendMsg(u, GOC_MSG_LISTADDROW, &wiersz, 0);
wiersz.pText = goc_tableClear( wiersz.pText, &(wiersz.nText) );
return ret;
/*
GOC_StList* lista = (GOC_StList*)u;
char *pBuf = NULL;
GOC_COLUMN *k = NULL;
int i;
if ( lista->flag & GOC_LISTFLAG_EXTERNAL )
return GOC_ERR_REFUSE;
// jesli nie ma to stworz nowa kolumne
if ( lista->nKolumna == 0 )
goc_listAddColumn(u, lista->width);
if ( kolumna >= lista->nKolumna )
return GOC_ERR_REFUSE;
// zrob kopie dodawanego tekstu
pBuf = goc_stringCopy(pBuf, tekst);
// dodaj do wszystkich kolumn wiersz, ustawiajac ten do ktorego
// ma zostac wpisany tekst
for ( i=0; i<lista->nKolumna; i++ )
{
k = lista->pKolumna[i];
k->pText = goc_tableAdd(k->pText, &(k->nText),sizeof(char*));
if ( i != kolumna )
k->pText[k->nText-1] = NULL;
else
k->pText[k->nText-1] = pBuf;
}
return GOC_ERR_OK;
*/
}
static void generateLandMass(
int code, // genrowany kod
int *pAllowedCode, // dozwolona tablica kodow do zjadania
int nAllowedCode)
{
stChange** pBiomeSet = NULL;
int nBiomeSet = 0;
int landMass = context->configuration.minLandMass + goc_random(context->configuration.maxLandMass-context->configuration.minLandMass);
stChange* point = NULL;
GOC_BINFO("Generate land %d with landmass size %d", code, landMass);
point = randomLandMassStartPoint(code, pAllowedCode, nAllowedCode, 20);
if ( point == NULL )
{
GOC_INFO("Start point of landmass not found");
return;
}
pBiomeSet = goc_tableAdd(pBiomeSet, &nBiomeSet, sizeof(void*));
pBiomeSet[nBiomeSet-1] = point;
goc_maparawSetPoint(context->mapa, point->x, point->y, point->v);
while ( landMass )
{
if ( ! nBiomeSet )
{
break;
}
int r = goc_random(nBiomeSet);
point = pBiomeSet[r];
int x = point->x;
int y = point->y;
// czy ma zginac - TODO: MARGIN
if (
( (x+1 >= context->configuration.maxx) || (!isInCodeSet(goc_maparawGetPoint(context->mapa, x+1, y), pAllowedCode, nAllowedCode)) ) &&
( (y+1 >= context->configuration.maxy) || (!isInCodeSet(goc_maparawGetPoint(context->mapa, x, y+1), pAllowedCode, nAllowedCode)) ) &&
( (y-1 <= 0) || (!isInCodeSet(goc_maparawGetPoint(context->mapa, x, y-1), pAllowedCode, nAllowedCode)) ) &&
( (x-1 <= 0) || (!isInCodeSet(goc_maparawGetPoint(context->mapa, x-1, y), pAllowedCode, nAllowedCode)) )
)
{
free(pBiomeSet[r]);
pBiomeSet = goc_tableRemove(pBiomeSet, &nBiomeSet, sizeof(void*), r);
continue;
}
// znajdz, jakie miejsce moze zarazic
{
// RANDOM ONLY in 4 base direction
int r = goc_random(4);
switch ( r )
{
case 0:
x++;
break;
case 1:
x--;
break;
case 2:
y++;
break;
case 3:
y--;
break;
}
}
// wykluczenie
if (( x >= context->configuration.maxx ) || ( y >= context->configuration.maxy ) || ( x < 0 ) || ( y < 0 ))
{
continue;
}
if ( !isInCodeSet( goc_maparawGetPoint(context->mapa, x, y), pAllowedCode, nAllowedCode) )
{
continue;
}
// wykonaj zarazenie
{
stChange* newpoint = mallocPoint(x, y, point->v);
pBiomeSet = goc_tableAdd(pBiomeSet, &nBiomeSet, sizeof(void*));
pBiomeSet[nBiomeSet-1] = newpoint;
goc_maparawSetPoint(context->mapa, x, y, point->v);
landMass--;
// goc_maskPaintPoint(maska, x, y); // TODO: metoda paintAreaPoint, do rysowania punktu wskazanego z danych
}
}
pBiomeSet = goc_tableClear(pBiomeSet, &nBiomeSet);
}
// TODO : random landMass from min to max
// TODO : putting next landMass level for height
static void civGeneration(GOC_HANDLER mapa, int numStartPoints, int minLM, int maxLM, int MINLEVEL, int NEWLEVEL)
{
// int MINLEVEL=0;
// int NEWLEVEL=1;
int type = 0;
stChange point;
point.x = 0;
point.y = 0;
point.v = 0;
stChange** pSet = NULL;
int nSet = 0;
int landMass;
int svStartPoints = numStartPoints;
int createdLandMass;
GOC_BINFO("Start civ generation system [numStartPoint: %d, minLandMass: %d, maxLandMass: %d, level: %d]", numStartPoints, minLM, maxLM, NEWLEVEL);
if ( MINLEVEL >= 10 )
return;
if ( numStartPoints <= 0 )
return;
if ( maxLM <= 0 )
return;
while (numStartPoints--)
{
GOC_BDEBUG("Number of start points %d", numStartPoints);
// inicjowanie do kolejnej iteracji tworzenia masy ladowej
type = 0;
landMass = minLM + goc_random(maxLM-minLM);
createdLandMass = 0;
GOC_BINFO("Generated landmass: %d", landMass);
if ( nSet )
{
GOC_DEBUG("Clear set");
int i;
for ( i=0; i<nSet; i++ )
free(pSet[i]);
pSet = goc_tableClear(pSet, &nSet);
}
while ( landMass )
{
GOC_BDEBUG("Landmass to generate %d", landMass);
// random new point
if ( randomPoint(&point, type, MINLEVEL, mapa) )
{
GOC_BDEBUG("Setting a point (%d,%d,%d)", point.x, point.y, NEWLEVEL);
pSet = goc_tableAdd(pSet, &nSet, sizeof(void*));
pSet[nSet-1] = mallocPoint(point.x, point.y, NEWLEVEL);
goc_maparawSetPoint(mapa, point.x, point.y, NEWLEVEL);
createdLandMass++;
}
landMass--;
while ( nSet )
{
// random point from set
int randp = goc_random(nSet);
int x, y;
type = 1; // neighbour
// check a point has any free neighbour
x = pSet[randp]->x;
y = pSet[randp]->y;
if (
( (x+1 < context.configuration.maxx) && (goc_maparawGetPoint(mapa, x+1, y) <= MINLEVEL) ) ||
( (y+1 < context.configuration.maxy) && (goc_maparawGetPoint(mapa, x, y+1) <= MINLEVEL )) ||
( (y > 0) && (goc_maparawGetPoint(mapa, x, y-1) <= MINLEVEL) ) ||
( (x > 0) && (goc_maparawGetPoint(mapa, x-1, y) <= MINLEVEL) )
)
{
point.x = x;
point.y = y;
point.v = pSet[randp]->v;
GOC_BDEBUG("Find point in set (%d,%d,%d)", point.x, point.y, point.v);
break;
}
else
{
GOC_DEBUG("Remove point from set");
free(pSet[randp]);
pSet = goc_tableRemove(pSet, &nSet, sizeof(void*), randp);
}
}
// check, if there are any points in set
if ( !nSet )
break;
}
GOC_BINFO("Created landmass: %d", createdLandMass);
}
civGeneration(
mapa,
svStartPoints, //-svStartPoints/20,
minLM-minLM*precentageCut[MINLEVEL]/10,
maxLM-maxLM*precentageCut[MINLEVEL]/10,
MINLEVEL+1,
NEWLEVEL+1);
/*
pStartPoint = randomStartPoints(&nStartPoint, numStartPoints);
for (i=0; i<nStartPoint; i++)
{
goc_maparawSetPoint(mapa, pStartPoint[i]->x, pStartPoint[i]->y, 1);
}
*/
}
/*
* Wykonuje przebieg poprzez kolejne linie i sprawdza otoczenie punktu,
* probujac okreslic punkt, ktory postawi - tendencja opadajaca
* Przebieg wykonywany jest podana liczbe razy
*/
void petlaGrow(GOC_HANDLER maska, int cnt)
{
stChange **pZmiany = NULL;
int nZmiany = 0;
int i, j, k, v, n, t;
// ustawienie poczatkowych punktow
randomLandSeed(maska, 1);
for ( i=0; i<cnt; i++ )
{
for ( j=0; j<context.configuration.maxx; j++ )
for ( k=0; k<context.configuration.maxy; k++ )
{
fprintf(stderr, "[i,j,k]=[%d,%d,%d]\n",i,j,k);
v = goc_maparawGetPoint(maska, j, k);
if ( v == 0 )
{
n = 0;
// sprawdz otoczenie
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
if ( j != 39 )
t = goc_maparawGetPoint(maska, (j+1), k);
else
t = 0;
if ( t )
{
v += t;
n++;
}
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
if ( j != 0 )
t = goc_maparawGetPoint(maska, (j-1), k);
else
t = 0;
if ( t )
{
v += t;
n++;
}
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
if ( k != 22 )
t = goc_maparawGetPoint(maska, j, (k+1));
else
t = 0;
if ( t )
{
v += t;
n++;
}
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
if ( k != 0 )
t = goc_maparawGetPoint(maska, j, (k-1));
else
t = 0;
if ( t )
{
v += t;
n++;
}
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
if ( n )
{
// zgromadz zmiany
stChange *x = malloc(sizeof(stChange));
x->x = j;
x->y = k;
v /= n;
v--;
x->v = v;
pZmiany = goc_tableAdd(
pZmiany,
&nZmiany,
sizeof(stChange*));
pZmiany[nZmiany-1] = x;
}
}
}
// zastosuj zmiany
for ( j = 0; j<nZmiany; j++ )
goc_maparawSetPoint(maska, pZmiany[j]->x, pZmiany[j]->y,
pZmiany[j]->v);
// czysc tablice zmian
for ( j=0; j<nZmiany; j++ )
free(pZmiany[j]);
pZmiany = goc_tableClear(pZmiany, &nZmiany);
}
}
