1 files changed, 270 insertions, 273 deletions

diff --git a/src/modules/modAI.c b/src/modules/modAI.c
index 372e8cb..b29e141 100755
--- a/src/modules/modAI.c
+++ b/src/modules/modAI.c
@@ -13,326 +13,321 @@
 #include "space.h"
 
 #ifndef PUBLIC_SERVER
-  #include "interface.h"
-  #include "image.h"
+#include "interface.h"
+#include "image.h"
 #else
-  #include "publicServer.h"
+#include "publicServer.h"
 #endif
 
 static export_fce_t *export_fce;
 
 typedef struct alternative_struct
 {
-	int first;
-	int route;
-	int step;
-	int x, y;
+    int first;
+    int route;
+    int step;
+    int x, y;
 } alternative_t;
 
-alternative_t* newAlternative(int route, int x, int y)
+alternative_t *
+newAlternative(int route, int x, int y)
 {
-	alternative_t *new;
+    alternative_t *new;
 
-	new = malloc( sizeof(alternative_t) );
-	new->first = route;
-	new->route = route;
-	new->x = x;
-	new->y = y;
-	new->step = 0;
+    new = malloc(sizeof(alternative_t));
+    new->first = route;
+    new->route = route;
+    new->x = x;
+    new->y = y;
+    new->step = 0;
 
-	return new;
+    return new;
 }
 
-alternative_t* cloneAlternative(alternative_t *p, int route, int x, int y)
+alternative_t *
+cloneAlternative(alternative_t * p, int route, int x, int y)
 {
-	alternative_t *new;
+    alternative_t *new;
 
-	assert( p != NULL );
-	
-	new = newAlternative(route, p->x, p->y);
-	new->first = p->first;
-	new->step = p->step;
+    assert(p != NULL);
 
-	return new;
+    new = newAlternative(route, p->x, p->y);
+    new->first = p->first;
+    new->step = p->step;
+
+    return new;
 }
 
-void forkAlternative(list_t *list, alternative_t *p, int w, int h)
+void
+forkAlternative(list_t * list, alternative_t * p, int w, int h)
 {
-	int x, y;
-
-	assert( list != NULL );
-	assert( p != NULL );
-
-	x  = p->x;
-	y  = p->y;
-
-	switch( p->route )
-	{
-		case TUX_UP :
-			addList(list, cloneAlternative(p, TUX_RIGHT, x+(w+5), y ) );
-			addList(list, cloneAlternative(p, TUX_LEFT, x-(w+5), y ) );
-		break;
-		case TUX_RIGHT :
-			addList(list, cloneAlternative(p, TUX_UP, x, y-(h+5) ) );
-			addList(list, cloneAlternative(p, TUX_DOWN, x, y+(h+5) ) );
-		break;
-		case TUX_LEFT :
-			addList(list, cloneAlternative(p, TUX_UP, x, y-(h+5) ) );
-			addList(list, cloneAlternative(p, TUX_DOWN, x, y+(h+5) ) );
-		break;
-		case TUX_DOWN :
-			addList(list, cloneAlternative(p, TUX_RIGHT, x+(w+5), y ) );
-			addList(list, cloneAlternative(p, TUX_LEFT, x-(w+5), y ) );
-		break;
-	}
+    int x, y;
+
+    assert(list != NULL);
+    assert(p != NULL);
+
+    x = p->x;
+    y = p->y;
+
+    switch (p->route) {
+    case TUX_UP:
+        addList(list, cloneAlternative(p, TUX_RIGHT, x + (w + 5), y));
+        addList(list, cloneAlternative(p, TUX_LEFT, x - (w + 5), y));
+        break;
+    case TUX_RIGHT:
+        addList(list, cloneAlternative(p, TUX_UP, x, y - (h + 5)));
+        addList(list, cloneAlternative(p, TUX_DOWN, x, y + (h + 5)));
+        break;
+    case TUX_LEFT:
+        addList(list, cloneAlternative(p, TUX_UP, x, y - (h + 5)));
+        addList(list, cloneAlternative(p, TUX_DOWN, x, y + (h + 5)));
+        break;
+    case TUX_DOWN:
+        addList(list, cloneAlternative(p, TUX_RIGHT, x + (w + 5), y));
+        addList(list, cloneAlternative(p, TUX_LEFT, x - (w + 5), y));
+        break;
+    }
 
 }
 
