- podpora modulov

- hra sa musi kompilovat s GUI ako
  v config.h _zakomenotvane_ #define PUBLIC_SERVER
  make clean
  make
  make mod
  su
  make install

- hra sa musi ako server kompilovat
  v config.h _odkomentovane__ #define PUBLIC_SERVER
  make clean
  make
  make mod

- pozor, urcite tam je este vela bugov //je to nedoladene
  zatial to ani nedavajte na server



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

5 files changed, 1187 insertions, 0 deletions

diff --git a/modules/Makefile b/modules/Makefile
new file mode 100755
index 0000000..a3e5588
--- /dev/null
+++ b/modules/Makefile
@@ -0,0 +1,16 @@
+
+CFLAGS = -g -O0  -I../include -Wall
+
+modTeleport:
+	gcc $(CFLAGS) -fPIC -I../include `sdl-config --cflags` -c list.c -o list.o
+	gcc $(CFLAGS) -fPIC -I../include `sdl-config --cflags` -c modTeleport.c -o modTeleport.o
+	gcc $(CFLAGS) -I../include -shared -fPIC -o modTeleport.so modTeleport.o list.o
+
+modPipe:
+	gcc $(CFLAGS) -fPIC -I../include `sdl-config --cflags` -c list.c -o list.o
+	gcc $(CFLAGS) -fPIC -I../include `sdl-config --cflags` -c modPipe.c -o modPipe.o
+	gcc $(CFLAGS) -I../include -shared -fPIC -o modPipe.so modPipe.o list.o
+
+clean:
+	rm -rf *.o 
+	rm -rf *.so
diff --git a/modules/list.c b/modules/list.c
new file mode 100755
index 0000000..56f7e17
--- /dev/null
+++ b/modules/list.c
@@ -0,0 +1,236 @@
+
+#include "main.h"
+#include "list.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+list_t* newList()
+{
+	list_t *new;
+
+	new = malloc( sizeof(list_t) );
+	memset(new, 0, sizeof(list_t) );
+
+	return new;
+}
+
+list_t* cloneList(list_t *p)
+{
+	list_t *new;
+
+	assert( p != NULL );
+
+	new = malloc( sizeof(list_t) );
+	memcpy(new, p, sizeof(list_t) );
+
+	if( p->list != NULL )
+	{
+		new->list = malloc( p->alloc * sizeof(void *) );
+		memcpy(new->list, p->list, p->alloc * sizeof(void *));
+	}
+
+	return new;
+}
+
+list_t* cloneListItem(list_t *p, void *f)
+{
+	list_t *new;
+	void* (*fce)(void *);
+	int i;
+
+	assert( p != NULL );
+	assert( f != NULL );
+
+	new = cloneList(p);
+	fce = f;
+
+	for(i = 0 ; i < p->count ; i++)
+		new->list[i] = fce(p->list[i]);
+
+	return new;
+}
+
+void addList(list_t *p, void *item)
+{
+	assert( p != NULL );
+
+	if( p->alloc == 0 )
+	{
+		p->alloc = LIST_ALLOC_LIMIT;
+		p->count = 1;
+		p->list = malloc(p->alloc * sizeof(void *) );
+		p->list[0] = item;
+
+		return;
+	}
+
+	if( p->count + 1 <= p->alloc )
+	{
+		p->list[p->count] = item;
+		p->count += 1;
+
+		return;
+	}
+
+	if( p->count + 1 > p->alloc )
+	{
+		void **new;
+
+#ifdef DEBUG_LIST
+		printf("realokujem z %d na %d (count=%d)\n",
+		p->alloc, p->alloc+LIST_ALLOC_LIMIT, p->count);
+#endif
+
+		p->alloc += LIST_ALLOC_LIMIT;
+		new = malloc(p->alloc * sizeof(void *) );
+		memcpy(new, p->list, p->count * sizeof(void *) );
+		free(p->list);
+		p->list = new;
+		p->list[p->count] = item;
+		p->count++;
+
+		return;
+	}
+}
+
+void insList(list_t *p, int n, void *item)
+{
+	assert( p != NULL );
+
+	addList(p, NULL); // :)
+
+	assert( n >= 0 || n < p->count );
+
+	memmove(p->list+n+1, p->list+n, ( (p->count-1) - n ) * sizeof(void *));
+
+	p->list[n] = item;
+}
+
+void *getList(list_t *p, int n)
+{
+	assert( p != NULL );
+	assert( n >= 0 || n < p->count );
+
+	return p->list[n];
+}
+
+int searchListItem(list_t *p, void *n)
+{
+	int i;
+
+	assert( p != NULL );
+
+	for( i = 0 ; i < p->count ; i++ )
+		if( p->list[i] == n )return i;
+
+	return -1;
+}
+
+void delList(list_t *p, int n)
+{
+	assert( p != NULL );
+	assert( n >= 0 || n < p->count );
+
+	memmove(p->list+n, p->list+n+1,  ( (p->count-1) - n ) * sizeof(void *));
+	
+	p->count--;
+
+	if( p->count + LIST_ALLOC_LIMIT < p->alloc )
+	{
+		void **new;
+
+#ifdef DEBUG_LIST
+		printf("realokujem z %d na %d (count=%d)\n",
+		p->alloc, p->alloc-LIST_ALLOC_LIMIT, p->count);
+#endif
+
+		p->alloc -= LIST_ALLOC_LIMIT;
+		new = malloc(p->alloc * sizeof(void *) );
+		memcpy(new, p->list, p->count * sizeof(void *) );
+		free(p->list);
+		p->list = new;
+	}
+}
+
+void delListItem(list_t *p, int n, void *f)
+{
+	int (*fce)(void *);
+
+	assert( p != NULL );
+	assert( n >= 0 || n < p->count );
+
+	fce = f;
+	if( fce != NULL )fce(p->list[n]);
+
+	delList(p, n);
+}
+
+void destroyList(list_t *p)
+{
+	assert( p != NULL );
+
+	if( p->list != NULL )free(p->list);
+	free(p);
+}
+
+void destroyListItem(list_t *p, void *f)
+{
+	void (*fce)(void *);
+	int i;
+
+	assert( p != NULL );
+	assert( f != NULL );
+
+	fce = f;
+
+	for(i = 0 ; i < p->count ; i++)
+		fce(p->list[i]);
+
+	destroyList(p);
+}
+
+/*
+typedef struct pokus_str
+{
+	int x;
+} pokus;
+
+pokus* newPokus(int n)
+{
+	pokus *new;
+	new = malloc(sizeof(pokus));
+	new->x = n;
+	return new;
+}
+
+pokus *clonePokus(pokus *p)
+{
+	pokus *new;
+	new = malloc(sizeof(pokus));
+	memcpy(new, p, sizeof(pokus));
+	return new;
+}
+
+void destroyPokus(pokus *p)
+{
+	free(p);
+}
+
+int main()
+{
+	list_t *my;
+	int i;
+
+	my = newList();
+
+	for(i = 0; i < 100; i++)
+		addList(my, newPokus(i));
+
+	destroyListItem(my, destroyPokus);
+
+	return 0;
+}
+*/
diff --git a/modules/list.h b/modules/list.h
new file mode 100755
index 0000000..8722baa
--- /dev/null
+++ b/modules/list.h
@@ -0,0 +1,32 @@
+
+#ifndef LIST_H
+
+#define LIST_H
+
+#include "main.h"
+
+#define LIST_ALLOC_LIMIT 16
+
+typedef struct list_str
+{
+	void **list;
+	int count;
+	int alloc;
+} list_t;
+
+extern list_t* newList();
+extern list_t* cloneList(list_t *p);
+extern list_t* cloneListItem(list_t *p, void *f);
+
+extern void addList(list_t *p, void *item);
+extern void insList(list_t *p, int n, void *item);
+extern void *getList(list_t *p,int n);
+extern int searchListItem(list_t *p, void *n);
+
+extern void delList(list_t *p,int n);
+extern void delListItem(list_t *p,int n,void *f);
+
+extern void destroyList(list_t *p);
+extern void destroyListItem(list_t *p,void *f);
+
+#endif
diff --git a/modules/modPipe.c b/modules/modPipe.c
new file mode 100755
index 0000000..fa5f99e
--- /dev/null
+++ b/modules/modPipe.c
@@ -0,0 +1,423 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "main.h"
+#include "interface.h"
+#include "modules.h"
+#include "tux.h"
+#include "shot.h"
+#include "list.h"
+#include "gun.h"
+#include "image.h"
+
+#ifdef PUBLIC_SERVER
+#include "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;
+
+#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;
+}
+
+#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 pipe_t* isConflictWithListPipe(list_t *listPipe, int x, int y, int w, int h)
+{
+	pipe_t *thisPipe;
+	int i;
+
+	assert( listPipe != NULL );
+
+	for( i = 0 ; i < listPipe->count ; i++ )
+	{
+		thisPipe  = (pipe_t *)listPipe->list[i];
+		assert( thisPipe != NULL );
+
+		if( export_fce->fce_conflictSpace(x, y, w, h,
+		    thisPipe->x, thisPipe->y, thisPipe->w, thisPipe->h) )
+		{
+			return thisPipe;
+		}
+	}
+
+	return NULL;
+}
+
+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
+
+	addList(listPipe, 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;
+}
+
+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;
+
+	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 :
+			shot->x = dist_x + offset;
+			shot->y = dist_y;
+		break;
+
+		case TUX_LEFT :
+			shot->x = dist_x;
+			shot->y = dist_y + offset;
+		break;
+
+		case TUX_RIGHT :
+			shot->x = dist_x + dist_w;
+			shot->y = dist_y + offset;
+		break;
+
+		case TUX_DOWN :
+			shot->x = dist_x + offset;
+			shot->y = dist_y + dist_h;
+		break;
+	}
+
+	shot->x += shot->px;
+	shot->y += shot->py;
+
+	if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_SERVER )
+	{
+		export_fce->fce_proto_send_shot_server(PROTO_SEND_ALL, NULL, shot);
+	}
+
+}
+
+static pipe_t* getPipeId(list_t *listPipe, int id)
+{
+	int i;
+
+	for( i = 0 ; i < listPipe->count ; i++ )
+	{
+		pipe_t *thisPipe;
+
+		thisPipe = (pipe_t *) listPipe->list[i];
+
+		if( thisPipe->id == id )
+		{
+			return thisPipe;
+		}
+	}
+
+	return NULL;
+}
+
+static void moveShotFromPipe(shot_t *shot, pipe_t *pipe, list_t *listPipe)
+{
+	pipe_t *distPipe;
+
+	distPipe = getPipeId(listPipe, 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()
+{
+	pipe_t *thisPipe;
+	int i;
+
+	assert( listPipe != NULL );
+
+	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;
+
+	arena = export_fce->fce_getCurrentArena();
+
+	for( i = 0 ; i < arena->listShot->count ; i++ )
+	{
+		shot_t *thisShot;
+
+		thisShot  = (shot_t *)arena->listShot->list[i];
+		assert( thisShot != NULL );
+
+		if( ( thisPipe = isConflictWithListPipe(listPipe, thisShot->x, thisShot->y,
+		    thisShot->w, thisShot->h) ) != NULL )
+		{
+			tux_t *author;
+
+			author = export_fce->fce_getTuxID(arena->listTux, thisShot->author_id);
+			
+			if( author != NULL &&
+			    author->bonus == BONUS_GHOST &&
+			    author->bonus_time > 0 )
+			{
+				continue;
+			}
+
+			if( negPosition( thisShot->position ) == thisPipe->position )
+			{
+				if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+				{
+					if( thisShot->gun != GUN_BOMBBALL )
+					{
+						delListItem(arena->listShot, i, export_fce->fce_destroyShot);
+						i--;
+					}
+				}
+				else
+				{
+					moveShotFromPipe(thisShot, thisPipe, listPipe);
+				}
+			}
+			else
+			{
+				if( thisShot->gun == GUN_BOMBBALL && 
+				    export_fce->fce_getNetTypeGame() != NET_GAME_TYPE_CLIENT )
+				{
+					export_fce->fce_boundBombBall(thisShot);
+					continue;
+				}
+				else
+				{
+					delListItem(arena->listShot, i, export_fce->fce_destroyShot);
+					i--;
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+int isConflict(int x, int y, int w, int h)
+{
+	if( isConflictWithListPipe(listPipe, x, y, w, h) != NULL )
+	{
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+void cmd(char *line)
+{
+	if( strncmp(line, "pipe", 4) == 0 )cmd_teleport(line);
+}
+
+int destroy()
+{
+	destroyListItem(listPipe, destroyPipe);
+
+	return 0;
+}
diff --git a/modules/modTeleport.c b/modules/modTeleport.c
new file mode 100755
index 0000000..fb59470
--- /dev/null
+++ b/modules/modTeleport.c
@@ -0,0 +1,480 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "main.h"
+#include "interface.h"
+#include "modules.h"
+#include "tux.h"
+#include "shot.h"
+#include "list.h"
+#include "gun.h"
+#include "image.h"
+
+#ifdef PUBLIC_SERVER
+#include "publicServer.h"
+#endif
+
+typedef struct teleport_struct
+{
+	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 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
+{
+	teleport_t *new;
+	
+#ifndef PUBLIC_SERVER	
+	assert( img != NULL );
+#endif
+
+	new  = malloc( sizeof(teleport_t) );
+	assert( new != NULL );
+
+	new->x = x;
+	new->y = y;
+	new->w = w;
+	new->h = h;
+	new->layer = layer;
+#ifndef PUBLIC_SERVER	
+	new->img = img;
+#endif
+
+	printf("new teleport\n");
+	return new;
+}
+
+#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 teleport_t* isConflictWithListTeleport(list_t *listTeleport, int x, int y, int w, int h)
+{
+	teleport_t *thisTeleport;
+	int i;
+
+	assert( listTeleport != NULL );
+
+	for( i = 0 ; i < listTeleport->count ; i++ )
+	{
+		thisTeleport  = (teleport_t *)listTeleport->list[i];
+		assert( thisTeleport != NULL );
+
+		if( export_fce->fce_conflictSpace(x, y, w, h,
+		    thisTeleport->x, thisTeleport->y, thisTeleport->w, thisTeleport->h) )
+		{
+			return thisTeleport;
+		}
+	}
+
+	return NULL;
+}
+
+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
+
+	addList(listTeleport, new);
+}
+
+static teleport_t* getRandomTeleportBut(list_t *listTeleport, teleport_t *teleport)
+{
+	int x;
+
+	do{
+		x = random() % listTeleport->count;
+	}while( listTeleport->list[x] == teleport );
+
+	return (teleport_t *) listTeleport->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 current_x, current_y;
+	int dist_x, dist_y;
+
+	if( tux->bonus == BONUS_GHOST ||
+	    export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+	{
+		return;
+	}
+
+	distTeleport = getRandomTeleportBut(listTeleport, 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) )
+	{
+		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 )
+	{
+		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;
+
+	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 :
+			shot->x = dist_x + offset;
+			shot->y = dist_y;
+		break;
+
+		case TUX_LEFT :
+			shot->x = dist_x;
+			shot->y = dist_y + offset;
+		break;
+
+		case TUX_RIGHT :
+			shot->x = dist_x + dist_w;
+			shot->y = dist_y + offset;
+		break;
+
+		case TUX_DOWN :
+			shot->x = dist_x + offset;
+			shot->y = dist_y + dist_h;
+		break;
+	}
+
+	shot->x += shot->px;
+	shot->y += shot->py;
+
+	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 *listTeleport)
+{
+	teleport_t *distTeleport;
+
+	distTeleport = getRandomTeleportBut(listTeleport, 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()
+{
+	teleport_t *thisTeleport;
+	int i;
+
+	assert( listTeleport != NULL );
+
+	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;
+
+	arena = export_fce->fce_getCurrentArena();
+
+	for( i = 0 ; i < arena->listTux->count ; i++ )
+	{
+		tux_t *thisTux;
+		int x, y, w, h;
+
+		thisTux = (tux_t *)arena->listTux->list[i];
+		export_fce->fce_getTuxProportion(thisTux, &x, &y, &w, &h);
+
+		if( ( thisTeleport = isConflictWithListTeleport(listTeleport, x, y, w, h) ) != NULL )
+		{
+			teleportTux(thisTux, thisTeleport);
+		}
+	}
+	
+	for( i = 0 ; i < arena->listShot->count ; i++ )
+	{
+		shot_t *thisShot;
+	
+		thisShot  = (shot_t *)arena->listShot->list[i];
+		assert( thisShot != NULL );
+
+		if( thisShot->gun == GUN_LASSER )
+		{
+			continue;
+		}
+
+		if( ( thisTeleport = isConflictWithListTeleport(listTeleport,
+			thisShot->x, thisShot->y, thisShot->w, thisShot->h) ) != NULL )
+		{
+			tux_t *author;
+
+			author = export_fce->fce_getTuxID(arena->listTux, thisShot->author_id);
+			
+			if( author != NULL && 
+			    author->bonus == BONUS_GHOST &&
+			    author->bonus_time > 0 )
+			{
+				continue;
+			}
+
+			if( export_fce->fce_getNetTypeGame() == NET_GAME_TYPE_CLIENT )
+			{
+				delListItem(arena->listShot, i, export_fce->fce_destroyShot);
+				i--;
+			}
+			else
+			{
+				moveShotFromTeleport(thisShot, thisTeleport, listTeleport);
+			}
+		}
+	}
+
+	return 0;
+}
+
+int isConflict(int x, int y, int w, int h)
+{
+	return 0;
+}
+
+
+void eventConflictWithTux(tux_t *tux)
+{
+}
+
+void eventConflictWithShot(shot_t *tux)
+{
+}
+
+void cmd(char *line)
+{
+	if( strncmp(line, "teleport", 8) == 0 )cmd_teleport(line);
+}
+
+int destroy()
+{
+	destroyListItem(listTeleport, destroyTeleport);
+	return 0;
+}