maze.c File Reference

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <windows.h>

Include dependency graph for maze.c:

Go to the source code of this file.

Macros
#define	STRICT
#define	APIENTRY   far pascal
#define	DLGPROC   FARPROC
#define	MAX_MAZE_SIZE_X   ((unsigned long) 250)
#define	MAX_MAZE_SIZE_Y   ((unsigned long) 250)
#define	MOVE_LIST_SIZE   (MAX_MAZE_SIZE_X * MAX_MAZE_SIZE_Y)
#define	WALL_TOP   0x8000
#define	WALL_RIGHT   0x4000
#define	WALL_BOTTOM   0x2000
#define	WALL_LEFT   0x1000
#define	DOOR_IN_TOP   0x800
#define	DOOR_IN_RIGHT   0x400
#define	DOOR_IN_BOTTOM   0x200
#define	DOOR_IN_LEFT   0x100
#define	DOOR_IN_ANY   0xF00
#define	DOOR_OUT_TOP   0x80
#define	DOOR_OUT_RIGHT   0x40
#define	DOOR_OUT_BOTTOM   0x20
#define	DOOR_OUT_LEFT   0x10
#define	START_SQUARE   0x2
#define	END_SQUARE   0x1
#define	border_x   (0)
#define	border_y   (0)
#define	get_random(x)   (rand() % (x))

Functions
static BOOL	InitApplication (HINSTANCE hInstance)
static BOOL	InitInstance (HINSTANCE hInstance, int nCmdShow)
LRESULT CALLBACK	WndProc (HWND hWnd, UINT message, WPARAM uParam, LPARAM lParam)
static void	set_maze_sizes (int width, int height)
static void	initialize_maze ()
static int	choose_door ()
static long	backup ()
static void	draw_wall ()
static void	draw_solid_square (int, int, int, HDC, HBRUSH)
static void	enter_square (int, HDC, HBRUSH)
static void	create_maze ()
static int	choose_door (HDC hDC)
static void	draw_maze_border (HWND hWnd, HDC hDC)
static void	draw_wall (int i, int j, int dir, HDC hDC)
static void	begin_solve_maze ()
static int	solve_maze ()
static void	start_timer (HWND hWnd, int iTimeout)
int APIENTRY	WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
static BOOL	OnCreate (HWND hWnd, LPCREATESTRUCT lpCreateStruct)
void	OnTimer (HWND hwnd, UINT id)

Variables
HINSTANCE	hInst
HWND	hWnd
HBRUSH	hBrushDead
HBRUSH	hBrushLiving
HDC	hDC
static BOOL	waiting
char	szAppName [] = "Maze"
char	szTitle [] = "Maze"
static int	solve_delay
static int	pre_solve_delay
static int	post_solve_delay
static unsigned short	maze [MAX_MAZE_SIZE_X][MAX_MAZE_SIZE_Y]
struct {
unsigned char   x
unsigned char   y
unsigned char   dir
unsigned char   dummy
}	move_list [MOVE_LIST_SIZE]
struct {
unsigned char   x
unsigned char   y
unsigned char   dir
unsigned char   dummy
}	save_path [MOVE_LIST_SIZE]
struct {
unsigned char   x
unsigned char   y
unsigned char   dir
unsigned char   dummy
}	path [MOVE_LIST_SIZE]
static int	maze_size_x
static int	maze_size_y
static long	sqnum
static long	path_length
static int	cur_sq_x
static int	cur_sq_y
static int	start_x
static int	start_y
static int	start_dir
static int	end_x
static int	end_y
static int	end_dir
static int	grid_width
static int	grid_height
static int	state = 1
static int	pathi = 0
int	bw

Macro Definition Documentation

APIENTRY

#define APIENTRY   far pascal

Definition at line 58 of file maze.c.

border_x

#define border_x   (0)

Definition at line 107 of file maze.c.

border_y

#define border_y   (0)

Definition at line 108 of file maze.c.

DLGPROC

#define DLGPROC   FARPROC

Definition at line 62 of file maze.c.

DOOR_IN_ANY

#define DOOR_IN_ANY   0xF00