-void moveAlternative(alternative_t *p, int offset)
+void
+moveAlternative(alternative_t * p, int offset)
 {
-	assert( p != NULL );
-
-	p->step++;
-
-	//printf("move %d %d %d\n", p->x, p->y, p->step);
-
-	switch( p->route )
-	{
-		case TUX_UP :
-			p->y -= offset;
-		break;
-		case TUX_RIGHT :
-			p->x += offset;
-		break;
-		case TUX_LEFT :
-			p->x -= offset;
-		break;
-		case TUX_DOWN :
-			p->y += offset;
-		break;
-	}
+    assert(p != NULL);
+
+    p->step++;
+
+    //printf("move %d %d %d\n", p->x, p->y, p->step);
+
+    switch (p->route) {
+    case TUX_UP:
+        p->y -= offset;
+        break;
+    case TUX_RIGHT:
+        p->x += offset;
+        break;
+    case TUX_LEFT:
+        p->x -= offset;
+        break;
+    case TUX_DOWN:
+        p->y += offset;
+        break;
+    }
 }
 
-void destroyAlternative(alternative_t *p)
+void
+destroyAlternative(alternative_t * p)
 {
-	assert( p != NULL );
-	free(p);
+    assert(p != NULL);
+    free(p);
 }
 
-static void cmd_ai(char *line)
+static void
+cmd_ai(char *line)
 {
 }
 
-int init(export_fce_t *p)
+int
+init(export_fce_t * p)
 {
-	export_fce = p;
+    export_fce = p;
 
-	return 0;
+    return 0;
 }
 
 #ifndef PUBLIC_SERVER
-int draw(int x, int y, int w, int h)
+int
+draw(int x, int y, int w, int h)
 {
-	return 0;
+    return 0;
 }
 #endif
 
-tux_t *findOtherTux(space_t *space)
+tux_t *
+findOtherTux(space_t * space)
 {
-	int i;
+    int i;
 
-	for( i = 0 ; i < getSpaceCount(space) ; i++ )
-	{
-		tux_t *thisTux;
+    for (i = 0; i < getSpaceCount(space); i++) {
+        tux_t *thisTux;
 
-		thisTux = getItemFromSpace(space, i);
+        thisTux = getItemFromSpace(space, i);
 
-		if( thisTux->control != TUX_CONTROL_AI )
-		{
-			return thisTux;
-		}
-	}
+        if (thisTux->control != TUX_CONTROL_AI) {
+            return thisTux;
+        }
+    }
 
-	return NULL;
+    return NULL;
 }
 
