Initial checkin. Not there yet.

[xor] / undo.c

/* -*-c-*-
 *
 * $Id: undo.c,v 1.1 2003/12/12 10:55:30 mdw Exp $
 *
 * Management of undo records
 *
 * (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: undo.c,v $
 * Revision 1.1  2003/12/12 10:55:30  mdw
 * Initial checkin.  Not there yet.
 *
 */

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

#include "xor.h"

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

void undo_init(game_state *g)
{
  g->u = g->r = g->m = 0;
}

void undo_begin(game_state *g)
{
  undo_move *u = CREATE(undo_move);
  u->next = 0;
  u->act = 0;
  g->m = u;
}

void undo_cell(game_state *g, int x, int y, int c)
{
  undo_action *a, **aa;

  for (aa = &g->m->act; *aa; aa = &a->next) {
    a = *aa;
    if (a->type == A_CELL && a->u.c.x == x && a->u.c.y == y) {
      if (a->u.c.c == c) {
	*aa = a->next;
	DESTROY(a);
      }
      return;
    }
  }
  if (c == CELL(g->l, x, y)) return;
  a = CREATE(undo_action);
  a->next = 0;
  *aa = a;
  a->type = A_CELL;
  a->u.c.x = x;
  a->u.c.y = y;
  a->u.c.c = CELL(g->l, x, y);
}

void undo_die(game_state *g, game_player *p)
{
  undo_action *a = CREATE(undo_action);

  a->next = g->m->act;
  a->type = A_DIE;
  a->u.p = p;
  g->m->act = a;
}

void undo_levelf(game_state *g)
{
  undo_action *a = CREATE(undo_action);

  a->next = g->m->act;
  a->type = A_LEVEL;
  a->u.f = g->l->f;
  g->m->act = a;
}

void undo_mask(game_state *g)
{
  undo_action *a = CREATE(undo_action);

  a->next = g->m->act;
  a->type = A_MASK;
  a->u.n = g->l->m;
  g->m->act = a;
}

void undo_pmove(game_state *g)
{
  undo_action *a = CREATE(undo_action);

  a->next = g->m->act;
  a->type = A_MOVE;
  a->u.c.x = g->p->x;
  a->u.c.y = g->p->y;
  g->m->act = a;
}

void undo_switch(game_state *g)
{
  undo_action *a = CREATE(undo_action);
  a->next = g->m->act;
  a->type = A_SWITCH;
  a->u.p = g->p;
  g->m->act = a;
}

static void freelist(undo_move **mm)
{
  undo_move *u, *uu;
  undo_action *a, *aa;

  for (u = *mm; u; u = uu) {
    uu = u->next;
    for (a = u->act; a; a = aa) {
      aa = a->next;
      DESTROY(a);
    }
    DESTROY(u);
  }
  *mm = 0;
}

void undo_commit(game_state *g)
{
  if (!g->m->act)
    DESTROY(g->m);
  else {
    g->m->next = g->u;
    g->u = g->m;
    freelist(&g->r);
  }
  g->m = 0;
}

static int do_undo(game_state *g, undo_move **m, undo_move **mm)
{
  undo_move *u = *m;
  undo_action *a;
  game_player *p;
  int x, y, c;
  unsigned f;

  if (!u) return (0);
  *m = u->next;

  for (a = u->act; a; a = a->next) {
    switch (a->type) {
      case A_CELL:
	c = a->u.c.c;
	a->u.c.c = CELL(g->l, a->u.c.x, a->u.c.y);
	CELLSET(g->l, a->u.c.x, a->u.c.y, c);
	break;
      case A_DIE:
	a->u.p->f &= ~PF_DEAD;
	a->type = A_LIVE;
	break;
      case A_MASK:
	c = a->u.n;
	a->u.n = g->l->m;
	g->l->m = c;
	break;
      case A_LEVEL:
	f = a->u.f;
	a->u.f = g->l->f;
	g->l->f = f;
	break;
      case A_MOVE:
	x = a->u.c.x;
	y = a->u.c.y;
	a->u.c.x = g->p->x;
	a->u.c.y = g->p->y;
	g->p->x = x;
	g->p->y = y;
	break;
      case A_LIVE:
	a->u.p->f |= PF_DEAD;
	a->type = A_DIE;
	break;
      case A_SWITCH:
	p = a->u.p;
	a->u.p = g->p;
	game_switchto(g, p);
	break;
      default:
	abort();
    }
  }
  
  u->next = *mm;
  *mm = u;
  return (1);
}

void undo(game_state *g)
{
  if (do_undo(g, &g->u, &g->r)) g->l->v--;
  ui_update(g->p->u);
}

void redo(game_state *g)
{
  if (do_undo(g, &g->r, &g->u)) g->l->v++;
  ui_update(g->p->u);
}

void undo_free(game_state *g)
{
  freelist(&g->m);
  freelist(&g->u);
  freelist(&g->r);
}

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