Definition at line 97 of file maze.c.

DOOR_IN_BOTTOM

#define DOOR_IN_BOTTOM   0x200

Definition at line 95 of file maze.c.

DOOR_IN_LEFT

#define DOOR_IN_LEFT   0x100

Definition at line 96 of file maze.c.

DOOR_IN_RIGHT

#define DOOR_IN_RIGHT   0x400

Definition at line 94 of file maze.c.

DOOR_IN_TOP

#define DOOR_IN_TOP   0x800

Definition at line 93 of file maze.c.

DOOR_OUT_BOTTOM

#define DOOR_OUT_BOTTOM   0x20

Definition at line 101 of file maze.c.

DOOR_OUT_LEFT

#define DOOR_OUT_LEFT   0x10

Definition at line 102 of file maze.c.

DOOR_OUT_RIGHT

#define DOOR_OUT_RIGHT   0x40

Definition at line 100 of file maze.c.

DOOR_OUT_TOP

#define DOOR_OUT_TOP   0x80

Definition at line 99 of file maze.c.

END_SQUARE

#define END_SQUARE   0x1

Definition at line 105 of file maze.c.

get_random

#define get_random

(

x

)

(rand() % (x))

Definition at line 110 of file maze.c.

MAX_MAZE_SIZE_X

#define MAX_MAZE_SIZE_X   ((unsigned long) 250)

Definition at line 83 of file maze.c.

MAX_MAZE_SIZE_Y

#define MAX_MAZE_SIZE_Y   ((unsigned long) 250)

Definition at line 84 of file maze.c.

MOVE_LIST_SIZE

#define MOVE_LIST_SIZE   (MAX_MAZE_SIZE_X * MAX_MAZE_SIZE_Y)

Definition at line 86 of file maze.c.

START_SQUARE

#define START_SQUARE   0x2

Definition at line 104 of file maze.c.

STRICT

#define STRICT

Definition at line 50 of file maze.c.

WALL_BOTTOM

#define WALL_BOTTOM   0x2000

Definition at line 90 of file maze.c.

WALL_LEFT

#define WALL_LEFT   0x1000

Definition at line 91 of file maze.c.

WALL_RIGHT

#define WALL_RIGHT   0x4000

Definition at line 89 of file maze.c.

WALL_TOP

#define WALL_TOP   0x8000

Definition at line 88 of file maze.c.

Function Documentation

backup()

static long backup ( )

static

Definition at line 367 of file maze.c.

{
  sqnum--;
  if (0 <= sqnum) {
    cur_sq_x = move_list[sqnum].x;
    cur_sq_y = move_list[sqnum].y;
  }
  return ( sqnum );
}

begin_solve_maze()

static void begin_solve_maze ( )

static

Definition at line 487 of file maze.c.

{
  static long grayPattern[] = {
    0x55555555,
    0xaaaaaaaa,
    0x55555555,
    0xaaaaaaaa,
    0x55555555,
    0xaaaaaaaa,
    0x55555555,
    0xaaaaaaaa
  };
  static RGBQUAD argbq[] = {
    { 0, 0, 255, 0 },
    { 255, 255, 255, 0 }
  };
  BITMAPINFO *pbmi;
 
  hDC = GetDC(hWnd);
  pbmi = malloc(sizeof(BITMAPINFOHEADER) + sizeof(argbq) + sizeof(grayPattern));
  pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  pbmi->bmiHeader.biWidth = 8;
  pbmi->bmiHeader.biHeight = 8;
  pbmi->bmiHeader.biPlanes = 1;
  pbmi->bmiHeader.biBitCount = 1;
  pbmi->bmiHeader.biCompression = BI_RGB;
  (void) memcpy(pbmi->bmiColors, argbq, sizeof(argbq));
  (void) memcpy(pbmi->bmiColors + 2, grayPattern, sizeof(grayPattern));
#if 0
  /* FIXME Pattern brushes not yet implemented in ReactOS */
  hBrushDead = CreateDIBPatternBrushPt(pbmi, DIB_RGB_COLORS);
#else
  hBrushDead = CreateSolidBrush(RGB(255, 0, 0));
#endif
//  hBrushDead = CreateHatchBrush(HS_DIAGCROSS, RGB(255, 0, 0));
  free(pbmi);
  hBrushLiving = CreateSolidBrush(RGB(0, 255, 0));
 
  /* plug up the surrounding wall */
  maze[start_x][start_y] |= (WALL_TOP >> start_dir);
  maze[end_x][end_y] |= (WALL_TOP >> end_dir);
 
  /* initialize search path */
  pathi = 0;
  path[pathi].x = end_x;
  path[pathi].y = end_y;
  path[pathi].dir = -1;
}

