bomberclone/src/single.c

/* $Id: single.c,v 1.26 2003/05/29 20:49:53 stpohle Exp $ */
/* single player */

#include "basic.h"
#include "bomberclone.h"

void
single_game_new ()
{
    int p,
      i;

    bman.players_nr_s = 1;
    bman.players_nr = 1;

    // set players variables
    for (p = 0; p < MAX_PLAYERS; p++) {
        bman.players[p].pos.x = -1;
        bman.players[p].pos.y = -1;
        if (PS_IS_used (bman.players[p].state)) {
            bman.players_nr_s++;
            bman.players_nr++;
            bman.players[p].state = PSF_used + PSF_alife + PSF_playing;
        }
        else
            bman.players[p].state = 0;

        // reset bombs
        bman.players[p].bombs_n = START_BOMBS;
        bman.players[p].range = START_RANGE;
        bman.players[p].speed = START_SPEED;
        bman.players[p].special = SP_nothing;
        bman.updatestatusbar = 1;
        for (i = 0; i < MAX_BOMBS; i++) {
            bman.players[p].bombs[i].state = BS_off;
            bman.players[p].bombs[i].ex_nr = -1;
        }

        for (i = 0; i < PI_max; i++)
            bman.players[p].ill[i].to = 0;
        bman.players[p].frame = 0;
        bman.players[p].frameto = 0;
        bman.players[p].d = 0;
    }

    for (bman.p_nr = -1, p = 0; (bman.p_nr == -1 && p < MAX_PLAYERS); p++)
        if (!(PS_IS_used (bman.players[p].state)))
            bman.p_nr = p;

    if (bman.p_nr >= MAX_PLAYERS) {
        printf ("ERROR in function (single_game_new): couldn't find any free player\n");
        exit (1);
    }

    bman.players[bman.p_nr].state = PSFM_alife;
    player_set_gfx (&bman.players[bman.p_nr], 5);
    bman.last_ex_nr = 1;

    init_map_tileset ();

    bman.gametype = GT_single;
    bman.state = GS_running;
};


int
ai_checkfield (int x, int y)
{
    return ((bman.field[x][y].type == FT_nothing || bman.field[x][y].type == FT_fire || bman.field[x][y].type == FT_shoe || bman.field[x][y].type == FT_bomb ) && bman.bfield[x][y] == 0);
}


/* give the run away direction */
int
ai_easyrunaway (_point p)
{
    int i,
      done = 0,
      dir = 0;
    _point pos[4],
      m[4];

    for (i = 0; i < 4; i++) {
        pos[i] = p;
        switch (i) {
        case (left):
            m[i].x = -1;
            m[i].y = 0;
            break;
        case (right):
            m[i].x = 1;
            m[i].y = 0;
            break;
        case (up):
            m[i].x = 0;
            m[i].y = -1;
            break;
        default:
            m[i].x = 0;
            m[i].y = 1;
            break;
        }
        pos[i].x += m[i].x;
        pos[i].y += m[i].y;
    }

    /* test the possible ways */
    while (!done) {
        done = 1;

        for (i = 0; i < 4; i++) {
            /* check if we are still in the game field */
            if (pos[i].x <= 0 || pos[i].y <= 0 || pos[i].x >= bman.fieldsize.x - 1
                || pos[i].y >= bman.fieldsize.y - 1)
                pos[i].x = pos[i].y = -1;

            if (pos[i].x != -1 && pos[i].y != -1) {
                /* check if this place is free to go to */
                if (ai_checkfield (pos[i].x, pos[i].y)) {
                    done = 0;
                    /* check the field left and right beside */
                    if (i == left || i == right) {
                        if (ai_findnearbombs (pos[i]) == 0
                            && (ai_checkfield (pos[i].x, pos[i].y - 1)
                                || ai_checkfield (pos[i].x, pos[i].y + 1)))
                            dir |= (1 << i);
                    }
                    else {
                        if (ai_findnearbombs (pos[i]) == 0
                            && (ai_checkfield (pos[i].x - 1, pos[i].y)
                                || ai_checkfield (pos[i].x + 1, pos[i].y)))
                            dir |= (1 << i);
                    }
                    pos[i].x += m[i].x;
                    pos[i].y += m[i].y;
                }
            }
        }
    }

    return dir;
};