-static void shotTux(arena_t *arena, tux_t *tux_ai, tux_t *tux_rival)
+static void
+shotTux(arena_t * arena, tux_t * tux_ai, tux_t * tux_rival)
 {
-	const int limit = 20;
-	int x_ai, y_ai;
-	int x_rival, y_rival;
-	int w, h;
-
-	export_fce->fce_getTuxProportion(tux_ai, &x_ai, &y_ai, &w, &h);
-	export_fce->fce_getTuxProportion(tux_rival, &x_rival, &y_rival, &w, &h);
-
-	if( y_rival < y_ai && x_rival > x_ai && x_rival < x_ai+limit )
-	{
-		export_fce->fce_actionTux(tux_ai, TUX_UP);
-		export_fce->fce_actionTux(tux_ai, TUX_SHOT);
-	}
-
-	if( x_rival > x_ai && y_rival > y_ai && y_rival < y_ai+limit )
-	{
-		export_fce->fce_actionTux(tux_ai, TUX_RIGHT);
-		export_fce->fce_actionTux(tux_ai, TUX_SHOT);
-	}
-
-	if( x_rival < x_ai && y_rival > y_ai && y_rival < y_ai+limit )
-	{
-		export_fce->fce_actionTux(tux_ai, TUX_LEFT);
-		export_fce->fce_actionTux(tux_ai, TUX_SHOT);
-	}
-
-	if( y_rival > y_ai && x_rival > x_ai && x_rival < x_ai+limit )
-	{
-		export_fce->fce_actionTux(tux_ai, TUX_DOWN);
-		export_fce->fce_actionTux(tux_ai, TUX_SHOT);
-	}
+    const int limit = 20;
+    int x_ai, y_ai;
+    int x_rival, y_rival;
+    int w, h;
+
+    export_fce->fce_getTuxProportion(tux_ai, &x_ai, &y_ai, &w, &h);
+    export_fce->fce_getTuxProportion(tux_rival, &x_rival, &y_rival, &w, &h);
+
+    if (y_rival < y_ai && x_rival > x_ai && x_rival < x_ai + limit) {
+        export_fce->fce_actionTux(tux_ai, TUX_UP);
+        export_fce->fce_actionTux(tux_ai, TUX_SHOT);
+    }
+
+    if (x_rival > x_ai && y_rival > y_ai && y_rival < y_ai + limit) {
+        export_fce->fce_actionTux(tux_ai, TUX_RIGHT);
+        export_fce->fce_actionTux(tux_ai, TUX_SHOT);
+    }
+
+    if (x_rival < x_ai && y_rival > y_ai && y_rival < y_ai + limit) {
+        export_fce->fce_actionTux(tux_ai, TUX_LEFT);
+        export_fce->fce_actionTux(tux_ai, TUX_SHOT);
+    }
+
+    if (y_rival > y_ai && x_rival > x_ai && x_rival < x_ai + limit) {
+        export_fce->fce_actionTux(tux_ai, TUX_DOWN);
+        export_fce->fce_actionTux(tux_ai, TUX_SHOT);
+    }
 }
 