Referenced by ScreenSaverProc(), and WinMain().

choose_door() [1/2]

static int choose_door ( )

static

choose_door() [2/2]

static int choose_door ( HDC  hDC )

static

Definition at line 286 of file maze.c.

{
  int candidates[3];
  register int num_candidates;
 
  num_candidates = 0;
 
  /* top wall */
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_IN_TOP )
    goto rightwall;
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_OUT_TOP )
    goto rightwall;
  if ( maze[cur_sq_x][cur_sq_y] & WALL_TOP )
    goto rightwall;
  if ( maze[cur_sq_x][cur_sq_y - 1] & DOOR_IN_ANY ) {
    maze[cur_sq_x][cur_sq_y] |= WALL_TOP;
    maze[cur_sq_x][cur_sq_y - 1] |= WALL_BOTTOM;
    draw_wall(cur_sq_x, cur_sq_y, 0, hDC);
    goto rightwall;
  }
  candidates[num_candidates++] = 0;
 
 rightwall:
  /* right wall */
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_IN_RIGHT )
    goto bottomwall;
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_OUT_RIGHT )
    goto bottomwall;
  if ( maze[cur_sq_x][cur_sq_y] & WALL_RIGHT )
    goto bottomwall;
  if ( maze[cur_sq_x + 1][cur_sq_y] & DOOR_IN_ANY ) {
    maze[cur_sq_x][cur_sq_y] |= WALL_RIGHT;
    maze[cur_sq_x + 1][cur_sq_y] |= WALL_LEFT;
    draw_wall(cur_sq_x, cur_sq_y, 1, hDC);
    goto bottomwall;
  }
  candidates[num_candidates++] = 1;
 
 bottomwall:
  /* bottom wall */
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_IN_BOTTOM )
    goto leftwall;
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_OUT_BOTTOM )
    goto leftwall;
  if ( maze[cur_sq_x][cur_sq_y] & WALL_BOTTOM )
    goto leftwall;
  if ( maze[cur_sq_x][cur_sq_y + 1] & DOOR_IN_ANY ) {
    maze[cur_sq_x][cur_sq_y] |= WALL_BOTTOM;
    maze[cur_sq_x][cur_sq_y + 1] |= WALL_TOP;
    draw_wall(cur_sq_x, cur_sq_y, 2, hDC);
    goto leftwall;
  }
  candidates[num_candidates++] = 2;
 
 leftwall:
  /* left wall */
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_IN_LEFT )
    goto donewall;
  if ( maze[cur_sq_x][cur_sq_y] & DOOR_OUT_LEFT )
    goto donewall;
  if ( maze[cur_sq_x][cur_sq_y] & WALL_LEFT )
    goto donewall;
  if ( maze[cur_sq_x - 1][cur_sq_y] & DOOR_IN_ANY ) {
    maze[cur_sq_x][cur_sq_y] |= WALL_LEFT;
    maze[cur_sq_x - 1][cur_sq_y] |= WALL_RIGHT;
    draw_wall(cur_sq_x, cur_sq_y, 3, hDC);
    goto donewall;
  }
  candidates[num_candidates++] = 3;
 
 donewall:
  if (num_candidates == 0)
    return ( -1 );
  if (num_candidates == 1)
    return ( candidates[0] );
  return ( candidates[ get_random(num_candidates) ] );
 
}

create_maze()

static void create_maze ( )

static

Definition at line 235 of file maze.c.