/* give the run away direction 
  the return value:
*/
_airunaway
ai_runawayfrom (_point p, int nearbomb, signed char norecursive)
{
    int i,
      done = 0,
      nbomb,
      tdir,
      _i,
      bdirpoints = 10,
      j,
      c;
    _airunaway res;
    _point pos[4],
      m[4],
      tpos;

    res.dir = 0;
    res.bestdir = -1;

    for (i = 0; i < 4; i++) {
        pos[i] = p;
        switch (i) {
        case (left):
            m[i].x = -1;
            m[i].y = 0;
            break;
        case (right):
            m[i].x = 1;
            m[i].y = 0;
            break;
        case (up):
            m[i].x = 0;
            m[i].y = -1;
            break;
        default:
            m[i].x = 0;
            m[i].y = 1;
            break;
        }
        pos[i].x += m[i].x;
        pos[i].y += m[i].y;
    }

    /* test if we just have to move to the side */
    if (!norecursive)
        for (i = 0; i < 4; i++)
            if (ai_checkfield (pos[i].x, pos[i].y) && ai_findnearbombs (pos[i]) == 0) {
                bdirpoints = 0;
                res.bestdir = i;
                res.dir |= (1 << i);
            }

/*    if (!norecursive) {
        printf ("%d,%d NB:", p.x, p.y);
        d_bitprint (nearbomb, 5);
        d_bitprint (res.dir, 4);
    }
*/
    /* test the possible ways */
    while (!done) {
        done = 1;

        for (i = 0; i < 4; i++) {
            /* check if we are still in the game field */
            if (pos[i].x <= 0 || pos[i].y <= 0 || pos[i].x >= bman.fieldsize.x - 1
                || pos[i].y >= bman.fieldsize.y - 1)
                pos[i].x = pos[i].y = -1;

            if (pos[i].x != -1 && pos[i].y != -1) {
                /* check if this place is free to go to */
                if (ai_checkfield (pos[i].x, pos[i].y)) {
                    done = 0;
                    /* check the field left and right beside */
                    for (j = 0; j < 4; j++)
                        if (((i == left || i == right) && (j == up || j == down)) ||
                            ((j == left || j == right) && (i == up || i == down))) {
                            c = 10;
                            tpos.x = pos[i].x + m[j].x;
                            tpos.y = pos[i].y + m[j].y;
                            if (ai_checkfield (tpos.x, tpos.y)) {
                                nbomb = ai_findnearbombs (tpos);
                                c = s_countbits (nbomb, 5);
                                if (!norecursive) {
                                    tdir = ai_runawayfrom (tpos, nbomb, 1).dir;
                                    _i = ai_invertdir (i);
                                    if (tdir != (1 << _i)) { // usefull direction
//                                            printf ("B%d ", i);
                                        res.dir |= (1 << i); // add this one
                                    }
                                    else {
//                                            printf ("-%d ", i);
                                        c = -1;
                                    }
                                }
                                else
                                    res.dir |= (1 << i);

                                /* check for the best direction */
//        if (!norecursive) printf ("pts:%d|%d ", bdirpoints, res.bestdir);
                                if (c != -1 && !norecursive) {
                                    if (c < bdirpoints) {
                                        bdirpoints = c;
                                        res.bestdir = i;
                                    }
                                    else if (bdirpoints != 0 && c == bdirpoints && c < 5
                                             && s_random (2) == 0)
                                        res.bestdir = i; // random if the points are equal
                                }
                            }
                        }
                    pos[i].x += m[i].x;
                    pos[i].y += m[i].y;
                }
            }
        }
    }

/*    if (!norecursive) {
        d_bitprint (res.dir, 4);
        printf ("%d ] ", res.bestdir);
    } else {
		printf ("(%d,%d NB ", p.x, p.y);
		d_bitprint (nearbomb, 5);
		d_bitprint (res.dir, 4);
		printf (")");
	}
*/
    return res;
};


/* count the points for dropping a bomb here 
   this will even count if there is any powerup*/
int
ai_bombpoints (_point pos, int range)
{
    int points = 0,
      d,
      r;
    _point p,
      m;

    if (bman.field[pos.x][pos.y].type != FT_block && bman.field[pos.x][pos.y].type != FT_stone
        && ai_checkfield (pos.x, pos.y)) {
        for (d = 0; d < 4; d++) {
            switch (d) {
            case (left):
                m.x = -1;
                m.y = 0;
                break;
            case (right):
                m.x = 1;
                m.y = 0;
                break;
            case (up):
                m.x = 0;
                m.y = -1;
                break;
            default:
                m.x = 0;
                m.y = 1;
                break;
            }

            p = pos;

            for (r = 0; (r < range && bman.field[p.x][p.y].type == FT_nothing); r++) {
                p.x += m.x;
                p.y += m.y;
            }

            if (bman.field[p.x][p.y].type != FT_nothing && (bman.field[p.x][p.y].type != FT_block || bman.field[p.x][p.y].type == FT_shoe || bman.field[p.x][p.y].type == FT_bomb || bman.field[p.x][p.y].type == FT_fire))
                points++;
			if (bman.field[p.x][p.y].type == FT_shoe || bman.field[p.x][p.y].type == FT_bomb ||
				bman.field[p.x][p.y].type == FT_fire)
				points += 2;
        }
    }

    if (ai_easyrunaway (pos) == 0 || ai_findnearbombs (pos) != 0)
        points = 0;

    return points;
};


