/* ToDo: Thread Function for Enemy */
int Enemy(void* dummy){
unsigned int count;
unsigned int x,y;
unsigned int i = 10,j = 10;
count=0;
printf("Thread:");
do {
x = rand();
y = rand();
x %= (MAX_X);
y %= (MAX_Y);
} while(!CHECK_EMPTY(x, y));
playground[y][x] = ENEMY;
//Steuerung des Enemy
SDL_Delay(randomGTime(3000, 5000));
thrd_create(NULL, Enemy, NULL);
for (count = 0; count < 25U; count++)
{
int nx, ny;
nx = x;
ny = y;
//playground[y][x] = ENEMY;
/* retrieve pacman position, so that enemy can follow ... */
GetPacmanPosition(&i, &j);
if (i>x && CHECK_EMPTY_OR_PLAYER(x + 1, y))
nx++;
else
if (i<x && CHECK_EMPTY_OR_PLAYER(x - 1, y))
nx--;
else
if (j<y && CHECK_EMPTY_OR_PLAYER(x, y - 1))
ny--;
else
if (j>y && CHECK_EMPTY_OR_PLAYER(x, y + 1))
ny++;
playground[y][x]=EMPTY;
playground[ny][nx]=ENEMY;
x=nx;
y=ny;
SDL_Delay(300);
}
playground[y][x]=EMPTY;
return 0;
}
void TREE_ARAMA_KERNEL::SLOT_SEARCH_BUTTON()
{
run_search_button->setDisabled(true);
if ( CHECK_VAR_CONTROL() EQ false ) {
run_search_button->setDisabled(false);
return;
}
if ( CHECK_EMPTY() EQ ADAK_FAIL ) {
run_search_button->setDisabled ( false );
return;
}
SEARCH();
run_search_button->setDisabled ( false );
}
/* ToDo: Callbacks for Goodies */
Uint32 NewGoodie(Uint32 intervall, void* param){
int rX = 0, rY = 0;
do{
rX = rand() % (MAX_X-1);
rY = rand() % (MAX_Y-1);
printf("%d, %d\n", rX, rY);
} while(!CHECK_EMPTY(rX, rY));
tGoodie *fG = malloc(sizeof(tGoodie));
fG-> x = rX;
fG-> y = rY;
fG->behind = playground[rY][rX];
playground[rY][rX] = GOODIE;
SDL_TimerID remover = SDL_AddTimer(randomGTime(4000, 7000), RemoveGoodie, fG);
SDL_TimerID timer = SDL_AddTimer(randomGTime(2000, 5000), NewGoodie, NULL);
return 0;
}
int main(int UNUSED(argc), char UNUSED(**argv))
{
skDQErr_t err;
pthread_t a, b, c;
int rv;
char *v;
skAppRegister("skdeque-test");
skthread_init("main");
rv = sklogSetup(0);
assert(rv == 0);
rv = sklogSetDestination("stderr");
assert(rv == 0);
rv = sklogOpen();
assert(rv == 0);
rv = sklogSetLevel("debug");
assert(rv == 0);
rv = sklogEnableThreadedLogging();
assert(rv == 0);
rv = sklogSetStampFunction(&log_stamp);
assert(rv == 0);
da = skDequeCreate();
db = skDequeCreate();
dc = skDequeCreate();
/*** Single threaded tests ***/
/* check empty deque */
CHECK_EMPTY(da);
/* push first element onto 'da' and check */
err = skDequePushFront(da, (void*)xa);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
XASSERT(1 == skDequeSize(da));
/* push first element onto 'db' and check */
err = skDequePushBack(db, (void*)xb);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
err = skDequeFront(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
XASSERT(1 == skDequeSize(db));
/* push first element onto 'dc' */
err = skDequePushFront(dc, (void*)xc);
XASSERT(err == SKDQ_SUCCESS);
/* push second element onto front 'da' and check */
err = skDequePushFront(da, (void*)xx);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(2 == skDequeSize(da));
/* push second element onto 'db' and 'dc' */
err = skDequePushFront(db, (void*)xy);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushFront(dc, (void*)xz);
XASSERT(err == SKDQ_SUCCESS);
/* push third element onto back of 'da' and check */
err = skDequePushBack(da, (void*)xa);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(3 == skDequeSize(da));
/* push third element onto back of 'db' and 'dc' */
err = skDequePushBack(db, (void*)xb);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(dc, (void*)xc);
XASSERT(err == SKDQ_SUCCESS);
/* push fourth element onto back of 'da' and check */
err = skDequePushBack(da, (void*)xx);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(4 == skDequeSize(da));
/* push fourth element onto back of 'db' and 'dc' */
err = skDequePushBack(db, (void*)xy);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(dc, (void*)xz);
XASSERT(err == SKDQ_SUCCESS);
/* pop four elements from 'da', each from the front */
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(3 == skDequeSize(da));
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
XASSERT(2 == skDequeSize(da));
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
XASSERT(1 == skDequeSize(da));
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(0 == skDequeSize(da));
/* verify 'da' is empty */
CHECK_EMPTY(da);
/* pop four elements from 'db', each from the back */
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
XASSERT(3 == skDequeSize(db));
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
XASSERT(2 == skDequeSize(db));
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
XASSERT(1 == skDequeSize(db));
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
XASSERT(0 == skDequeSize(db));
/* verify 'db' is empty */
CHECK_EMPTY(db);
/* pop four elements from 'dc' */
err = skDequePopFrontNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
err = skDequePopBackNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
err = skDequePopFrontNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
err = skDequePopBackNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
err = skDequePopBackNB(dc, (void**)&v);
XASSERT(err == SKDQ_EMPTY);
/* verify 'dc' is empty */
CHECK_EMPTY(dc);
/* create a merged queue from 'da' and 'db' */
dd = skDequeCreateMerged(da, db);
/* verify 'dd' is empty */
CHECK_EMPTY(dd);
/* push the first element onto each of 'da' and 'db' */
err = skDequePushBack(da, (void*)xa);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(db, (void*)xx);
XASSERT(err == SKDQ_SUCCESS);
/* check sizes */
XASSERT(1 == skDequeSize(da));
XASSERT(1 == skDequeSize(db));
XASSERT(2 == skDequeSize(dd));
/* peek at front and back of merged deck */
err = skDequeBack(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
err = skDequeFront(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
/* push the second element onto each of 'da' and 'db' */
err = skDequePushBack(da, (void*)xb);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(db, (void*)xy);
XASSERT(err == SKDQ_SUCCESS);
/* peek at front and back of merged deck */
err = skDequeBack(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
err = skDequeFront(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
/* push a third element onto front and back of merged deck */
err = skDequePushFront(dd, (void*)xc);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(db, (void*)xz);
XASSERT(err == SKDQ_SUCCESS);
/* check sizes */
XASSERT(3 == skDequeSize(da));
XASSERT(3 == skDequeSize(db));
XASSERT(6 == skDequeSize(dd));
/* peek at front and back of 'da' */
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
/* peek at front and back of 'db' */
err = skDequeBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
err = skDequeFront(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
/* pop three elements from front of 'dd' */
XASSERT(6 == skDequeSize(dd));
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
/* verify 'da' is empty */
CHECK_EMPTY(da);
/* pop three elements from front of 'dd' */
XASSERT(3 == skDequeSize(dd));
XASSERT(3 == skDequeSize(db));
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
/* verify 'db' is empty */
CHECK_EMPTY(db);
/* verify 'dd' is empty */
CHECK_EMPTY(dd);
/* done with 'dd' */
skDequeDestroy(dd);
/* verify 'da' and 'db' are still empty (and valid) */
CHECK_EMPTY(da);
CHECK_EMPTY(db);
/*** Multi-threaded tests ***/
rv = skthread_create("a", &a, thread_a, NULL);
XASSERT(rv == 0);
rv = skthread_create("b", &b, thread_b, NULL);
XASSERT(rv == 0);
rv = skthread_create("c", &c, thread_c, NULL);
XASSERT(rv == 0);
rv = pthread_join(a, NULL);
XASSERT(rv == 0);
rv = pthread_join(b, NULL);
XASSERT(rv == 0);
rv = pthread_join(c, NULL);
XASSERT(rv == 0);
skDequeDestroy(dc);
skDequeDestroy(db);
skDequeDestroy(da);
sklogClose();
sklogTeardown();
skthread_teardown();
skAppUnregister();
return 0;
}