{
  register int i, newdoor = 0;
  HDC hDC;
 
  hDC = GetDC(hWnd);
  do {
    move_list[sqnum].x = cur_sq_x;
    move_list[sqnum].y = cur_sq_y;
    move_list[sqnum].dir = newdoor;
    while ( ( newdoor = choose_door(hDC) ) == -1 ) { /* pick a door */
      if ( backup() == -1 ) { /* no more doors ... backup */
        ReleaseDC(hWnd, hDC);
        return; /* done ... return */
      }
    }
 
    /* mark the out door */
    maze[cur_sq_x][cur_sq_y] |= ( DOOR_OUT_TOP >> newdoor );
 
    switch (newdoor) {
    case 0: cur_sq_y--;
      break;
    case 1: cur_sq_x++;
      break;
    case 2: cur_sq_y++;
      break;
    case 3: cur_sq_x--;
      break;
    }
    sqnum++;
 
    /* mark the in door */
    maze[cur_sq_x][cur_sq_y] |= ( DOOR_IN_TOP >> ((newdoor+2)%4) );
 
    /* if end square set path length and save path */
    if ( maze[cur_sq_x][cur_sq_y] & END_SQUARE ) {
      path_length = sqnum;
      for ( i=0; i<path_length; i++) {
    save_path[i].x = move_list[i].x;
    save_path[i].y = move_list[i].y;
    save_path[i].dir = move_list[i].dir;
      }
    }
 
  } while (1);
 
}

Referenced by ScreenSaverProc(), and WinMain().

draw_maze_border()

static void draw_maze_border ( HWND  hWnd, HDC  hDC  )

static

Definition at line 417 of file maze.c.

{
  register int i, j;
  HBRUSH hBrush;
 
 
  for ( i=0; i<maze_size_x; i++) {
    if ( maze[i][0] & WALL_TOP ) {
      MoveToEx(hDC, border_x + grid_width * i, border_y, NULL);
      (void) LineTo(hDC, border_x + grid_width * (i + 1) - 1, border_y);
    }
    if ((maze[i][maze_size_y - 1] & WALL_BOTTOM)) {
      MoveToEx(hDC, border_x + grid_width * i,
               border_y + grid_height * (maze_size_y) - 1, NULL);
      (void) LineTo(hDC, border_x + grid_width * (i+1) - 1,
                    border_y + grid_height * (maze_size_y) - 1);
    }
  }
  for ( j=0; j<maze_size_y; j++) {
    if ( maze[maze_size_x - 1][j] & WALL_RIGHT ) {
      MoveToEx(hDC, border_x + grid_width * maze_size_x - 1,
               border_y + grid_height * j, NULL);
      (void) LineTo(hDC, border_x + grid_width * maze_size_x - 1,
                    border_y + grid_height * (j+1) - 1);
    }
    if ( maze[0][j] & WALL_LEFT ) {
      MoveToEx(hDC, border_x, border_y + grid_height * j, NULL);
      (void) LineTo(hDC, border_x, border_y + grid_height * (j+1) - 1);
    }
  }
 
  hBrush = GetStockObject(BLACK_BRUSH);
  draw_solid_square (start_x, start_y, start_dir, hDC, hBrush);
  draw_solid_square (end_x, end_y, end_dir, hDC, hBrush);
}

draw_solid_square()

static void draw_solid_square ( int  i, int  j, int  dir, HDC  hDC, HBRUSH  hBrush  )

static

Definition at line 380 of file maze.c.

{
  RECT rc;
 
  switch (dir) {
  case 0:
    rc.left = border_x + bw + grid_width * i;
    rc.right = rc.left + grid_width - (bw + bw);
    rc.top = border_y - bw + grid_height * j;
    rc.bottom = rc.top + grid_height;
    break;
  case 1:
    rc.left = border_x + bw + grid_width * i;
    rc.right = rc.left + grid_width;
    rc.top = border_y + bw + grid_height * j;
    rc.bottom = rc.top + grid_height - (bw + bw);
    break;
  case 2:
    rc.left = border_x + bw + grid_width * i;
    rc.right = rc.left + grid_width - (bw + bw);
    rc.top = border_y + bw + grid_height * j;
    rc.bottom = rc.top + grid_height;
    break;
  case 3:
    rc.left = border_x - bw + grid_width * i;
    rc.right = rc.left + grid_width;
    rc.top = border_y + bw + grid_height * j;
    rc.bottom = rc.top + grid_height - (bw + bw);
    break;
  }
  (void) FillRect(hDC, &rc, hBrush);
}