/* find the best position to go for dropping a bomb */
int
ai_findbestbombdir (_point pos, int dir, int range)
{
    int points[5] = { 0, 0, 0, 0, 0 };
    int d,
      done = 0,
      j,
	  maxpoints = 0,
	bestd;
    _point m[4],
      p[4];

    points[4] = ai_bombpoints (pos, range);

    /* fill in the positions */
    for (d = 0; d < 4; d++) {
        p[d] = pos;

        switch (d) {
        case (left):
            m[d].x = -1;
            m[d].y = 0;
            break;
        case (right):
            m[d].x = 1;
            m[d].y = 0;
            break;
        case (up):
            m[d].x = 0;
            m[d].y = -1;
            break;
        default:
            m[d].x = 0;
            m[d].y = 1;
            break;
        }
    }

    while (!done) {
        done = 1;

        for (d = 0; d < 5; d++) {

            if (d < 4) {
                p[d].x += m[d].x;
                p[d].y += m[d].y;
                if (p[d].x > 0 && p[d].y > 0 && p[d].x < bman.fieldsize.x - 1
                    && p[d].y < bman.fieldsize.y - 1) {
						if (ai_checkfield (p[d].x, p[d].y)) { 
							/* we are opn a empty field go on with the test */
							done = 0;
							j = ai_bombpoints (p[d], range);
							if (points[d] < j)
								points[d] = j;
						}
						else /* no empty field */
							p[d].x = p[d].y = -1;
                }
            }

 			if (maxpoints < points[d])
				maxpoints = points[d];
        }
    }

	bestd = 0;
	if (maxpoints > 2)
		maxpoints--;

	for (d = 0; d < 5; d++)
		if (points[d] >= maxpoints)
			bestd |= (1 << d);
	
	/* prevent from turning around */
	if (dir != -1 && (bestd & (0xFF -(1 << ai_invertdir(dir)))))
		bestd &= (0xFF - (1 << ai_invertdir(dir)));

//    d_printf ("ai_bestbombdir (%d,%d) [%d, %d, %d, %d, %d]\n", pos.x, pos.y, points[0],
//            points[1], points[2], points[3], points[4]);

    return bestd;
}


/* check if is there is a bom in the near
   returns the directions (bits 0(left)-3(down) bit4 bomb under us) where a bomb is */
int
ai_findnearbombs (_point pos)
{
    int d,
      res = 0,                  // result if there is a bomb

      done = 0;
    _point m[4];                // direction addition
    _point dist[4];             // to check every direction (on three ways)

    for (d = 0; d < 4; d++)
        switch (d) {
        case (left):
            m[d].x = -1;
            m[d].y = 0;
            dist[d].x = pos.x - 1;
            dist[d].y = pos.y;
            break;
        case (right):
            m[d].x = 1;
            m[d].y = 0;
            dist[d].x = pos.x + 1;
            dist[d].y = pos.y;
            break;
        case (up):
            m[d].x = 0;
            m[d].y = -1;
            dist[d].x = pos.x;
            dist[d].y = pos.y - 1;
            break;
        case (down):
            m[d].x = 0;
            m[d].y = 1;
            dist[d].x = pos.x;
            dist[d].y = pos.y + 1;
            break;
        }

    while (!done) {
        done = 1;
        /* check every direction again */
        for (d = 0; d < 4; d++)
            if (dist[d].x >= 0 && dist[d].x < bman.fieldsize.x &&
                dist[d].y >= 0 && dist[d].y < bman.fieldsize.y) {
                if (bman.bfield[dist[d].x][dist[d].y] != 0) {
                    res |= (1 << d); // set the bit for the direction;
                    dist[d].x = dist[d].y = -1; // don't check no more.
                }
                if (bman.field[dist[d].x][dist[d].y].type != FT_nothing)
                    dist[d].x = dist[d].y = -1; // don't check no more.
                else if (dist[d].x != -1 && dist[d].y != -1) {
                    dist[d].x += m[d].x;
                    dist[d].y += m[d].y;
                    done = 0;
                }
            }
    }

    if (bman.bfield[pos.x][pos.y] != 0)
        res |= 16;              // set the 4th. bit

    return res;
}


/* check if we are still running and fill out the position 
	return == 0 we're still walking ... else we have reached a point */
int
ai_checkpos (_player * pl, _point * pos)
{
    _point _p;

    _p.x = pl->pos.x & 255;
    _p.y = pl->pos.y & 255;

    pos->x = pl->pos.x >> 8;
    pos->y = pl->pos.y >> 8;

    if (_p.x > 128)
        (pos->x)++;
    if (_p.y > 128)
        (pos->y)++;

    return ((_p.x < 42 || _p.x > 213) && (_p.y < 42 || _p.y > 213));
};


