Initial checkin. Not there yet.

[xor] / game.c

/* -*-c-*-
 *
 * $Id: game.c,v 1.1 2003/12/12 10:55:30 mdw Exp $
 *
 * Main game logic
 *
 * (c) 2003 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of XOR.
 *
 * XOR is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * XOR is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with XOR; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: game.c,v $
 * Revision 1.1  2003/12/12 10:55:30  mdw
 * Initial checkin.  Not there yet.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "xor.h"

/*----- Main code ---------------------------------------------------------*/

#define G_CELLSET(g, x, y, c) do {					\
  undo_cell((g), (x), (y), (c));					\
  CELLSET((g)->l, (x), (y), (c));					\
} while (0)

void game_die(game_state *g, int x, int y)
{
  game_player *p;

  for (p = g->p; p && (p->x != x || p->y != y); p = p->next) ;
  if (!p) return;
  ui_frame(g->p->u);
  undo_die(g, p);
  p->f |= PF_DEAD;
  G_CELLSET(g, p->x, p->y, C_EMPTY);
  for (p = g->p; p && (p->f & PF_DEAD); p = p->next) ;
  if (p) ui_message(g->p->u, "Whoops!");
  else ui_message(g->p->u, "Gotcha!");
}

void game_explode(game_state *g, const point *pt, int n)
{
  int i;

  ui_explode(g->p->u, pt, n);
  for (i = 0; i < n; i++) game_die(g, pt[i].x, pt[i].y);
  for (i = 0; i < n; i++) G_CELLSET(g, pt[i].x, pt[i].y, C_EMPTY);
}

void game_moveobj(game_state *g, int x, int y, int xx, int yy)
{
  int c = CELL(g->l, x, y);
  G_CELLSET(g, x, y, C_EMPTY);
  G_CELLSET(g, xx, yy, c);
}

static int doupdateh(game_state *g)
{
  level *l = g->l;
  int i, j, c;
  int rc = 0;

  for (j = 0; j < l->h; j++) {
    for (i = 0; i < l->w; i++) {
      c = CELL(l, i, j) & CF_CELLMASK;
      if (cellmap[c]->moveh && cellmap[c]->moveh(g, i, j)) rc = 1;
    }
  }
  if (rc) ui_frame(g->p->u);
  return (rc);
}

static int doupdatev(game_state *g)
{
  level *l = g->l;
  int i, j, c;
  int rc = 0;

  for (i = 0; i < l->w; i++) {
    for (j = l->h - 1; j >= 0; j--) {
      c = CELL(l, i, j) & CF_CELLMASK;
      if (cellmap[c]->movev && cellmap[c]->movev(g, i, j)) rc = 1;
    }
  }
  if (rc) ui_frame(g->p->u);
  return (rc);
}

static void updatev(game_state *g) { while (doupdatev(g) || doupdateh(g)) ; }
static void updateh(game_state *g) { while (doupdateh(g) || doupdatev(g)) ; }

void game_switchto(game_state *g, game_player *p)
{
  /* --- Don't stash undo records here --- */

  if (!(g->p->f & PF_DEAD))
    CELLSET(g->l, g->p->x, g->p->y, C_SPARE);
  g->p->prev = g->ptail;
  p->prev->next = 0;
  g->ptail->next = g->p;
  g->ptail = p->prev;
  p->prev = 0;
  g->p = p;
  g->l->v++;
  CELLSET(g->l, g->p->x, g->p->y, C_PLAYER);
  ui_switch(g->p->u);
}

int game_switch(game_state *g)
{
  game_player *p;

  if (!g->p)
    return (0);
  for (p = g->p->next; p && (p->f & PF_DEAD); p = p->next)
    ;
  if (!p) return (0);
  if (g->l->v >= g->l->vtot) return (1);
  undo_switch(g);
  game_switchto(g, p);
  return (1);
}

void game_move(game_state *g, int dx, int dy)
{
  int x = g->p->x;
  int y = g->p->y;
  int c = CELL(g->l, x + dx, y + dy) & CF_CELLMASK;

  if (g->p->f & PF_DEAD) return;
  if (g->l->v >= g->l->vtot) return;
  if ((cellmap[c]->f & ((dx ? CF_HPASS : 0) | (dy ? CF_VPASS : 0))) ||
      (cellmap[c]->nudge &&
       cellmap[c]->nudge(g, x + dx, y + dy, dx, dy) > 0)) {
    undo_pmove(g);
    game_moveobj(g, x, y, x + dx, y + dy);
    g->p->x = x + dx;
    g->p->y = y + dy;
    g->l->v++;
    ui_track(g->p->u, x + dx, y + dy);
    if (dx) updatev(g); else updateh(g);
    ui_update(g->p->u);
    if (g->p->f & PF_DEAD) game_switch(g);
  }
}

void game_quit(game_state *g) { g->f |= GF_QUIT; }

static void addplayer(game_state *g, int x, int y)
{
  game_player *p = CREATE(game_player);
  p->f = 0;
  p->x = x;
  p->y = y;
  p->u = ui_start(g->l, x, y);
  p->next = 0;
  p->prev = g->ptail;
  if (g->ptail) g->ptail->next = p; else g->p = p;
  g->ptail = p;
}

void game_go(level *l)
{
  game_state g;
  int x, y;

  g.l = lev_copy(l);
  lev_write(g.l, stdout);
  g.f = 0;
  g.ptail = 0;
  lev_findcell(l, C_PLAYER, &x, &y);
  addplayer(&g, x, y);
  if (lev_findcell(l, C_SPARE, &x, &y)) {
    do
      addplayer(&g, x, y);
    while (lev_findnext(l, C_SPARE, &x, &y));
  }
  undo_init(&g);
  ui_switch(g.p->u);
  while (!(g.f & GF_QUIT)) {
    undo_begin(&g);
    ui_go(&g, g.p->u);
    undo_commit(&g);
  }
  lev_free(g.l);
  undo_free(&g);
}

/*----- That's all, folks -------------------------------------------------*/