draw_wall() [1/2]

static void draw_wall ( )

static

draw_wall() [2/2]

static void draw_wall ( int  i, int  j, int  dir, HDC  hDC  )

static

Definition at line 455 of file maze.c.

{
  switch (dir) {
  case 0:
    MoveToEx(hDC, border_x + grid_width * i, border_y + grid_height * j, NULL);
    (void) LineTo(hDC, border_x + grid_width * (i+1),
                  border_y + grid_height * j);
    break;
  case 1:
    MoveToEx(hDC, border_x + grid_width * (i+1), border_y + grid_height * j,
             NULL);
    (void) LineTo(hDC, border_x + grid_width * (i+1),
                  border_y + grid_height * (j+1));
    break;
  case 2:
    MoveToEx(hDC, border_x + grid_width * i, border_y + grid_height * (j+1),
             NULL);
    (void) LineTo(hDC, border_x + grid_width * (i+1),
                  border_y + grid_height * (j+1));
    break;
  case 3:
    MoveToEx(hDC, border_x + grid_width * i, border_y + grid_height * j,
             NULL);
    (void) LineTo(hDC, border_x + grid_width * i,
                  border_y + grid_height * (j+1));
    break;
  }
}

enter_square()

static void enter_square ( int  n, HDC  hDC, HBRUSH  hBrush  )

static

Definition at line 574 of file maze.c.

{
  draw_solid_square( (int)path[n].x, (int)path[n].y,
            (int)path[n].dir, hDC, hBrush);
 
  path[n+1].dir = -1;
  switch (path[n].dir) {
  case 0: path[n+1].x = path[n].x;
    path[n+1].y = path[n].y - 1;
    break;
  case 1: path[n+1].x = path[n].x + 1;
    path[n+1].y = path[n].y;
    break;
  case 2: path[n+1].x = path[n].x;
    path[n+1].y = path[n].y + 1;
    break;
  case 3: path[n+1].x = path[n].x - 1;
    path[n+1].y = path[n].y;
    break;
  }
}

InitApplication()

static BOOL InitApplication ( HINSTANCE  hInstance )

static

Definition at line 750 of file maze.c.

{
    WNDCLASS  wc;
 
    // Fill in window class structure with parameters that describe the
    // main window.
 
    wc.style         = CS_HREDRAW | CS_VREDRAW;// Class style(s).
    wc.lpfnWndProc   = (WNDPROC)WndProc;       // Window Procedure
    wc.cbClsExtra    = 0;                      // No per-class extra data.
    wc.cbWndExtra    = 0;                      // No per-window extra data.
    wc.hInstance     = hInstance;              // Owner of this class
    wc.hIcon         = LoadIcon (hInstance, szAppName); // Icon name from .RC
    wc.hCursor       = LoadCursor(NULL, (LPCTSTR) IDC_ARROW);// Cursor
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);// Default color
    wc.lpszMenuName  = NULL;                    // No menu
    wc.lpszClassName = szAppName;              // Name to register as
 
    // Register the window class and return success/failure code.
    return (RegisterClass(&wc));
}

Referenced by WinMain().

initialize_maze()

static void initialize_maze ( )

static

Definition at line 139 of file maze.c.