/* random choose direction */
int
ai_choosedir (int dir, int nearbomb, int oldpos)
{
    int rdir[4];
    int bdir[4 * 3];
    int i,
      rnr,
      bnr;

    for (rnr = bnr = i = 0; i < 4; i++) {
        if ((dir & (1 << i)) != 0) {
            rdir[rnr] = i;
            rnr++;
        }
        if (((nearbomb & (DIRM_up + DIRM_down)) != 0) && ((dir & (1 << i)) != 0)
            && (i == left || i == right) && i != ai_invertdir (oldpos)) {
            bdir[bnr] = i;
            bnr++;
        }
        if (((nearbomb & (DIRM_left + DIRM_right)) != 0) && ((dir & (1 << i)) != 0)
            && (i == down || i == up) && i != ai_invertdir (oldpos)) {
            bdir[bnr] = i;
            bnr++;
        }
    }

    if (rnr == 0)
        return (s_random (4));

    if (bnr != 0)
        i = bdir[s_random (bnr)];
    else
        i = rdir[s_random (rnr)];

    return i;
};


int
ai_invertdir (int dir)
{
    int idir;
    switch (dir) {
    case (left):
        idir = right;
        break;
    case (right):
        idir = left;
        break;
    case (down):
        idir = up;
        break;
    default:
        idir = down;
        break;
    }
    return idir;
};


int
ai_checknewpos (_point pos, int d)
{
    _point m;
    switch (d) {
    case (left):
        m.x = pos.x - 1;
        m.y = pos.y;
        break;
    case (right):
        m.x = pos.x + 1;
        m.y = pos.y;
        break;
    case (up):
        m.x = pos.x;
        m.y = pos.y - 1;
        break;
    default:
        m.x = pos.x;
        m.y = pos.y + 1;
        break;
    }

    return (ai_findnearbombs (m) == 0);
};


/* create a giving number of ai players */
void
single_create_ai (int players)
{
    int p;
    int count;
    _player *pl;

    for (count = 0; count < players; count++) {
        /* find free players */
        for (pl = NULL, p = 0; (pl == NULL && p < MAX_PLAYERS); p++)
            if (!(PS_IS_used (bman.players[p].state))) {
                pl = &bman.players[p];
                pl->state |= PSF_used + PSF_alife + PSF_playing;
                player_set_gfx (pl, s_random (MAX_PLAYERS));
            }

        if (pl == NULL)
            return;
    }
};



void
single_playergame ()
{
    int p;

    /* delete player from the game */
    for (p = 0; p < MAX_PLAYERS; p++)
        bman.players[p].state = 0;

    single_create_ai (7);
    single_game_new ();
    gfx_game_init ();
    game_loop ();
    gfx_game_shutdown ();
};



void
single_loop ()
{
    int p;
    _player *pl;
    _point plpos;
    int nearbomb = 0,
      bestbdir,
      i;
    _airunaway rawdir;

    for (p = 0; p < MAX_PLAYERS; p++)
        if (p != bman.p_nr && PS_IS_alife (bman.players[p].state)) {
            pl = &bman.players[p];

            i = ai_checkpos (pl, &plpos);

            if (!i)
                /* we're still moving */
                pl->m = 1;
            else {
                nearbomb = ai_findnearbombs (plpos);
                if (nearbomb == 0) { // no bombs found
                    bestbdir = ai_findbestbombdir (plpos, pl->d, pl->range);
                    if (bestbdir & DIRM_under) {
                        if (ai_easyrunaway (plpos) != 0)
                            player_drop_bomb (p);
                    }
                    else if (bestbdir == 0) {
                        pl->d = s_random (4);
                        pl->m = 1;
                    }
                    else {
                        pl->d = ai_choosedir (bestbdir, 0, pl->d);
                        pl->m = 1;
                    }
                    if (!ai_checknewpos (plpos, pl->d))
                        pl->m = 0;
                }
                else {
                    // bombs in the near found
//                    printf ("P%d,%d ", plpos.x, plpos.y);
                    rawdir = ai_runawayfrom (plpos, nearbomb, 0);
                    if (rawdir.dir != 0 && rawdir.bestdir == -1) {
                        pl->d = ai_choosedir (rawdir.dir, nearbomb, pl->d); // we have to make a choice.. do it
                        pl->m = 1;
                    }
                    else if (rawdir.bestdir != -1) {
                        pl->d = rawdir.bestdir;
                        pl->m = 1;
                    }
//                    printf (" d:%d m:%d\n", pl->d, pl->m);
                }
            }
            player_ilness_loop (p);
            move_player (p);
        }
};