/*********************************************/
/* you just keep on pushing my luck over the */
/*          BOULDER        DASH              */
/*                                           */
/*     Jeroen Houttuin, ETH Zurich, 1990     */
/*********************************************/

#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/Xutil.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include "xbd.h"

void
die(display, event)
  Display        *display;
  XErrorEvent    *event;
{
  char            buffer[BUFSIZ];
  XGetErrorText(display, event->error_code, buffer, BUFSIZ);
  (void) fprintf(stderr, "Display %s: Error %s\n",
		 XDisplayName(display), buffer);
  seteuid(getuid());
  do
  {
    (void) fprintf(stderr, "(R)eturn (D)ump Core (E)xit:");
    switch (fgetc(stdin))
    {
    case 'R':
    case 'r':
      return;
    case 'E':
    case 'e':
      exit(1);
      break;
    case 'D':
    case 'd':
      kill(0, 3);
      break;
    default:
      break;
    }
  } while (1);
}

void
init_vars()
{
  blobbreak = 100;
  critical = 100;
  blobcells = 0;
  curorder = STAND;
  gamestop = True;
  scoreobs = True;
  stoplevel = False;
  levelnum = 1;
  speed = 1;
  lives = 4;
  xin = 0;
  yin = 0;
  players = 1;
}

struct itimerval cycletime;	/* Structure used when setting up timer */
void
adapt_timer()
{
  long            period;

  if (speed <= 0)
    speed = 1;
  period = (long) 3 *(long) 625000 / speed;
  cycletime.it_interval.tv_sec = period / 1000000;
  cycletime.it_interval.tv_usec = period % 1000000;
  cycletime.it_value = cycletime.it_interval;
  setitimer(ITIMER_REAL, &cycletime, (struct itimerval *) NULL);
}

/* Handle a key stroke by the user. */
void
handle_key(keyhit)
  KeySym          keyhit;	/* Key symbol for key stroke provided by X
				 * windows */
{
  if (players <= 0)
  {
    init_level(levelnum);
    adapt_timer();
    XResizeWindow(disp, wind, x << 5, (y << 5) + SCORESIZE);
    stoplevel = False;
    draw_field(True);
    gamestop = True;
    players = 1;
    return;
  }
  switch (keyhit)
  {
  case XK_question:
  case XK_slash:
    puts("Control the player using keyboard keys.");
    puts("CTRL key - steal instead of go");
    puts("h,left arrow -  left");
    puts("l,right arrow -  right");
    puts("k,up arrow -  up");
    puts("j,down arrow -  down");
    puts("\nSPACE - pause/continue game");
    puts("^C - kill the game");
    puts("^D - give Dutch act");
    puts("^R - redraw the screen");
    break;
  case XK_space:
  case XK_R11:
    gamestop = !gamestop;
    break;
  case XK_Left:
  case XK_H:
  case XK_h:
    curorder = LEFT;
    gamestop = False;
    break;
  case XK_Up:
  case XK_K:
  case XK_k:
    curorder = UP;
    gamestop = False;
    break;
  case XK_Down:
  case XK_J:
  case XK_j:
    curorder = DOWN;
    gamestop = False;
    break;
  case XK_Right:
  case XK_L:
  case XK_l:
    curorder = RIGHT;
    gamestop = False;
    break;
  }
}

/**** Timer  procedures  ****/

/* Function which is called whenever the timer signal goes off */
void
ticker(sig)
  int             sig;
{
  signal(SIGALRM, SIG_IGN);
  /* Ignore any signal which is not an alarm.  Ignore alarm signals */
  /* after a new level has been drawn until a key is hit. */
  if (sig != SIGALRM)
    return;
  if (tleft)
    tleft--;
  if (tinkact)
    tinkdur--;
  if (tleft % 10 == 1)
    scoreobs = True;

  if (!gamestop)
  {
    calculate_field();
    draw_field(0);
    XFlush(disp);
  }
  if (stoplevel)
  {
    init_level(levelnum);
    adapt_timer();
    XResizeWindow(disp, wind, x << 5, (y << 5) + SCORESIZE);
    XFlush(disp);
    gamestop = True;
    stoplevel = False;
  }
  signal(SIGALRM, ticker);
}
/**** End timer procedures ****/

void
main(argc, argv)
  int             argc;
  char          **argv;
{
  long            period;
  KeySym          keyhit;
  char            buf[50];
  static XEvent   xev;
  int             keycount, i;

  printf("type ? for help.\n");

  init_vars();

  /* scan the command line for executing parameters and flags */
  for (i = 1; i < argc; ++i)
  {
    if (argv[i][0] == '-')
    {
      if (argv[i][1] == 'l')
      {
	if (argv[i][2] == '\0' && i + 1 < argc)
	{
	  sscanf(argv[i + 1], "%d", &levelnum);
	  i++;
	} else
	  sscanf(argv[i] + 2, "%d", &levelnum);
      } else
      {
	printf("usage: xbd [-l <level>] \n");
	exit(1);
      }
    }
  }

  levelstart = levelnum;
  init_level(levelnum);
  xstart(EVMASK);
  XSetErrorHandler(die);
  XStoreName(disp, wind, "BOULDER DASH ?");
  make_gcs();
  draw_field(True);
  draw_score();

  /* initialize timer structure according to speed */
  if (speed <= 0)
    speed = 1;
  period = (long) 3 *(long) 625000 / speed;
  cycletime.it_interval.tv_sec = period / 1000000;
  cycletime.it_interval.tv_usec = period % 1000000;
  cycletime.it_value = cycletime.it_interval;
  /* start the system timer.  the timer signal catcher will be set */
  /* after the first x event is received. */
  signal(SIGALRM, SIG_IGN);
  setitimer(ITIMER_REAL, &cycletime, (struct itimerval *) NULL);

  while (lives > 0)		/* MAIN LOOP */
  {
    XWindowEvent(disp, wind, EVMASK, &xev);
    signal(SIGALRM, SIG_IGN);
    if ((xev.type == Expose && xev.xexpose.count == 0))
    {
      draw_field(True);
      draw_score();
    } else if (xev.type == KeyPress)
    {
      keycount = XLookupString(&xev, buf, 50, &keyhit, (XComposeStatus *) NULL);
      if (steal = (xev.xkey.state & ControlMask))
	switch (keyhit)
	{
	  /* ^C, ^U kill the game */
	case XK_C:
	case XK_U:
	case XK_c:
	case XK_u:
	case XK_backslash:
	  goto game_over;
	  /* ^D Kill; commit suicide */
	case XK_D:
	case XK_d:
	  curorder = KILL;
	  /* ^R redraws the level */
	case XK_R:
	case XK_r:
	  draw_field(True);
	  break;
	default:
	  handle_key(keyhit);
	  break;
	}
      else
	handle_key(keyhit);
    }
    if (!gamestop)
    {
      XSync(disp, False);
      signal(SIGALRM, ticker);
    }
  }
game_over:
  XSync(disp, False);
  xend();
  add_score();
}