{
  register int i, j, wall;
 
  /* initialize all squares */
  for ( i=0; i<maze_size_x; i++) {
    for ( j=0; j<maze_size_y; j++) {
      maze[i][j] = 0;
    }
  }
 
  /* top wall */
  for ( i=0; i<maze_size_x; i++ ) {
    maze[i][0] |= WALL_TOP;
  }
 
  /* right wall */
  for ( j=0; j<maze_size_y; j++ ) {
    maze[maze_size_x-1][j] |= WALL_RIGHT;
  }
 
  /* bottom wall */
  for ( i=0; i<maze_size_x; i++ ) {
    maze[i][maze_size_y-1] |= WALL_BOTTOM;
  }
 
  /* left wall */
  for ( j=0; j<maze_size_y; j++ ) {
    maze[0][j] |= WALL_LEFT;
  }
 
  /* set start square */
  wall = get_random(4);
  switch (wall) {
  case 0:
    i = get_random(maze_size_x);
    j = 0;
    break;
  case 1:
    i = maze_size_x - 1;
    j = get_random(maze_size_y);
    break;
  case 2:
    i = get_random(maze_size_x);
    j = maze_size_y - 1;
    break;
  case 3:
    i = 0;
    j = get_random(maze_size_y);
    break;
  }
  maze[i][j] |= START_SQUARE;
  maze[i][j] |= ( DOOR_IN_TOP >> wall );
  maze[i][j] &= ~( WALL_TOP >> wall );
  cur_sq_x = i;
  cur_sq_y = j;
  start_x = i;
  start_y = j;
  start_dir = wall;
  sqnum = 0;
 
  /* set end square */
  wall = (wall + 2)%4;
  switch (wall) {
  case 0:
    i = get_random(maze_size_x);
    j = 0;
    break;
  case 1:
    i = maze_size_x - 1;
    j = get_random(maze_size_y);
    break;
  case 2:
    i = get_random(maze_size_x);
    j = maze_size_y - 1;
    break;
  case 3:
    i = 0;
    j = get_random(maze_size_y);
    break;
  }
  maze[i][j] |= END_SQUARE;
  maze[i][j] |= ( DOOR_OUT_TOP >> wall );
  maze[i][j] &= ~( WALL_TOP >> wall );
  end_x = i;
  end_y = j;
  end_dir = wall;
}

InitInstance()

static BOOL InitInstance ( HINSTANCE  hInstance, int  nCmdShow  )

static

Definition at line 790 of file maze.c.

{
    /* Save the instance handle in static variable, which will be used in
       many subsequence calls from this application to Windows. */
 
    hInst = hInstance; /* Store instance handle in our global variable */
 
    /* Create a main window for this application instance. */
 
    hWnd = CreateWindow(
        szAppName,          /* See RegisterClass() call. */
        szTitle,            /* Text for window title bar. */
        WS_OVERLAPPEDWINDOW,/* Window style. */
        0, 0, CW_USEDEFAULT, CW_USEDEFAULT, /* Use default positioning */
        NULL,               /* Overlapped windows have no parent. */
        NULL,               /* Use the window class menu. */
        hInstance,          /* This instance owns this window. */
        NULL                /* We don't use any data in our WM_CREATE */
    );
 
    // If window could not be created, return "failure"
    if (!hWnd) {
        return (FALSE);
    }
 
    // Make the window visible; update its client area; and return "success"
    ShowWindow(hWnd, nCmdShow); // Show the window
    UpdateWindow(hWnd);         // Sends WM_PAINT message
 
    return (TRUE);              // We succeeded...
 
}

Referenced by WinMain().

OnCreate()

static BOOL OnCreate ( HWND  hWnd, LPCREATESTRUCT  lpCreateStruct  )

static

Definition at line 826 of file maze.c.

{
    RECT rc;
    int size;
 
    srand((unsigned) time(NULL));
 
    size = GetPrivateProfileIntA("maze", "gridsize", 10, "maze.ini");
    pre_solve_delay = GetPrivateProfileIntA("maze", "predelay", 5000, "maze.ini");
    post_solve_delay = GetPrivateProfileIntA("maze", "postdelay", 5000, "maze.ini");
    solve_delay = GetPrivateProfileIntA("maze", "solvedelay", 1, "maze.ini");
 
    if (size < 2) {
        size = 7 + (rand() % 30);
    }
    grid_width = grid_height = size;
    bw = (size > 6 ? 3 : (size-1)/2);
 
    GetClientRect(hWnd, &rc);
    set_maze_sizes(rc.right - rc.left, rc.bottom - rc.top);
 
    return TRUE;
}

