From 2d776fcd61be168e1ff0ff2e4a5e71835e7cea19 Mon Sep 17 00:00:00 2001 From: oroborus Date: Sat, 28 Jun 2008 16:38:35 +0000 Subject: - prekopanie adresarovej struktury, prva cast git-svn-id: http://opensvn.csie.org/tuxanci_ng@77 0ee4d065-81f0-4d1e-b06c-ff20ad07cc3e --- src/modules/Makefile | 22 ++ src/modules/modAI.c | 256 +++++++++++++++++++++++ src/modules/modPipe.c | 453 +++++++++++++++++++++++++++++++++++++++++ src/modules/modTeleport.c | 506 ++++++++++++++++++++++++++++++++++++++++++++++ src/modules/modWall.c | 331 ++++++++++++++++++++++++++++++ 5 files changed, 1568 insertions(+) create mode 100755 src/modules/Makefile create mode 100755 src/modules/modAI.c create mode 100755 src/modules/modPipe.c create mode 100755 src/modules/modTeleport.c create mode 100755 src/modules/modWall.c (limited to 'src/modules') 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 +#include +#include +#include + +#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 +#include +#include +#include + +#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 +#include +#include +#include + +#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, ¤t_x, ¤t_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 +#include +#include +#include + +#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; +} -- cgit v1.2.3