-static void eventTuxAI(tux_t *tux)
+static void
+eventTuxAI(tux_t * tux)
 {
-	arena_t *arena;
-	tux_t *rivalTux;
+    arena_t *arena;
+    tux_t *rivalTux;
 
-	list_t *listAlternative;
-	list_t *listDst;
-	list_t *listFork;
+    list_t *listAlternative;
+    list_t *listDst;
+    list_t *listFork;
 
-	int x, y, w, h;
-	int rival_x, rival_y;
-	int i, index;
+    int x, y, w, h;
+    int rival_x, rival_y;
+    int i, index;
 
-	int countFork = 0;
-	int countDel = 0;
-	int countLimit = 0;
-	int countDo = 0;
+    int countFork = 0;
+    int countDel = 0;
+    int countLimit = 0;
+    int countDo = 0;
 
-	export_fce->fce_getTuxProportion(tux, &x, &y, &w, &h);
-	//printf("tux AI %d %d\n", x, y);
+    export_fce->fce_getTuxProportion(tux, &x, &y, &w, &h);
+    //printf("tux AI %d %d\n", x, y);
 
-	arena = export_fce->fce_getCurrentArena();
+    arena = export_fce->fce_getCurrentArena();
 
-	rivalTux = findOtherTux(arena->spaceTux);
+    rivalTux = findOtherTux(arena->spaceTux);
 
-	if( rivalTux == NULL || rivalTux->status != TUX_STATUS_ALIVE )
-	{
-		return;
-	}
+    if (rivalTux == NULL || rivalTux->status != TUX_STATUS_ALIVE) {
+        return;
+    }
 
-	listAlternative = newList();
-	listDst = newList();
-	listFork = newList();
+    listAlternative = newList();
+    listDst = newList();
+    listFork = newList();
 
-	shotTux(arena, tux, rivalTux);
+    shotTux(arena, tux, rivalTux);
 
-	export_fce->fce_getTuxProportion(rivalTux, &rival_x, &rival_y, NULL, NULL);
-	//printf("tux rival %d %d\n", rival_x, rival_y);
+    export_fce->fce_getTuxProportion(rivalTux, &rival_x, &rival_y, NULL,
+                                     NULL);
+    //printf("tux rival %d %d\n", rival_x, rival_y);
 
-	addList(listAlternative, newAlternative(TUX_UP, x, y-(h+10)) );
-	addList(listAlternative, newAlternative(TUX_RIGHT, x+(w+10), y) );
-	addList(listAlternative, newAlternative(TUX_LEFT, x-(w+10), y) );
-	addList(listAlternative, newAlternative(TUX_DOWN, x, y+(h+10)) );
+    addList(listAlternative, newAlternative(TUX_UP, x, y - (h + 10)));
+    addList(listAlternative, newAlternative(TUX_RIGHT, x + (w + 10), y));
+    addList(listAlternative, newAlternative(TUX_LEFT, x - (w + 10), y));
+    addList(listAlternative, newAlternative(TUX_DOWN, x, y + (h + 10)));
 
-	index = -1;
-	while(1)
-	{
-		alternative_t *this;
+    index = -1;
+    while (1) {
+        alternative_t *this;
 
-		index++;
-		if( index < 0 || index >= listAlternative->count )
-		{
+        index++;
+        if (index < 0 || index >= listAlternative->count) {
 
-			int j;
+            int j;
 
-			//printf("listFork->count = %d\n", listFork->count);
+            //printf("listFork->count = %d\n", listFork->count);
 
-			for( j = 0; j < listFork->count ; j++ )
-			{
-				addList(listAlternative, listFork->list[j]);
-			}
+            for (j = 0; j < listFork->count; j++) {
+                addList(listAlternative, listFork->list[j]);
+            }
 
-			listDoEmpty(listFork);
+            listDoEmpty(listFork);
 
-			index = 0;
-		}
+            index = 0;
+        }
 
-		if( listAlternative->count == 0 )
-		{
-			break;
-		}
+        if (listAlternative->count == 0) {
+            break;
+        }
 
-		this = (alternative_t *)listAlternative->list[index];
-		
-		if( ++countDo == 100 )break;
+        this = (alternative_t *) listAlternative->list[index];
 
-		if( this->step > 100 )
-		{
-			delListItem(listAlternative, index, destroyAlternative);
-			countLimit++;
-			index--;
-			continue;
-		}
+        if (++countDo == 100)
+            break;
 
-		moveAlternative(this, w*2);
+        if (this->step > 100) {
+            delListItem(listAlternative, index, destroyAlternative);
+            countLimit++;
+            index--;
+            continue;
+        }
 
-		if( export_fce->fce_isFreeSpace(arena, this->x, this->y, w, h) == 1 )
-		{
-			forkAlternative(listFork, this, 2*w, 2*h);
-			countFork++;
-			continue;
-		}
+        moveAlternative(this, w * 2);
 
-		if( export_fce->fce_conflictSpace(this->x, this->y, w, h, rival_x, rival_y, w, h) )
-		{
-			//printf("this->step = %d\n", this->step);
+        if (export_fce->fce_isFreeSpace(arena, this->x, this->y, w, h) == 1) {
+            forkAlternative(listFork, this, 2 * w, 2 * h);
+            countFork++;
+            continue;
+        }
 
- 			delList(listAlternative, index);
-			addList(listDst, this);
-			index--;
-			//continue;
-			break;
-		}
+        if (export_fce->
+            fce_conflictSpace(this->x, this->y, w, h, rival_x, rival_y, w,
+                              h)) {
+            //printf("this->step = %d\n", this->step);
 
-		if( export_fce->fce_isFreeSpace(arena, this->x, this->y, w, h) == 0 )
-		{
-			//forkAlternative(listFork, this, w*2, h*2);
-			delListItem(listAlternative, index, destroyAlternative);
-			index--;
-			countDel++;
-			
-			continue;
-		}
+            delList(listAlternative, index);
+            addList(listDst, this);
+            index--;
+            //continue;
+            break;
+        }
 
-	}
+        if (export_fce->fce_isFreeSpace(arena, this->x, this->y, w, h) == 0) {
+            //forkAlternative(listFork, this, w*2, h*2);
+            delListItem(listAlternative, index, destroyAlternative);
+            index--;
+            countDel++;
 
-	int minStep = 1000;
-	int recRoute = 0;
+            continue;
+        }
 
-	//printf("------------\n");
-	for( i = 0 ; i < listDst->count ; i++ )
-	{
-		alternative_t *this;
+    }
 
-		this = (alternative_t *)listDst->list[i];
+    int minStep = 1000;
+    int recRoute = 0;
 
-		//printf("XXX step %d route = %d\n", this->step, this->first);
-		if( this->step < minStep )
-		{
-			minStep = this->step;
-			recRoute = this->first;
-		}
-	}
+    //printf("------------\n");
+    for (i = 0; i < listDst->count; i++) {
+        alternative_t *this;
 
-	if( recRoute != 0 )
-	{
-		export_fce->fce_actionTux(tux, recRoute);
-	}
+        this = (alternative_t *) listDst->list[i];
+
+        //printf("XXX step %d route = %d\n", this->step, this->first);
+        if (this->step < minStep) {
+            minStep = this->step;
+            recRoute = this->first;
+        }
+    }
 
-	destroyListItem(listFork, destroyAlternative);
-	destroyListItem(listAlternative, destroyAlternative);
-	destroyListItem(listDst, destroyAlternative);
+    if (recRoute != 0) {
+        export_fce->fce_actionTux(tux, recRoute);
+    }
+
+    destroyListItem(listFork, destroyAlternative);
+    destroyListItem(listAlternative, destroyAlternative);
+    destroyListItem(listDst, destroyAlternative);
 /*
 	printf("countFork = %d\n", countFork);
 	printf("countDel = %d\n", countDel);
@@ -341,48 +336,45 @@ static void eventTuxAI(tux_t *tux)
 */
 }
 