OnTimer()

void OnTimer	(	HWND	hwnd,
		UINT	id
	)

Definition at line 850 of file maze.c.

{
    waiting = FALSE;
}

Referenced by WndProc().

set_maze_sizes()

static void set_maze_sizes ( int  width, int  height  )

static

Definition at line 130 of file maze.c.

{
  maze_size_x = width / grid_width;
  maze_size_y = height / grid_height;
}

solve_maze()

static int solve_maze ( )

static

Definition at line 537 of file maze.c.

{
  int ret;
  int action_done;
 
  do {
    action_done = 1;
    if ( ++path[pathi].dir >= 4 ) {
      pathi--;
      draw_solid_square( (int)(path[pathi].x), (int)(path[pathi].y),
               (int)(path[pathi].dir), hDC, hBrushDead);
      ret = 0;
    }
    else if ( ! (maze[path[pathi].x][path[pathi].y] &
        (WALL_TOP >> path[pathi].dir))  &&
         ( (pathi == 0) || ( (path[pathi].dir !=
                (int)(path[pathi-1].dir+2)%4) ) ) ) {
      enter_square(pathi, hDC, hBrushLiving);
      pathi++;
      if ( maze[path[pathi].x][path[pathi].y] & START_SQUARE ) {
        DeleteObject(hBrushLiving);
        DeleteObject(hBrushDead);
        ReleaseDC(hWnd, hDC);
          ret = 1;
      } else {
        ret = 0;
      }
    } else {
      action_done = 0;
    }
  } while (! action_done);
 
  return ret;
}

Referenced by ScreenSaverProc(), and WinMain().

start_timer()

static void start_timer ( HWND  hWnd, int  iTimeout  )

static

Definition at line 597 of file maze.c.

{
    waiting = TRUE;
    SetTimer(hWnd, 1, iTimeout, NULL);
}

WinMain()

int APIENTRY WinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInstance,
		LPSTR	lpCmdLine,
		int	nCmdShow
	)

Definition at line 624 of file maze.c.

{
    MSG msg;
    HDC hDC;
 
    if (!hPrevInstance) {           /* Other instances of app running? */
            if (!InitApplication(hInstance)) { /* Initialize shared things */
            return (FALSE);         /* Exits if unable to initialize */
        }
    }
 
    /* Perform initializations that apply to a specific instance */
 
    if (!InitInstance(hInstance, nCmdShow)) {
        return (FALSE);
    }
 
    waiting = FALSE;
    state = 1;
 
    /* Acquire and dispatch messages until a WM_QUIT message is received. */
 
    while (0 != state) {
        if (waiting) {
            (void) WaitMessage();
        }
        while (0 != state && PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            if (WM_QUIT == msg.message) {
                state = 0;
            } else {
                DispatchMessage(&msg); /* Dispatches message to window */
            }
        }
            switch (state) {
            case 1:
                initialize_maze();
            state = 2;
                break;
            case 2:
            hDC = GetDC(hWnd);
            SendMessage(hWnd, WM_ERASEBKGND, (WPARAM) hDC, (LPARAM) 0);
            draw_maze_border(hWnd, hDC);
            ReleaseDC(hWnd, hDC);
            state = 3;
                break;
            case 3:
            create_maze();
            state = 4;
            break;
            case 4:
            start_timer(hWnd, pre_solve_delay);
            state = 5;
            break;
        case 5:
            if (! waiting) {
                state = 6;
            }
            break;
            case 6:
            begin_solve_maze();
            if (0 != solve_delay) {
                start_timer(hWnd, solve_delay);
                state = 7;
            } else {
                state = 8;
            }
            break;
        case 7:
            if (! waiting) {
                state = 8;
            }
            break;
        case 8:
            if (! solve_maze()) {
                if (0 != solve_delay) {
                    start_timer(hWnd, solve_delay);
                    state = 7;
                }
            } else {
                state = 9;
            }
            break;
        case 9:
            start_timer(hWnd, post_solve_delay);
            state = 10;
            break;
        case 10:
            if (! waiting) {
                state = 11;
            }
            break;
        case 11:
            state = 1;
            break;
        }
    }
 
    return (msg.wParam); /* Returns the value from PostQuitMessage */
}

