You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
378 lines
12 KiB
378 lines
12 KiB
/* $Id: map.c,v 1.3 2003/07/22 18:29:08 stpohle Exp $ */
|
|
/* map handling, like generate and load maps. */
|
|
|
|
#include "bomberclone.h"
|
|
|
|
_map map;
|
|
|
|
// put items into the field
|
|
void
|
|
map_fillitems (int fieldtype, int num)
|
|
{
|
|
int nb_try = 100,
|
|
d,
|
|
x,
|
|
y;
|
|
/* this is the item factor we multiply it with this so we know
|
|
how much items we want in the game */
|
|
float fkt = ((float) (map.size.x * map.size.y)) / (25.0 * 17.0);
|
|
/* put the row special in the field */
|
|
|
|
for (d = 0; d < num * fkt; d++) {
|
|
x = y = 0;
|
|
while (map.field[x][y].type != FT_stone || map.field[x][y].special != FT_nothing) {
|
|
x = ((float) rand () / (float) RAND_MAX) * (map.size.x - 1);
|
|
y = ((float) rand () / (float) RAND_MAX) * (map.size.y - 1);
|
|
nb_try--;
|
|
if (nb_try < 0)
|
|
break;
|
|
}
|
|
map.field[x][y].special = fieldtype;
|
|
}
|
|
}
|
|
|
|
|
|
// loads or generate an map
|
|
void
|
|
map_new (char *filename)
|
|
{
|
|
int x,
|
|
y;
|
|
FILE *fmap;
|
|
|
|
if (filename) {
|
|
fmap = fopen (filename, "r");
|
|
|
|
/* if we can't open the given filename for any reason, reverting
|
|
to default value else, load the file */
|
|
if (fmap)
|
|
map_load (fmap);
|
|
}
|
|
else
|
|
fmap = NULL;
|
|
|
|
// Clean and create the field //
|
|
if (fmap == NULL)
|
|
map_genrandom ();
|
|
|
|
/* delete the bfield data */
|
|
for (x = 0; x < MAX_FIELDSIZE_X; x++)
|
|
for (y = 0; y < MAX_FIELDSIZE_Y; y++)
|
|
map.bfield[x][y] = 0;
|
|
|
|
/* Set the Playerinformation */
|
|
map_set_playerposition (fmap != NULL);
|
|
|
|
/* put the fire powerups in the field */
|
|
map_fillitems (FT_fire, map.fire);
|
|
/* put the bomb powerups in the field */
|
|
map_fillitems (FT_bomb, map.bombs);
|
|
/* put the shoe powerup in the field */
|
|
map_fillitems (FT_shoe, map.shoes);
|
|
/* put the death ?powerups? in the field */
|
|
map_fillitems (FT_death, map.death);
|
|
/* put the mixed powerrup in the field */
|
|
map_fillitems (FT_mixed, map.mixed);
|
|
/* put the trigger special in the field */
|
|
map_fillitems (FT_sp_trigger, map.sp_trigger);
|
|
/* put the row special in the field */
|
|
map_fillitems (FT_sp_row, map.sp_row);
|
|
/* put the push special in the field */
|
|
map_fillitems (FT_sp_push, map.sp_push);
|
|
/* put the kick special in the field */
|
|
// map_fillitems (FT_sp_kick, GAME_SPECIAL_ITEMSKICK);
|
|
}
|
|
|
|
void map_genrandom () {
|
|
int x, y, d;
|
|
|
|
/* if we can't load the map check first the fieldsize settings */
|
|
if (map.size.x < MIN_FIELDSIZE_X)
|
|
map.size.x = MIN_FIELDSIZE_X;
|
|
if (map.size.x > MAX_FIELDSIZE_X)
|
|
map.size.x = MAX_FIELDSIZE_X;
|
|
|
|
for (x = 0; x < map.size.x; x++)
|
|
for (y = 0; y < map.size.y; y++) {
|
|
if ((y == 0) || (y == map.size.y - 1))
|
|
map.field[x][y].type = FT_block;
|
|
else if ((x == 0) || (x == map.size.x - 1))
|
|
map.field[x][y].type = FT_block;
|
|
else if (((x & 1) == 0) && ((y & 1) == 0))
|
|
map.field[x][y].type = FT_block;
|
|
else {
|
|
// create random field
|
|
if ((s_random (256) & 3) == 0)
|
|
map.field[x][y].type = FT_nothing;
|
|
else
|
|
map.field[x][y].type = FT_stone;
|
|
}
|
|
|
|
for (d = 0; d < 4; d++)
|
|
map.field[x][y].ex[d].frame = map.field[x][y].ex[d].count = 0;
|
|
map.field[x][y].ex_nr = -1;
|
|
map.field[x][y].frame = 0;
|
|
map.field[x][y].frameto = 0;
|
|
map.field[x][y].special = FT_nothing;
|
|
}
|
|
}
|
|
|
|
|
|
/* will set the playerposition but in a way that we won't start on a block */
|
|
/* i am just too lazy to write this all again and again */
|
|
#define PLX bman.players[i].pos.x
|
|
#define PLY bman.players[i].pos.y
|
|
void
|
|
map_set_playerposition (int usermap)
|
|
{
|
|
int p,
|
|
dist,
|
|
i,
|
|
j,
|
|
mx,
|
|
my,
|
|
dx = 0,
|
|
dy = 0;
|
|
char txt[255];
|
|
|
|
p = 50;
|
|
dist = 8;
|
|
while (p == 50) {
|
|
p = 0;
|
|
dist--;
|
|
for (i = 0; (p < 50 && i < MAX_PLAYERS);) {
|
|
if (usermap) {
|
|
int maxloop = 0;
|
|
while (maxloop < 200 && (PLX == -1 || PLY == -1)) {
|
|
maxloop++;
|
|
PLX = s_random (map.size.x - 2) + 1;
|
|
PLY = s_random (map.size.y - 2) + 1;
|
|
|
|
for (dx = 10, dy = 10, j = 0; (j < i && j < MAX_PLAYERS && (dx > 1 || dy > 1)); j++) { /* is ther any other player */
|
|
dx = PLX - bman.players[j].pos.x;
|
|
if (dx < 0)
|
|
dx = -dx;
|
|
dy = PLY - bman.players[j].pos.y;
|
|
if (dy < 0)
|
|
dy = -dy;
|
|
}
|
|
|
|
/* check if there is no block */
|
|
if ((dx > 1 || dy > 1)
|
|
&& ((map.field[PLX][PLY].type != FT_block && maxloop > 100)
|
|
|| map.field[PLX][PLY].type == FT_nothing)) {
|
|
/* get (up or down) dx and (left or right) dy */
|
|
dx = s_random (2);
|
|
if (dx == 0)
|
|
dx = -1;
|
|
dy = s_random (2);
|
|
if (dy == 0)
|
|
dy = -1;
|
|
|
|
/* first check if there is and free place for us */
|
|
if (!((map.field[PLX + dx][PLY].type != FT_block && maxloop > 100) ||
|
|
map.field[PLX + dx][PLY].type == FT_nothing))
|
|
dx = -dx;
|
|
if (!((map.field[PLX + dx][PLY].type != FT_block && maxloop > 100) ||
|
|
map.field[PLX + dx][PLY].type == FT_nothing))
|
|
PLX = -1;
|
|
|
|
if (!((map.field[PLX][PLY + dy].type != FT_block && maxloop > 100) ||
|
|
map.field[PLX][PLY + dy].type == FT_nothing))
|
|
dy = -dy;
|
|
if (!((map.field[PLX][PLY + dy].type != FT_block && maxloop > 100) ||
|
|
map.field[PLX][PLY + dy].type == FT_nothing))
|
|
PLY = -1;
|
|
}
|
|
else {
|
|
PLX = -1;
|
|
PLY = -1;
|
|
}
|
|
|
|
/* make some space */
|
|
if (PLX != -1 && PLY != -1) {
|
|
map.field[PLX][PLY].type = FT_nothing;
|
|
map.field[PLX + dx][PLY].type = FT_nothing;
|
|
map.field[PLX][PLY + dy].type = FT_nothing;
|
|
}
|
|
}
|
|
}
|
|
if (PLX == -1 || PLY == -1) {
|
|
/* we could not set all fields or we don't run on a usermap */
|
|
if (usermap) {
|
|
sprintf (txt, "Not all players could be set (Pl:%d)", i);
|
|
menu_displaymessage ("MAP - ERROR", txt);
|
|
}
|
|
|
|
/* now there will be some fields deleted */
|
|
PLX = 2 * (s_random ((map.size.x - 1) / 2)) + 1;
|
|
PLY = 2 * (s_random ((map.size.y - 1) / 2)) + 1;
|
|
|
|
map.field[PLX][PLY].type = FT_nothing;
|
|
|
|
dx = s_random (4); // bit 1 = up/down bit 2 = left/right
|
|
/* up and down */
|
|
if (((dx & 1) == 0 && PLX > 1) || PLX >= map.size.x - 2)
|
|
map.field[PLX - 1][PLY].type = FT_nothing;
|
|
else
|
|
map.field[PLX + 1][PLY].type = FT_nothing;
|
|
/* left and right */
|
|
if (((dx & 2) == 0 && PLY > 1) || PLY >= map.size.y - 2)
|
|
map.field[PLX][PLY - 1].type = FT_nothing;
|
|
else
|
|
map.field[PLX][PLY + 1].type = FT_nothing;
|
|
}
|
|
mx = my = 100;
|
|
for (j = 0; j <= i; j++) { /* search smalest distance */
|
|
dy = PLY - bman.players[j].pos.y;
|
|
dx = PLX - bman.players[j].pos.x;
|
|
if (dy < 0)
|
|
dy = -dy;
|
|
if (dx < 0)
|
|
dx = -dx;
|
|
|
|
if (mx > dx && i != j)
|
|
mx = dx;
|
|
if (my > dy && i != j)
|
|
my = dy;
|
|
}
|
|
|
|
if (mx > dist || my > dist)
|
|
i++;
|
|
else
|
|
p++;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < MAX_PLAYERS; i++) {
|
|
PLX = PLX << 8;
|
|
PLY = PLY << 8;
|
|
}
|
|
};
|
|
#undef PLX
|
|
#undef PLY
|
|
|
|
/* load a random map */
|
|
void map_random () {
|
|
_direntry *destart, *de, *desel;
|
|
char path[LEN_PATHFILENAME];
|
|
int max, sel;
|
|
|
|
sprintf (path, "%s/maps", bman.datapath);
|
|
desel = destart = s_getdir (path);
|
|
|
|
for (max = 0, de = destart; de != NULL; de = de->next)
|
|
if ((de->flags & DF_file) == DF_file)
|
|
max++;
|
|
|
|
sel = s_random (max);
|
|
for (max = 0, de = destart; max <= sel && de != NULL; de = de->next)
|
|
if ((de->flags & DF_file) == DF_file) {
|
|
desel = de;
|
|
max++;
|
|
}
|
|
|
|
d_printf ("Random Map %s (%d on %d)\n", desel->name, sel, max);
|
|
|
|
if (desel != NULL)
|
|
sprintf (map.map, "%s/maps/%s", bman.datapath, desel->name);
|
|
}
|
|
|
|
|
|
// Init the game according to options
|
|
void init_map_tileset()
|
|
{
|
|
switch (map.map_selection) {
|
|
case (0):
|
|
map_new (map.map);
|
|
break;
|
|
case (1):
|
|
map_random ();
|
|
map_new (map.map);
|
|
break;
|
|
case (2):
|
|
map_new (NULL);
|
|
break;
|
|
}
|
|
|
|
if (map.random_tileset)
|
|
tileset_random ();
|
|
}
|
|
|
|
|
|
/* read from an open file map, determine field.x and field.y
|
|
and fill the field.
|
|
(# correspond to a bloc and @ correspond to a stone,
|
|
an espace is nothing ' '
|
|
% are commentary at the beginning of the map */
|
|
void
|
|
map_load (FILE * fmap)
|
|
{
|
|
size_t length;
|
|
char *currentline;
|
|
char tmp[MAX_FIELDSIZE_X];
|
|
int sizex = 0;
|
|
int sizey = 0;
|
|
int i;
|
|
int d;
|
|
|
|
while ((currentline = fgets (tmp, MAX_FIELDSIZE_X, fmap))) {
|
|
length = strlen (currentline);
|
|
if (currentline[0] == '%')
|
|
continue;
|
|
/* now each line correspond to the field */
|
|
else if (strstr (currentline, "bombs") == currentline) // bombs
|
|
map.bombs = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "fire") == currentline) // fire
|
|
map.fire = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "shoes") == currentline) // shoes
|
|
map.shoes = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "mixed") == currentline) // mixed
|
|
map.mixed = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "death") == currentline) // death
|
|
map.death = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "sp_trigger") == currentline) // trigger special
|
|
map.sp_trigger = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "sp_push") == currentline) // push special
|
|
map.sp_push = atoi (strchr (currentline, '=') + 1);
|
|
else if (strstr (currentline, "sp_row") == currentline) // row special
|
|
map.sp_row = atoi (strchr (currentline, '=') + 1);
|
|
else if (currentline[0] == '#') { /* the map itself */
|
|
for (i = 0; i < length; i++) {
|
|
switch (currentline[i]) {
|
|
case '#':
|
|
map.field[i][sizey].type = FT_block;
|
|
break;
|
|
case '@':
|
|
map.field[i][sizey].type = FT_stone;
|
|
break;
|
|
case ' ':
|
|
map.field[i][sizey].type = FT_nothing;
|
|
default:
|
|
break;
|
|
}
|
|
for (d = 0; d < 4; d++)
|
|
map.field[i][sizey].ex[d].frame = map.field[i][sizey].ex[d].count = 0;
|
|
map.field[i][sizey].ex_nr = -1;
|
|
map.field[i][sizey].frame = 0;
|
|
map.field[i][sizey].frameto = 0;
|
|
map.field[i][sizey].special = FT_nothing;
|
|
}
|
|
sizey++;
|
|
if (sizex < length)
|
|
sizex = length;
|
|
}
|
|
}
|
|
|
|
map.size.x = sizex - 1;
|
|
map.size.y = sizey;
|
|
|
|
/* darw the border so we know everything is right */
|
|
for (i = 0; i < map.size.x; i++)
|
|
map.field[i][0].type = map.field[i][map.size.y - 1].type = FT_block;
|
|
for (i = 0; i < map.size.y; i++)
|
|
map.field[0][i].type = map.field[map.size.x - 1][i].type = FT_block;
|
|
|
|
fclose (fmap);
|
|
}
|