-static void action_tuxAI(space_t *space, tux_t *tux, void *p)
+static void
+action_tuxAI(space_t * space, tux_t * tux, void *p)
 {
-	if( tux->control == TUX_CONTROL_AI &&
-	    tux->status == TUX_STATUS_ALIVE )
-	{
-		eventTuxAI(tux);
-	}
+    if (tux->control == TUX_CONTROL_AI && tux->status == TUX_STATUS_ALIVE) {
+        eventTuxAI(tux);
+    }
 }
 
-int event()
+int
+event()
 {
-	static my_time_t lastEvent = 0;
-	my_time_t curentTime;
-	arena_t *arena;
-	int countTuxAI;
-	//int i;
+    static my_time_t lastEvent = 0;
+    my_time_t curentTime;
+    arena_t *arena;
+    int countTuxAI;
+    //int i;
 
-	if( lastEvent == 0 )
-	{
-		lastEvent = export_fce->fce_getMyTime();
-	}
+    if (lastEvent == 0) {
+        lastEvent = export_fce->fce_getMyTime();
+    }
 
-	curentTime = export_fce->fce_getMyTime();
+    curentTime = export_fce->fce_getMyTime();
 
-	if( curentTime - lastEvent < 25 )
-	{
-		return 0;
-	}
+    if (curentTime - lastEvent < 25) {
+        return 0;
+    }
 
-	lastEvent = export_fce->fce_getMyTime();
-	//printf("event AI\n");
+    lastEvent = export_fce->fce_getMyTime();
+    //printf("event AI\n");
 
-	arena = export_fce->fce_getCurrentArena();
+    arena = export_fce->fce_getCurrentArena();
 
-	if( arena == NULL )
-	{
-		return 0;
-	}
+    if (arena == NULL) {
+        return 0;
+    }
 
-	countTuxAI = 0;
+    countTuxAI = 0;
 
-	actionSpace(arena->spaceTux, action_tuxAI, NULL);
+    actionSpace(arena->spaceTux, action_tuxAI, NULL);
 /*
 	for( i = 0 ; i < arena->spaceTux->list->count ; i++ )
 	{
@@ -398,24 +390,29 @@ int event()
 		}
 	}
 */
-	return 0;
+    return 0;
 }
 
-int isConflict(int x, int y, int w, int h)
+int
+isConflict(int x, int y, int w, int h)
 {
-	return 0;
+    return 0;
 }
 
-void cmdArena(char *line)
+void
+cmdArena(char *line)
 {
-	if( strncmp(line, "ai", 2) == 0 )cmd_ai(line);
+    if (strncmp(line, "ai", 2) == 0)
+        cmd_ai(line);
 }
 
-void recvMsg(char *msg)
+void
+recvMsg(char *msg)
 {
 }
 
-int destroy()
+int
+destroy()
 {
-	return 0;
+    return 0;
 }