WndProc()

LRESULT CALLBACK WndProc	(	HWND	hWnd,
		UINT	message,
		WPARAM	uParam,
		LPARAM	lParam
	)

Definition at line 869 of file maze.c.

{
    PAINTSTRUCT ps;
 
    switch (message) {
        case WM_CREATE:
            OnCreate(hWnd, (LPCREATESTRUCT) lParam);
            break;
        case WM_PAINT:
            BeginPaint(hWnd, &ps);
            state = 1;
            EndPaint(hWnd, &ps);
        case WM_TIMER:
            OnTimer(hWnd, wParam);
            break;
        case WM_DESTROY:  // message: window being destroyed
            PostQuitMessage(0);
            break;
 
        default:          // Passes it on if unproccessed
            return (DefWindowProc(hWnd, message, wParam, lParam));
    }
    return (0);
}

Referenced by InitApplication().

Variable Documentation

bw

int bw

Definition at line 377 of file maze.c.

cur_sq_x

int cur_sq_x

static

Definition at line 123 of file maze.c.

cur_sq_y

int cur_sq_y

static

Definition at line 123 of file maze.c.

dir

unsigned char dir

Definition at line 117 of file maze.c.

dummy

unsigned char dummy

Definition at line 118 of file maze.c.

end_dir

int end_dir

static

Definition at line 124 of file maze.c.

end_x

int end_x

static

Definition at line 124 of file maze.c.

end_y

int end_y

static

Definition at line 124 of file maze.c.

grid_height

int grid_height

static

Definition at line 125 of file maze.c.

grid_width

int grid_width

static

Definition at line 125 of file maze.c.

hBrushDead

HBRUSH hBrushDead

Definition at line 72 of file maze.c.

hBrushLiving

HBRUSH hBrushLiving

Definition at line 73 of file maze.c.

hDC

HDC hDC

Definition at line 74 of file maze.c.

hInst

HINSTANCE hInst

Definition at line 70 of file maze.c.

Referenced by InitInstance().

hWnd

HWND hWnd

Definition at line 71 of file maze.c.

maze

unsigned short maze[MAX_MAZE_SIZE_X][MAX_MAZE_SIZE_Y]

static

Definition at line 112 of file maze.c.

maze_size_x

int maze_size_x

static

Definition at line 121 of file maze.c.

maze_size_y

int maze_size_y

static

Definition at line 121 of file maze.c.

struct { ... } move_list[MOVE_LIST_SIZE]

struct { ... } path[MOVE_LIST_SIZE]

path_length

long path_length

static

Definition at line 122 of file maze.c.

pathi

int pathi = 0

static

Definition at line 127 of file maze.c.

post_solve_delay

int post_solve_delay

static

Definition at line 81 of file maze.c.

pre_solve_delay

int pre_solve_delay

static

Definition at line 81 of file maze.c.

struct { ... } save_path[MOVE_LIST_SIZE]

solve_delay

int solve_delay

static

Definition at line 81 of file maze.c.

sqnum

long sqnum

static

Definition at line 122 of file maze.c.

start_dir

int start_dir

static

Definition at line 124 of file maze.c.

start_x

int start_x

static

Definition at line 124 of file maze.c.

start_y

int start_y

static

Definition at line 124 of file maze.c.

state

int state = 1

static

Definition at line 127 of file maze.c.

szAppName

char szAppName[] = "Maze"

Definition at line 78 of file maze.c.

Referenced by InitApplication(), and InitInstance().

szTitle

char szTitle[] = "Maze"

Definition at line 79 of file maze.c.

Referenced by InitInstance().

waiting

BOOL waiting

static

Definition at line 75 of file maze.c.

Referenced by Draw_Sweep(), OnTimer(), start_timer(), and WinMain().

x

unsigned char x

Definition at line 115 of file maze.c.

y

unsigned char y

Definition at line 116 of file maze.c.