- prekopanie adresarovej struktury, prva cast

git-svn-id: http://opensvn.csie.org/tuxanci_ng@77 0ee4d065-81f0-4d1e-b06c-ff20ad07cc3e

5 files changed, 1568 insertions, 0 deletions

diff --git a/src/modules/Makefile b/src/modules/Makefile
new file mode 100755
index 0000000..39e4388
--- /dev/null
+++ b/src/modules/Makefile
@@ -0,0 +1,22 @@
+
+all: modWall.so modPipe.so modTeleport.so modAI.so
+
+modWall.so:
+	gcc $(CFLAGS) -fPIC -c modWall.c -o modWall.o
+	gcc $(CFLAGS) -I../include -shared -fPIC -o modWall.so modWall.o ../base/list.o ../base/space.o
+
+modPipe.so:
+	gcc $(CFLAGS) -fPIC -c modPipe.c -o modPipe.o
+	gcc $(CFLAGS) -I../include -shared -fPIC -o modPipe.so modPipe.o ../base/list.o ../base/space.o
+
+modTeleport.so:
+	gcc $(CFLAGS) -fPIC -c modTeleport.c -o modTeleport.o
+	gcc $(CFLAGS) -I../include -shared -fPIC -o modTeleport.so modTeleport.o ../base/list.o ../base/space.o
+
+modAI.so:
+	gcc $(CFLAGS) -fPIC -c modAI.c -o modAI.o
+	gcc $(CFLAGS) -I../include -shared -fPIC -o modAI.so modAI.o ../base/list.o ../base/space.o
+
+clean:
+	rm -rf *.o 
+	rm -rf *.so
diff --git a/src/modules/modAI.c b/src/modules/modAI.c
new file mode 100755
index 0000000..d3a9f78
--- /dev/null
+++ b/src/modules/modAI.c
@@ -0,0 +1,256 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "base/main.h"
+#include "base/modules.h"
+#include "base/tux.h"
+#include "base/shot.h"
+#include "base/list.h"
+#include "base/gun.h"
+#include "base/space.h"
+
+#ifndef PUBLIC_SERVER
+#include "client/interface.h"
+#include "client/image.h"
+#endif
+
+#ifdef PUBLIC_SERVER
+#include "server/publicServer.h"
+#endif
+
+static export_fce_t *export_fce;
+
+static void cmd_ai(char *line)
+{
+}
+
+int init(export_fce_t *p)
+{
+	export_fce = p;
+
+	return 0;
+}
+
+#ifndef PUBLIC_SERVER
+
+int draw(int x, int y, int w, int h)
+{
+	return 0;
+}
+#endif
+
+/////////////////
+
+int colisionAll(tux_t *tux, int px, int py)
+{
+	arena_t *arena;
+	int x, y, w, h;
+
+	arena = export_fce->fce_getCurrentArena();
+
+	export_fce->fce_getTuxProportion(tux, &x, &y, &w, &h);
+	x += px;
+	y += py;
+
+	return export_fce->fce_isFreeSpace(arena, x, y, w, h);
+}
+
+void gotoTux(tux_t *tux, int x, int y, int w, int h)
+{
+	int px = 0,py = 0;
+	int smer = TUX_DOWN;
+
+	if(tux->x > x+w ) px = -TUX_STEP;
+	if(tux->x < x ) px = +TUX_STEP;
+	if(tux->y > y+h ) py = -TUX_STEP;
+	if(tux->y < y ) py = +TUX_STEP;
+
+	if( px != 0 && py !=0 ) px = 0;
+
+	while( colisionAll(tux, px, 0 ) )
+	{
+		px=0;
+		if(py==0) py = +TUX_STEP;
+		goto sem;
+	}
+
+	while( colisionAll(tux, 0, py ) )
+	{
+		py = 0;
+		if( px == 0 ) px = +TUX_STEP;
+	}
+
+	sem:
+	if( px != 0 && py != 0 ) px = 0;
+
+	if( py== -TUX_STEP )smer = TUX_UP;
+	if( px== +TUX_STEP )smer = TUX_RIGHT;
+	if( px== -TUX_STEP )smer = TUX_LEFT;
+	if( py== +TUX_STEP )smer = TUX_DOWN;
+	
+	//printf("smer=%d\n",smer);
+	export_fce->fce_actionTux(tux, smer);
+}
+
+void gotoTuxShot(tux_t *tux, int x, int y, int w, int h)
+{
+	if( tux->x > x && tux->x < x+w )
+	{
+		if( tux->y > y+h )tux->position = TUX_UP;
+		if( tux->y < y )tux->position = TUX_DOWN;
+	
+		if( colisionAll(tux, 0, 0) == 0 )
+		{
+			if( tux->shot[GUN_SIMPLE] > 0 )tux->gun = GUN_SIMPLE;
+			if( tux->shot[GUN_DUAL_SIMPLE] > 0 )tux->gun = GUN_DUAL_SIMPLE;
+			if( tux->shot[GUN_SCATTER] > 0 )tux->gun = GUN_SCATTER;
+			if( tux->shot[GUN_TOMMY] > 0 )tux->gun = GUN_TOMMY;
+			if( tux->shot[GUN_LASSER] > 0 )tux->gun = GUN_LASSER;
+			if( tux->shot[GUN_BOMBBALL] > 0 )tux->gun = GUN_BOMBBALL;
+
+			export_fce->fce_actionTux(tux, TUX_SHOT);
+		}
+	}
+
+	if( tux->y > y && tux->y < y+h )
+	{
+		if( tux->x > x+w )tux->position=TUX_LEFT;
+		if( tux->x < x )tux->position=TUX_RIGHT;
+
+		if( colisionAll(tux, 0 , 0) == 0 )
+		{
+			if( tux->shot[GUN_SIMPLE] > 0 )tux->gun = GUN_SIMPLE;
+			if( tux->shot[GUN_DUAL_SIMPLE] > 0 )tux->gun = GUN_DUAL_SIMPLE;
+			if( tux->shot[GUN_SCATTER] > 0 )tux->gun = GUN_SCATTER;
+			if( tux->shot[GUN_TOMMY] > 0 )tux->gun = GUN_TOMMY;
+			if( tux->shot[GUN_LASSER] > 0 )tux->gun = GUN_LASSER;
+			if( tux->shot[GUN_BOMBBALL] > 0 )tux->gun = GUN_BOMBBALL;
+
+			export_fce->fce_actionTux(tux, TUX_SHOT);
+		}
+	}
+}
+
+void killTux(tux_t *tux, int active)
+{
+	arena_t *arena;
+	int i;
+
+	arena = export_fce->fce_getCurrentArena();
+
+	for( i = 0 ; i < arena->spaceTux->list->count ; i++ )
+	{
+		tux_t *thisTux;
+
+		thisTux = arena->spaceTux->list->list[i];
+
+		if( thisTux->control != TUX_CONTROL_KEYBOARD_LEFT &&
+		    thisTux->status == TUX_STATUS_ALIVE )
+		{
+			gotoTuxShot(tux, thisTux->x, thisTux->y,
+					TUX_WIDTH, TUX_HEIGHT);
+
+			if( active )
+			{
+				gotoTux(tux, thisTux->x, thisTux->y,
+				TUX_WIDTH, TUX_HEIGHT);
+
+				gotoTuxShot(tux, thisTux->x, thisTux->y,
+				TUX_WIDTH, TUX_HEIGHT);
+
+				break;
+			}
+		}
+	}
+}
+
+/////////////////
+
+static void eventTux(tux_t *tux)
+{
+	arena_t *arena;
+	item_t *item;
+
+	arena = export_fce->fce_getCurrentArena();
+
+	killTux(tux, 0);
+
+	item = NULL;
+
+	if( arena->spaceItem->list->count > 0  )
+	{
+		item = (item_t *) arena->spaceItem->list->list[0];
+	}
+
+	if( item != NULL && 
+	    item->type != GUN_MINE )
+	{
+		gotoTux(tux, item->x, item->y,
+		item->w, item->h);
+	}
+	else
+	{
+		killTux(tux, 1);
+	}
+}
+
+int event()
+{
+	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();
+	}
+
+	curentTime = export_fce->fce_getMyTime();
+
+	if( curentTime - lastEvent < 25 )
+	{
+		return 0;
+	}
+
+	lastEvent = export_fce->fce_getMyTime();
+	//printf("event AI\n");
+
+	arena = export_fce->fce_getCurrentArena();
+	countTuxAI = 0;
+
+	for( i = 0 ; i < arena->spaceTux->list->count ; i++ )
+	{
+		tux_t *thisTux;
+
+		thisTux = arena->spaceTux->list->list[i];
+
+		if( thisTux->control == TUX_CONTROL_AI &&
+		    thisTux->status == TUX_STATUS_ALIVE )
+		{
+			eventTux(thisTux);
+			countTuxAI = 0;
+		}
+	}
+
+	return 0;
+}
+
+int isConflict(int x, int y, int w, int h)
+{
+	return 0;
+}
+
+void cmd(char *line)
+{
+	if( strncmp(line, "ai", 2) == 0 )cmd_ai(line);
+}
+
+int destroy()
+{
+	return 0;
+}
diff --git a/src/modules/modPipe.c b/src/modules/modPipe.c
new file mode 100755
index 0000000..77f2c05
--- /dev/null
+++ b/src/modules/modPipe.c
@@ -0,0 +1,453 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "base/main.h"
+#include "base/modules.h"
+#include "base/tux.h"
+#include "base/shot.h"
+#include "base/list.h"
+#include "base/gun.h"
+#include "base/space.h"
+
+#ifndef PUBLIC_SERVER
+#include "client/interface.h"
+#include "client/image.h"
+#endif
+
+#ifdef PUBLIC_SERVER
+#include "server/publicServer.h"
+#endif
+
+typedef struct pipe_struct
+{
+	int x; // poloha steny	
+	int y;
+
+	int w; // rozmery steny
+	int h;
+
+	int id;
+	int id_out;
+	int position;
+
+	int layer; // vrstva
+
+#ifndef PUBLIC_SERVER	
+	SDL_Surface *img; //obrazok
+#endif
+} pipe_t;
+
+static export_fce_t *export_fce;
+
+static list_t *listPipe;
+static space_t *spacePipe;
+
+#ifndef PUBLIC_SERVER	
+static pipe_t* newPipe(int x, int y, int w, int h, int layer, int id, int id_out, int position, SDL_Surface *img)
+#endif
+
+#ifdef PUBLIC_SERVER	
+static pipe_t* newPipe(int x, int y, int w, int h, int layer, int id, int id_out, int position)
+#endif
+
+{
+	pipe_t *new;
+	
+#ifndef PUBLIC_SERVER	
+	assert( img != NULL );
+#endif
+
+	new  = malloc( sizeof(pipe_t) );
+	assert( new != NULL );
+
+	new->x = x;
+	new->y = y;
+	new->w = w;
+	new->h = h;
+	new->layer = layer;
+	new->id = id;
+	new->id_out = id_out;
+	new->position = position;
+#ifndef PUBLIC_SERVER	
+	new->img = img;
+#endif
+	return new;
+}
+
+static void setStatusPipe(void *p, int x, int y, int w, int h)
+{
+	pipe_t *pipe;
+
+	pipe = p;
+
+	pipe->x = x;
+	pipe->y = y;
+	pipe->w = w;
+	pipe->h = h;
+}
+
+static void getStatusPipe(void *p, int *id, int *x, int *y, int *w, int *h)
+{
+	pipe_t *pipe;
+
+	pipe = p;
+
+	*id = pipe->id;
+	*x = pipe->x;
+	*y = pipe->y;
+	*w = pipe->w;
+	*h = pipe->h;
+}
+
+#ifndef PUBLIC_SERVER	
+
+static void drawPipe(pipe_t *p)
+{
+	assert( p != NULL );
+
+	export_fce->fce_addLayer(p->img, p->x, p->y, 0, 0, p->img->w, p->img->h, p->layer);
+}
+
+#endif
+
+static void destroyPipe(pipe_t *p)
+{
+	assert( p != NULL );
+	free(p);
+}
+
+
+static void cmd_teleport(char *line)
+{
+	char str_x[STR_NUM_SIZE];
+	char str_y[STR_NUM_SIZE];
+	char str_w[STR_NUM_SIZE];
+	char str_h[STR_NUM_SIZE];
+	char str_id[STR_NUM_SIZE];
+	char str_id_out[STR_NUM_SIZE];
+	char str_position[STR_NUM_SIZE];
+	char str_layer[STR_NUM_SIZE];
+	char str_image[STR_SIZE];
+	pipe_t *new;
+
+	if( export_fce->fce_getValue(line, "x", str_x, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "y", str_y, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "w", str_w, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "h", str_h, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "id", str_id, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "id_out", str_id_out, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "position", str_position, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "layer", str_layer, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "image", str_image, STR_SIZE) != 0 )return;
+
+#ifndef PUBLIC_SERVER
+	new = newPipe(atoi(str_x), atoi(str_y),
+			atoi(str_w), atoi(str_h),
+			atoi(str_layer), atoi(str_id), atoi(str_id_out), atoi(str_position),
+			export_fce->fce_getImage(IMAGE_GROUP_USER, str_image) );
+#endif
+
+#ifdef PUBLIC_SERVER
+	new = newPipe(atoi(str_x), atoi(str_y),
+			atoi(str_w), atoi(str_h),
+			atoi(str_layer), atoi(str_id), atoi(str_id_out), atoi(str_position) );
+#endif
+
+	if( spacePipe == NULL )
+	{
+		spacePipe  = newSpace(export_fce->fce_getCurrentArena()->w, export_fce->fce_getCurrentArena()->h,
+				320, 240, getStatusPipe, setStatusPipe);
+	}
+
+	addObjectToSpace(spacePipe, new);
+}
+
+static int myAbs(int n)
+{
+	return ( n > 0 ? n : -n );
+}
+
+
+static int getSppedShot(shot_t *shot)
+{
+	return ( myAbs(shot->px) > myAbs(shot->py) ? myAbs(shot->px) : myAbs(shot->py) );
+}
+
+static void transformShot(shot_t *shot, int position)
+{
+	int speed;
+
+	speed = getSppedShot(shot);
+
+	switch( position )
+	{
+		case TUX_UP :
+			shot->px = 0;
+			shot->py = -speed;
+		break;
+
+		case TUX_LEFT :
+			shot->px = -speed;
+			shot->py = 0;
+		break;
+
+		case TUX_RIGHT :
+			shot->px = speed;
+			shot->py = 0;
+		break;
+
+		case TUX_DOWN :
+			shot->px = 0;
+			shot->py = +speed;
+		break;
+	}
+
+	shot->position = position;	
+	shot->isCanKillAuthor = TRUE;
+
+	if( shot->gun == GUN_LASSER )
+	{
+		export_fce->fce_transformOnlyLasser(shot);
+	}
+}
+
+static void moveShot(shot_t *shot, int position, int src_x, int src_y,
+	int dist_x, int dist_y, int dist_w, int dist_h)
+{
+	int offset = 0;
+	int new_x, new_y;
+
+	switch( shot->position )
+	{
+		case TUX_UP :
+		case TUX_DOWN :
+			offset = shot->x - src_x;
+		break;
+
+		case TUX_RIGHT :
+		case TUX_LEFT :
+			offset = shot->y - src_y;
+		break;
+	}
+
+	transformShot(shot, position);
+
+	switch( shot->position )
+	{
+		case TUX_UP :
+			new_x = dist_x + offset;
+			new_y = dist_y;
+		break;
+
+		case TUX_LEFT :
+			new_x = dist_x;
+			new_y = dist_y + offset;
+		break;
+
+		case TUX_RIGHT :
+			new_x = dist_x + dist_w;
+			new_y = dist_y + offset;
+		break;
+
+		case TUX_DOWN :
+			new_x = dist_x + offset;
+			new_y = dist_y + dist_h;
+		break;
+	}
+
+	new_y += shot->px;
+	new_y += shot->py;
+
+	moveObjectInSpace(export_fce->fce_getCurrentArena()->spaceShot, shot, new_x, new_y);
+
+	if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_SERVER )
+	{
+		export_fce->fce_proto_send_shot_server(PROTO_SEND_ALL, NULL, shot);
+	}
+}
+
+static void moveShotFromPipe(shot_t *shot, pipe_t *pipe)
+{
+	pipe_t *distPipe;
+
+	distPipe = getObjectFromSpaceWithID(spacePipe, pipe->id_out);
+
+	if( distPipe == NULL )
+	{
+		fprintf(stderr, "Pipe %d ID not found\n", pipe->id);
+		return;
+	}
+
+	moveShot(shot, distPipe->position, pipe->x, pipe->y,
+		distPipe->x, distPipe->y, distPipe->w, distPipe->h);
+}
+
+int init(export_fce_t *p)
+{
+	export_fce = p;
+
+	listPipe = newList();
+
+	return 0;
+}
+
+#ifndef PUBLIC_SERVER
+
+int draw(int x, int y, int w, int h)
+{
+	pipe_t *thisPipe;
+	int i;
+
+	if( spacePipe == NULL )
+	{
+		return 0;
+	}
+
+	listDoEmpty(listPipe);
+	getObjectFromSpace(spacePipe, x, y, w, h, listPipe);
+	//printSpace(spacePipe);
+
+	for( i = 0 ; i < listPipe->count ; i++ )
+	{
+		thisPipe  = (pipe_t *)listPipe->list[i];
+		assert( thisPipe != NULL );
+		drawPipe(thisPipe);
+	}
+
+	return 0;
+}
+#endif
+
+static int negPosition(int n)
+{
+	switch( n )
+	{
+		case TUX_UP :
+		return TUX_DOWN;
+
+		case TUX_LEFT :
+		return TUX_RIGHT;
+
+		case TUX_RIGHT :
+		return TUX_LEFT;
+
+		case TUX_DOWN :
+		return TUX_UP;
+
+		default :
+			assert( ! "premenna n ma zlu hodnotu !" );
+		break;
+	}
+}
+
+int event()
+{
+	pipe_t *thisPipe;
+	arena_t *arena;
+	int i;
+
+	if( spacePipe == NULL )
+	{
+		return 0;
+	}
+
+/*
+	if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+	{
+		return;
+	}
+*/
+	arena = export_fce->fce_getCurrentArena();
+
+	for( i = 0 ; i < arena->spaceShot->list->count ; i++ )
+	{
+		shot_t *thisShot;
+		int j;
+
+		thisShot  = (shot_t *) arena->spaceShot->list->list[i];
+		assert( thisShot != NULL );
+
+		listDoEmpty(listPipe);
+		getObjectFromSpace(spacePipe, thisShot->x, thisShot->y, thisShot->w, thisShot->h, listPipe);
+
+		for( j = 0 ; j < listPipe->count ; j++ )
+		{
+			tux_t *author;
+
+			thisPipe = (pipe_t *)listPipe->list[j];
+
+			author = getObjectFromSpaceWithID(arena->spaceTux, thisShot->author_id);
+			
+			if( author != NULL &&
+			    author->bonus == BONUS_GHOST &&
+			    author->bonus_time > 0 )
+			{
+				continue;
+			}
+
+			if( negPosition( thisShot->position ) == thisPipe->position )
+			{
+				//moveShotFromPipe(thisShot, thisPipe, listPipe);
+
+				if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+				{
+					if( thisShot->gun != GUN_BOMBBALL )
+					{
+						delObjectFromSpaceWithObject(export_fce->fce_getCurrentArena()->spaceShot,
+							thisShot, export_fce->fce_destroyShot);
+						//delListItem(arena->listShot, i, export_fce->fce_destroyShot);
+						i--;
+					}
+				}
+				else
+				{
+					moveShotFromPipe(thisShot, thisPipe);
+				}
+
+			}
+			else
+			{
+				if( thisShot->gun == GUN_BOMBBALL && 
+				    export_fce->fce_getNetTypeGame() != NET_GAME_TYPE_CLIENT  )
+				{
+					export_fce->fce_boundBombBall(thisShot);
+					continue;
+				}
+				else
+				{
+					delObjectFromSpaceWithObject(export_fce->fce_getCurrentArena()->spaceShot,
+						thisShot, export_fce->fce_destroyShot);
+					i--;
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+int isConflict(int x, int y, int w, int h)
+{
+	if( spacePipe == NULL )
+	{
+		return 0;
+	}
+
+	return isConflictWithObjectFromSpace(spacePipe, x, y, w, h);
+}
+
+void cmd(char *line)
+{
+	if( strncmp(line, "pipe", 4) == 0 )cmd_teleport(line);
+}
+
+int destroy()
+{
+	destroySpaceWithObject(spacePipe, destroyPipe);
+	destroyList(listPipe);
+
+	return 0;
+}
diff --git a/src/modules/modTeleport.c b/src/modules/modTeleport.c
new file mode 100755
index 0000000..724e371
--- /dev/null
+++ b/src/modules/modTeleport.c
@@ -0,0 +1,506 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "base/main.h"
+#include "base/modules.h"
+#include "base/tux.h"
+#include "base/shot.h"
+#include "base/list.h"
+#include "base/gun.h"
+#include "base/space.h"
+
+#ifndef PUBLIC_SERVER
+#include "client/interface.h"
+#include "client/image.h"
+#endif
+
+#ifdef PUBLIC_SERVER
+#include "server/publicServer.h"
+#endif
+
+typedef struct teleport_struct
+{
+	int id;
+
+	int x; // poloha steny	
+	int y;
+
+	int w; // rozmery steny
+	int h;
+
+	int layer; // vrstva
+
+#ifndef PUBLIC_SERVER	
+	SDL_Surface *img; //obrazok
+#endif
+} teleport_t;
+
+static export_fce_t *export_fce;
+
+static space_t *spaceTeleport;
+static list_t *listTeleport;
+
+#ifndef PUBLIC_SERVER	
+teleport_t* newTeleport(int x, int y, int w, int h, int layer, SDL_Surface *img)
+#endif
+
+#ifdef PUBLIC_SERVER	
+teleport_t* newTeleport(int x, int y, int w, int h, int layer)
+#endif
+{
+	static int last_id = 0;
+
+	teleport_t *new;
+	
+#ifndef PUBLIC_SERVER	
+	assert( img != NULL );
+#endif
+
+	new  = malloc( sizeof(teleport_t) );
+	assert( new != NULL );
+
+	new->id = ++last_id;
+	new->x = x;
+	new->y = y;
+	new->w = w;
+	new->h = h;
+	new->layer = layer;
+#ifndef PUBLIC_SERVER	
+	new->img = img;
+#endif
+
+	return new;
+}
+
+static void setStatusTeleport(void *p, int x, int y, int w, int h)
+{
+	teleport_t *teleport;
+
+	teleport = p;
+
+	teleport->x = x;
+	teleport->y = y;
+	teleport->w = w;
+	teleport->h = h;
+}
+
+static void getStatusTeleport(void *p, int *id, int *x, int *y, int *w, int *h)
+{
+	teleport_t *teleport;
+	teleport = p;
+
+	*id = teleport->id;
+	*x = teleport->x;
+	*y = teleport->y;
+	*w = teleport->w;
+	*h = teleport->h;
+}
+
+#ifndef PUBLIC_SERVER
+
+static void drawTeleport(teleport_t *p)
+{
+	assert( p != NULL );
+
+	export_fce->fce_addLayer(p->img, p->x, p->y, 0, 0, p->img->w, p->img->h, p->layer);
+}
+
+#endif
+
+static void destroyTeleport(teleport_t *p)
+{
+	assert( p != NULL );
+	free(p);
+}
+
+
+static void cmd_teleport(char *line)
+{
+	char str_x[STR_NUM_SIZE];
+	char str_y[STR_NUM_SIZE];
+	char str_w[STR_NUM_SIZE];
+	char str_h[STR_NUM_SIZE];
+	char str_layer[STR_NUM_SIZE];
+	char str_image[STR_SIZE];
+	teleport_t *new;
+
+	if( export_fce->fce_getValue(line, "x", str_x, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "y", str_y, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "w", str_w, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "h", str_h, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "layer", str_layer, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "image", str_image, STR_SIZE) != 0 )return;
+
+#ifndef PUBLIC_SERVER
+	new = newTeleport(atoi(str_x), atoi(str_y),
+			atoi(str_w), atoi(str_h),
+			atoi(str_layer), export_fce->fce_getImage(IMAGE_GROUP_USER, str_image) );
+#endif
+
+#ifdef PUBLIC_SERVER
+	new = newTeleport(atoi(str_x), atoi(str_y),
+			atoi(str_w), atoi(str_h),
+			atoi(str_layer) );
+#endif
+
+	if( spaceTeleport == NULL )
+	{
+		spaceTeleport  = newSpace(export_fce->fce_getCurrentArena()->w, export_fce->fce_getCurrentArena()->h,
+				320, 240, getStatusTeleport, setStatusTeleport);
+	}
+
+	addObjectToSpace(spaceTeleport, new);
+}
+
+static teleport_t* getRandomTeleportBut(list_t *list, teleport_t *teleport)
+{
+	int x;
+
+	do{
+		x = random() % list->count;
+	}while( list->list[x] == teleport );
+
+	return (teleport_t *) list->list[x];
+}
+
+static int getRandomPosition()
+{
+	switch( random() % 4 )
+	{
+		case 0 :
+		return TUX_UP;
+
+		case 1 :
+		return TUX_LEFT;
+
+		case 2 :
+		return TUX_RIGHT;
+
+		case 3 :
+		return TUX_DOWN;
+	}
+
+	assert( ! "Stupid error ! " );
+}
+
+static void teleportTux(tux_t *tux, teleport_t *teleport)
+{
+	teleport_t *distTeleport;
+	int dist_x, dist_y;
+
+	if( tux->bonus == BONUS_GHOST ||
+	    export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+	{
+		return;
+	}
+
+	distTeleport = getRandomTeleportBut(spaceTeleport->list, teleport);
+	
+	//export_fce->fce_getTuxProportion(tux, &current_x, &current_y, NULL, NULL);
+	
+	switch( tux->position )
+	{
+		case TUX_UP :
+			dist_x = distTeleport->x + distTeleport->w/2;
+			dist_y = distTeleport->y - ( TUX_HEIGHT + 20 );
+		break;
+		case TUX_LEFT :
+			dist_x = distTeleport->x - ( TUX_WIDTH + 20 );
+			dist_y = distTeleport->y + distTeleport->h/2;
+		break;
+	
+		case TUX_RIGHT :
+			dist_x = distTeleport->x + distTeleport->w + 20;
+			dist_y = distTeleport->y + distTeleport->h/2;
+		break;
+	
+		case TUX_DOWN :
+			dist_x = distTeleport->x + distTeleport->w/2;
+			dist_y = distTeleport->y + distTeleport->h + 20;
+		break;
+	
+		default :
+			assert( ! "premenna p->control ma zlu hodnotu !" );
+		break;
+	}
+	
+	if( export_fce->fce_isFreeSpace(export_fce->fce_getCurrentArena(), dist_x, dist_y, TUX_WIDTH, TUX_HEIGHT) )
+	{
+		moveObjectInSpace(export_fce->fce_getCurrentArena()->spaceTux, tux, dist_x, dist_y);
+		//export_fce->fce_setTuxProportion(tux, dist_x, dist_y);
+#ifndef PUBLIC_SERVER
+		//playSound("teleport", SOUND_GROUP_BASE);
+#endif
+		if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_SERVER )
+		{
+			export_fce->fce_proto_send_newtux_server(PROTO_SEND_ALL, NULL, tux);
+		}
+	}
+}
+
+static int myAbs(int n)
+{
+	return ( n > 0 ? n : -n );
+}
+
+
+static int getSppedShot(shot_t *shot)
+{
+	return ( myAbs(shot->px) > myAbs(shot->py) ? myAbs(shot->px) : myAbs(shot->py) );
+}
+
+/*
+static void transformOnlyLasser(shot_t *shot)
+{
+	switch( shot->position )
+	{
+		case TUX_RIGHT :
+		case TUX_LEFT :
+			shot->w = GUN_LASSER_HORIZONTAL; 
+			shot->h = GUN_SHOT_VERTICAL; 
+#ifndef PUBLIC_SERVER	
+			shot->img = g_shot_lasserX;
+#endif
+		break;
+		case TUX_UP :
+		case TUX_DOWN :
+			shot->w = GUN_SHOT_VERTICAL; 
+			shot->h = GUN_LASSER_HORIZONTAL; 
+#ifndef PUBLIC_SERVER	
+			shot->img = g_shot_lasserY;
+#endif
+		break;
+	}
+}
+*/
+
+static void transformShot(shot_t *shot, int position)
+{
+	int speed;
+
+	speed = getSppedShot(shot);
+
+	switch( position )
+	{
+		case TUX_UP :
+			shot->px = 0;
+			shot->py = -speed;
+		break;
+
+		case TUX_LEFT :
+			shot->px = -speed;
+			shot->py = 0;
+		break;
+
+		case TUX_RIGHT :
+			shot->px = speed;
+			shot->py = 0;
+		break;
+
+		case TUX_DOWN :
+			shot->px = 0;
+			shot->py = +speed;
+		break;
+	}
+
+	shot->position = position;	
+	shot->isCanKillAuthor = TRUE;
+
+	if( shot->gun == GUN_LASSER )
+	{
+		export_fce->fce_transformOnlyLasser(shot);
+	}
+}
+
+static void moveShot(shot_t *shot, int position, int src_x, int src_y,
+	int dist_x, int dist_y, int dist_w, int dist_h)
+{
+	int offset = 0;
+	int new_x, new_y;
+
+	switch( shot->position )
+	{
+		case TUX_UP :
+		case TUX_DOWN :
+			offset = shot->x - src_x;
+		break;
+
+		case TUX_RIGHT :
+		case TUX_LEFT :
+			offset = shot->y - src_y;
+		break;
+	}
+
+	transformShot(shot, position);
+
+	switch( shot->position )
+	{
+		case TUX_UP :
+			new_x = dist_x + offset;
+			new_y = dist_y;
+		break;
+
+		case TUX_LEFT :
+			new_x = dist_x;
+			new_y = dist_y + offset;
+		break;
+
+		case TUX_RIGHT :
+			new_x = dist_x + dist_w;
+			new_y = dist_y + offset;
+		break;
+
+		case TUX_DOWN :
+			new_x = dist_x + offset;
+			new_y = dist_y + dist_h;
+		break;
+	}
+
+	new_y += shot->px;
+	new_y += shot->py;
+
+	moveObjectInSpace(export_fce->fce_getCurrentArena()->spaceShot, shot, new_x, new_y);
+
+	if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_SERVER )
+	{
+		export_fce->fce_proto_send_shot_server(PROTO_SEND_ALL, NULL, shot);
+	}
+}
+
+static void moveShotFromTeleport(shot_t *shot, teleport_t *teleport, list_t *list)
+{
+	teleport_t *distTeleport;
+
+	distTeleport = getRandomTeleportBut(list, teleport);
+
+	moveShot(shot, getRandomPosition(), teleport->x, teleport->y,
+		distTeleport->x, distTeleport->y, distTeleport->w, distTeleport->h);
+}
+
+int init(export_fce_t *p)
+{
+	export_fce = p;
+
+	listTeleport = newList();
+
+	return 0;
+}
+
+#ifndef PUBLIC_SERVER
+int draw(int x, int y, int w, int h)
+{
+	teleport_t *thisTeleport;
+	int i;
+
+	if( spaceTeleport == NULL )
+	{
+		return 0;
+	}
+
+	listDoEmpty(listTeleport);
+	getObjectFromSpace(spaceTeleport, x, y, w, h, listTeleport);
+
+	for( i = 0 ; i < listTeleport->count ; i++ )
+	{
+		thisTeleport  = (teleport_t *)listTeleport->list[i];
+		assert( thisTeleport != NULL );
+		drawTeleport(thisTeleport);
+	}
+
+	return 0;
+}
+#endif
+
+int event()
+{
+	teleport_t *thisTeleport;
+	arena_t *arena;
+	int i;
+
+	if( spaceTeleport == NULL )
+	{
+		return 0;
+	}
+
+	if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+	{
+		return 0;
+	}
+
+	arena = export_fce->fce_getCurrentArena();
+
+	for( i = 0 ; i < arena->spaceTux->list->count ; i++ )
+	{
+		tux_t *thisTux;
+		int x, y, w, h;
+		int j;
+
+		thisTux = (tux_t *)arena->spaceTux->list->list[i];
+		export_fce->fce_getTuxProportion(thisTux, &x, &y, &w, &h);
+
+		listDoEmpty(listTeleport);
+		getObjectFromSpace(spaceTeleport, x, y, w, h, listTeleport);
+
+		for( j = 0 ; j < listTeleport->count ; j++ )
+		{
+			thisTeleport = (teleport_t *)listTeleport->list[j];
+			teleportTux(thisTux, thisTeleport);
+		}
+	}
+	
+	for( i = 0 ; i < arena->spaceShot->list->count ; i++ )
+	{
+		shot_t *thisShot;
+		int j;
+
+		thisShot  = (shot_t *)arena->spaceShot->list->list[i];
+		assert( thisShot != NULL );
+
+		listDoEmpty(listTeleport);
+		getObjectFromSpace(spaceTeleport, thisShot->x, thisShot->y, thisShot->w, thisShot->h, listTeleport);
+
+		for( j = 0 ; j < listTeleport->count ; j++ )
+		{
+			tux_t *author;
+
+			thisTeleport = (teleport_t *)listTeleport->list[j];
+			author = getObjectFromSpaceWithID(arena->spaceTux, thisShot->author_id);
+			
+			if( author != NULL && 
+			    author->bonus == BONUS_GHOST &&
+			    author->bonus_time > 0 )
+			{
+				continue;
+			}
+
+			moveShotFromTeleport(thisShot, thisTeleport, spaceTeleport->list);
+		}
+	}
+
+	return 0;
+}
+
+int isConflict(int x, int y, int w, int h)
+{
+	if( spaceTeleport == NULL )
+	{
+		return 0;
+	}
+
+	return 0;
+}
+
+void cmd(char *line)
+{
+	if( strncmp(line, "teleport", 8) == 0 )cmd_teleport(line);
+}
+
+int destroy()
+{
+	destroySpaceWithObject(spaceTeleport, destroyTeleport);
+	destroyList(listTeleport);
+	return 0;
+}
diff --git a/src/modules/modWall.c b/src/modules/modWall.c
new file mode 100755
index 0000000..c5e01ce
--- /dev/null
+++ b/src/modules/modWall.c
@@ -0,0 +1,331 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "base/main.h"
+#include "base/modules.h"
+#include "base/tux.h"
+#include "base/shot.h"
+#include "base/list.h"
+#include "base/gun.h"
+#include "base/space.h"
+
+#ifndef PUBLIC_SERVER
+#include "client/interface.h"
+#include "client/image.h"
+#endif
+
+#ifdef PUBLIC_SERVER
+#include "server/publicServer.h"
+#endif
+
+typedef struct wall_struct
+{
+	int id;
+
+	int x; // poloha steny	
+	int y;
+
+	int w; // rozmery steny
+	int h;
+
+	int img_x; // poloha obrazka
+	int img_y;
+
+	int layer; // vrstva
+
+#ifndef PUBLIC_SERVER	
+	SDL_Surface *img; //obrazok
+#endif
+} wall_t;
+
+static export_fce_t *export_fce;
+
+static space_t *spaceWall;
+
+#ifndef PUBLIC_SERVER	
+static space_t *spaceImgWall;
+#endif
+
+static list_t *listWall;
+
+#ifndef PUBLIC_SERVER	
+wall_t* newWall(int x, int y, int w, int h,
+	int img_x, int img_y, int layer, SDL_Surface *img)
+#endif
+
+#ifdef PUBLIC_SERVER	
+wall_t* newWall(int x, int y, int w, int h,
+	int img_x, int img_y, int layer)
+#endif
+{
+	static int last_id = 0;
+	wall_t *new;
+	
+#ifndef PUBLIC_SERVER	
+	assert( img != NULL );
+#endif
+	new  = malloc( sizeof(wall_t) );
+	assert( new != NULL );
+
+	new->id = ++last_id;
+	new->x = x;
+	new->y = y;
+	new->w = w;
+	new->h = h;
+	new->img_x = img_x;
+	new->img_y = img_y;
+	new->layer = layer;
+#ifndef PUBLIC_SERVER
+	new->img = img;
+#endif
+
+	return new;
+}
+
+#ifndef PUBLIC_SERVER	
+
+void drawWall(wall_t *p)
+{
+	assert( p != NULL );
+
+	export_fce->fce_addLayer(p->img, p->img_x, p->img_y, 0, 0, p->img->w, p->img->h, p->layer);
+}
+
+void drawListWall(list_t *list)
+{
+	wall_t *thisWall;
+	int i;
+
+	assert( list != NULL );
+
+	for( i = 0 ; i < list->count ; i++ )
+	{
+		thisWall  = (wall_t *)list->list[i];
+		assert( thisWall != NULL );
+		drawWall(thisWall);
+	}
+}
+
+#endif
+
+void eventConflictShotWithWall()
+{
+	arena_t *arena;
+	shot_t *thisShot;
+	tux_t *author;
+	int i;
+
+	arena = export_fce->fce_getCurrentArena();
+
+	for( i = 0 ; i < arena->spaceShot->list->count ; i++ )
+	{
+		thisShot  = (shot_t *)arena->spaceShot->list->list[i];
+		assert( thisShot != NULL );
+
+		if( isConflictWithObjectFromSpace(spaceWall, thisShot->x, thisShot->y, thisShot->w, thisShot->h) )
+		{
+			author = getObjectFromSpaceWithID(
+				export_fce->fce_getCurrentArena()->spaceTux, thisShot->author_id );
+			
+			if( author != NULL &&
+			    author->bonus == BONUS_GHOST &&
+			    author->bonus_time > 0 )
+			{
+				continue;
+			}
+
+			if( thisShot->gun == GUN_BOMBBALL && export_fce->fce_getNetTypeGame() != NET_GAME_TYPE_CLIENT )
+			{
+				export_fce->fce_boundBombBall(thisShot);
+				continue;
+			}
+
+			delObjectFromSpaceWithObject(export_fce->fce_getCurrentArena()->spaceShot,
+				thisShot, export_fce->fce_destroyShot);
+			
+			//delListItem(listShot, i, export_fce->fce_destroyShot);
+			i--;
+		}
+	}
+}
+
+void destroyWall(wall_t *p)
+{
+	assert( p != NULL );
+	free(p);
+}
+
+static void getStatusWall(void *p, int *id, int *x, int *y, int *w, int *h)
+{
+	wall_t *wall;
+
+	wall = p;
+
+	*id = wall->id;
+	*x = wall->x;
+	*y = wall->y;
+	*w = wall->w;
+	*h = wall->h;
+}
+
+static void setStatusWall(void *p, int x, int y, int w, int h)
+{
+	wall_t *wall;
+
+	wall = p;
+
+	wall->x = x;
+	wall->y = y;
+	wall->w = w;
+	wall->h = h;
+}
+
+#ifndef PUBLIC_SERVER	
+
+static void getStatusImgWall(void *p, int *id, int *x, int *y, int *w, int *h)
+{
+	wall_t *wall;
+
+	wall = p;
+
+	*id = wall->id;
+	*x = wall->img_x;
+	*y = wall->img_y;
+	*w = wall->img->w;
+	*h = wall->img->h;
+}
+
+static void setStatusImgWall(void *p, int x, int y, int w, int h)
+{
+}
+
+#endif
+
+static void cmd_wall(char *line)
+{
+	char str_x[STR_NUM_SIZE];
+	char str_y[STR_NUM_SIZE];
+	char str_img_x[STR_NUM_SIZE];
+	char str_img_y[STR_NUM_SIZE];
+	char str_w[STR_NUM_SIZE];
+	char str_h[STR_NUM_SIZE];
+	char str_layer[STR_NUM_SIZE];
+	char str_image[STR_SIZE];
+	wall_t *new;
+
+	if( export_fce->fce_getValue(line, "x", str_x, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "y", str_y, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "w", str_w, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "h", str_h, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "img_x", str_img_x, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "img_y", str_img_y, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "layer", str_layer, STR_NUM_SIZE) != 0 )return;
+	if( export_fce->fce_getValue(line, "image", str_image, STR_SIZE) != 0 )return;
+
+#ifndef PUBLIC_SERVER
+	new = newWall(atoi(str_x), atoi(str_y),
+			atoi(str_w), atoi(str_h),
+			atoi(str_img_x), atoi(str_img_y),
+			atoi(str_layer), export_fce->fce_getImage(IMAGE_GROUP_USER, str_image) );
+#endif
+
+#ifdef PUBLIC_SERVER
+	new = newWall(atoi(str_x), atoi(str_y),
+			atoi(str_w), atoi(str_h),
+			atoi(str_img_x), atoi(str_img_y),
+			atoi(str_layer) );
+#endif
+
+	if( spaceWall == NULL )
+	{
+		spaceWall  = newSpace(export_fce->fce_getCurrentArena()->w, export_fce->fce_getCurrentArena()->h,
+				320, 240, getStatusWall, setStatusWall);
+
+#ifndef PUBLIC_SERVER	
+		spaceImgWall  = newSpace(export_fce->fce_getCurrentArena()->w, export_fce->fce_getCurrentArena()->h,
+				320, 240, getStatusImgWall, setStatusImgWall);
+#endif
+	}
+
+	addObjectToSpace(spaceWall, new);
+
+#ifndef PUBLIC_SERVER	
+	addObjectToSpace(spaceImgWall, new);
+#endif
+}
+
+int init(export_fce_t *p)
+{
+	export_fce = p;
+	listWall = newList();
+
+	return 0;
+}
+
+#ifndef PUBLIC_SERVER
+
+int draw(int x, int y, int w, int h)
+{
+	wall_t *thisWall;
+	int i;
+
+	if( spaceWall == NULL )
+	{
+		return 0;
+	}
+
+	listDoEmpty(listWall);
+	getObjectFromSpace(spaceImgWall, x, y, w, h, listWall);
+
+	for( i = 0 ; i < listWall->count ; i++ )
+	{
+		thisWall  = (wall_t *)listWall->list[i];
+		assert( thisWall != NULL );
+		drawWall(thisWall);
+	}
+
+	//printSpace(spaceWall);
+
+	return 0;
+}
+#endif
+
+
+int event()
+{
+	if( spaceWall == NULL )
+	{
+		return 0;
+	}
+
+	eventConflictShotWithWall(export_fce->fce_getCurrentArena()->spaceShot->list);
+	return 0;
+}
+
+int isConflict(int x, int y, int w, int h)
+{
+	if( spaceWall == NULL )
+	{
+		return 0;
+	}
+
+	return isConflictWithObjectFromSpace(spaceWall, x, y, w, h);
+}
+
+void cmd(char *line)
+{
+	if( strncmp(line, "wall", 4) == 0 )cmd_wall(line);
+}
+
+int destroy()
+{
+	destroySpaceWithObject(spaceWall, destroyWall);
+#ifndef PUBLIC_SERVER	
+	destroySpace(spaceImgWall);
+#endif
+	destroyList(listWall);
+	return 0;
+}