* [ maze ] ...
*
* modified: [ 03-08-15 ] Ge van Geldorp <ge@gse.nl>
- * ported to Reactos
+ * ported to ReactOS
* modified: [ 94-10-8 ] Ge van Geldorp <Ge.vanGeldorp@lr.tudelft.nl>
- * ported to MS Windows
+ * ported to MS Windows
* modified: [ 3-7-93 ] Jamie Zawinski <jwz@lucid.com>
- * added the XRoger logo, cleaned up resources, made
- * grid size a parameter.
+ * added the XRoger logo, cleaned up resources, made
+ * grid size a parameter.
* modified: [ 3-3-93 ] Jim Randell <jmr@mddjmr.fc.hp.com>
- * Added the colour stuff and integrated it with jwz's
- * screenhack stuff. There's still some work that could
- * be done on this, particularly allowing a resource to
- * specify how big the squares are.
+ * Added the colour stuff and integrated it with jwz's
+ * screenhack stuff. There's still some work that could
+ * be done on this, particularly allowing a resource to
+ * specify how big the squares are.
* modified: [ 10-4-88 ] Richard Hess ...!uunet!cimshop!rhess
* [ Revised primary execution loop within main()...
* [ Extended X event handler, check_events()...
#include <stdlib.h>
#include <string.h>
#include <time.h>
-#include <windows.h> /* required for all Windows applications */
+#include <windows.h> /* required for all Windows applications */
+#include <scrnsave.h>
+#include "resource.h"
-#if !defined (APIENTRY) /* Windows NT defines APIENTRY, but 3.x doesn't */
-#define APIENTRY far pascal
-#endif
-
-#if !defined(WIN32) /* Windows 3.x uses a FARPROC for dialogs */
-#define DLGPROC FARPROC
-#endif
+#define APPNAME _T("Maze")
-static BOOL InitInstance(HINSTANCE hInstance, HWND hParent);
-LRESULT CALLBACK MazeWndProc(HWND hWnd, UINT message, WPARAM uParam,
- LPARAM lParam);
+static BOOL InitInstance(HWND hParent);
+LRESULT CALLBACK ScreenSaverProc(HWND hWnd, UINT message, WPARAM uParam, LPARAM lParam);
+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);
-HINSTANCE hInst; /* current instance */
-HWND hWnd; /* Main window handle.*/
+extern HINSTANCE hMainInstance; /* current instance */
HBRUSH hBrushDead;
HBRUSH hBrushLiving;
HPEN hPenWall;
HDC hDC;
static BOOL waiting;
-
-WCHAR szAppName[] = L"Maze"; /* The name of this application */
-WCHAR szTitle[] = L"Maze"; /* The title bar text */
-
static int solve_delay, pre_solve_delay, post_solve_delay;
-#define MAX_MAZE_SIZE_X ((unsigned long) 250)
-#define MAX_MAZE_SIZE_Y ((unsigned long) 250)
+#define MAX_MAZE_SIZE_X ((unsigned long) 1000) // Dynamic detection?
+#define MAX_MAZE_SIZE_Y ((unsigned long) 1000) // Dynamic detection?
#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 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_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 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 START_SQUARE 0x2
+#define END_SQUARE 0x1
-#define border_x (0)
-#define border_y (0)
+#define border_x (0)
+#define border_y (0)
-#define get_random(x) (rand() % (x))
+#define get_random(x) (rand() % (x))
static unsigned short maze[MAX_MAZE_SIZE_X][MAX_MAZE_SIZE_Y];
static struct {
- unsigned char x;
- unsigned char y;
- unsigned char dir;
- unsigned char dummy;
+ unsigned int x;
+ unsigned int y;
+ unsigned int dir;
} move_list[MOVE_LIST_SIZE], save_path[MOVE_LIST_SIZE], path[MOVE_LIST_SIZE];
static int maze_size_x, maze_size_y;
static int cur_sq_x, cur_sq_y;
static int start_x, start_y, start_dir, end_x, end_y, end_dir;
static int grid_width, grid_height;
-
+static int bw;
static int state = 1, pathi = 0;
-static void
-set_maze_sizes (width, height)
- int width, height;
+static void set_maze_sizes(width, height)
+int width, height;
{
- maze_size_x = width / grid_width;
- maze_size_y = height / grid_height;
+ maze_size_x = (width -1)/ grid_width;
+ maze_size_y = (height-1) / grid_height;
+ if (maze_size_x > MAX_MAZE_SIZE_X)
+ maze_size_x = MAX_MAZE_SIZE_X;
+ if (maze_size_y > MAX_MAZE_SIZE_Y)
+ maze_size_y = MAX_MAZE_SIZE_Y;
}
-
-static void
-initialize_maze() /* draw the surrounding wall and start/end squares */
+static void initialize_maze() /* draw the surrounding wall and start/end squares */
{
- register int i, j, wall;
+ 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;
+ /* 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;
-}
-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() /* create a maze layout given the intiialized maze */
-{
- 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 */
- }
+ /* top wall */
+ for (i = 0; i < maze_size_x; i++) {
+ maze[i][0] |= WALL_TOP;
}
- /* 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;
- }
+ /* right wall */
+ for (j = 0; j < maze_size_y; j++) {
+ maze[maze_size_x - 1][j] |= WALL_RIGHT;
}
- } while (1);
-
-}
-
-
-static int
-choose_door(HDC hDC) /* pick a new path */
-{
- 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) ] );
-
-}
+ /* 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;
+ }
-static long
-backup() /* back up a move */
-{
- sqnum--;
- if (0 <= sqnum) {
- cur_sq_x = move_list[sqnum].x;
- cur_sq_y = move_list[sqnum].y;
- }
- return ( sqnum );
+ /* 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;
}
-int bw;
-
-static void
-draw_solid_square(i, j, dir, hDC, hBrush) /* draw a solid square in a square */
- register int i, j, dir;
- HDC hDC;
- HBRUSH hBrush;
+static void create_maze(HWND hWnd) /* create a maze layout given the initialized maze */
{
- 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);
+ register int i, newdoor = 0;
+
+ 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 */
+ 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);
}
-static void
-draw_maze_border(HWND hWnd, HDC hDC) /* draw the maze outline */
+static int choose_door(HDC hDC) /* pick a new path */
{
- register int i, j;
- HBRUSH hBrush;
-
- SelectObject(hDC, hPenWall);
-
- 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);
+ 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;
}
- 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);
+ 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;
}
- }
- 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);
+ 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;
}
- 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);
+ 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;
- hBrush = GetStockObject(WHITE_BRUSH); // FIXME: do not hardcode
- draw_solid_square (start_x, start_y, start_dir, hDC, hBrush);
- draw_solid_square (end_x, end_y, end_dir, hDC, hBrush);
-}
+donewall:
+ if (num_candidates == 0)
+ return -1;
+ if (num_candidates == 1)
+ return candidates[0];
+ return candidates[get_random(num_candidates)];
+}
-static void
-draw_wall(i, j, dir, hDC) /* draw a single wall */
- int i, j, dir;
- HDC hDC;
+static long backup() /* back up a move */
{
- SelectObject(hDC, hPenWall);
-
- 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;
- }
+ sqnum--;
+ if (0 <= sqnum) {
+ cur_sq_x = move_list[sqnum].x;
+ cur_sq_y = move_list[sqnum].y;
+ }
+ return sqnum;
}
-static void
-begin_solve_maze() /* solve it with graphical feedback */
+static void draw_solid_square(i, j, dir, hDC, hBrush) /* draw a solid square in a square */
+register int i, j, dir;
+HDC hDC;
+HBRUSH hBrush;
{
- 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;
+ 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);
}
-static int
-solve_maze() /* solve it with graphical feedback */
+static void draw_maze_border(HWND hWnd) /* draw the maze outline */
{
- 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;
+ register int i, j;
+ HBRUSH hBrush;
+
+ SelectObject(hDC, hPenWall);
+
+ 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);
+ }
}
- 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;
+ 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);
+ }
}
- } while (! action_done);
- return ret;
+ hBrush = GetStockObject(WHITE_BRUSH); // FIXME: do not hardcode
+ draw_solid_square(start_x, start_y, start_dir, hDC, hBrush);
+ draw_solid_square(end_x, end_y, end_dir, hDC, hBrush);
}
-
-static void
-enter_square(int n, HDC hDC, HBRUSH hBrush) /* move into a neighboring square */
+static void draw_wall(i, j, dir, hDC) /* draw a single wall */
+register int i, j, dir;
+HDC hDC;
{
- 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;
- }
+ SelectObject(hDC, hPenWall);
+
+ 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;
+ }
}
-static void
-start_timer(HWND hWnd, int iTimeout)
+static void begin_solve_maze(HWND hWnd) /* solve it with graphical feedback */
{
- waiting = TRUE;
- SetTimer(hWnd, 1, iTimeout, NULL);
+ /* 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;
}
-/****************************************************************************
-
- FUNCTION: WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
-
- PURPOSE: calls initialization function, processes message loop
-
- COMMENTS:
-
- Windows recognizes this function by name as the initial entry point
- for the program. This function calls the application initialization
- routine, if no other instance of the program is running, and always
- calls the instance initialization routine. It then executes a message
- retrieval and dispatch loop that is the top-level control structure
- for the remainder of execution. The loop is terminated when a WM_QUIT
- message is received, at which time this function exits the application
- instance by returning the value passed by PostQuitMessage().
-
- If this function must abort before entering the message loop, it
- returns the conventional value NULL.
-
-****************************************************************************/
-
-int APIENTRY MazeMain(
- HINSTANCE hInstance,
- HINSTANCE hPrevInstance,
- LPSTR lpCmdLine,
- HWND hParent)
+static int solve_maze(HWND hWnd) /* solve it with graphical feedback */
{
- MSG msg;
- HDC hDC;
-
- /* Perform initializations that apply to a specific instance */
-
- if (!InitInstance(hInstance, hParent)) {
- 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 */
+ 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) {
+
+ ret = 1;
+ }
+ else {
+ ret = 0;
+ }
+ }
+ else {
+ action_done = 0;
+ }
+ } while (!action_done);
+ return ret;
}
-
-/****************************************************************************
-
- FUNCTION: InitInstance(HINSTANCE, int)
-
- PURPOSE: Saves instance handle and creates main window
-
- COMMENTS:
-
- This function is called at initialization time for every instance of
- this application. This function performs initialization tasks that
- cannot be shared by multiple instances.
-
- In this case, we save the instance handle in a static variable and
- create and display the main program window.
-
-****************************************************************************/
-
-static BOOL InitInstance(
- HINSTANCE hInstance,
- HWND hParent)
+static void enter_square(int n, HDC hDC, HBRUSH hBrush) /* move into a neighboring square */
{
- RECT rect;
-
- /* 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 */
-
- GetClientRect(hParent, &rect);
-#if 0
- /* Create a main window for this application instance. */
- hWnd = CreateWindow(
- szAppName, /* See RegisterClass() call. */
- szTitle, /* Text for window title bar. */
- WS_CHILD,/* Window style. */
- 0, 0, rect.right/2, rect.bottom/2, /* Use default positioning */
- hParent, /* We use a Parent. */
- NULL, /* Use the window class menu. */
- hInstance, /* This instance owns this window. */
- NULL /* We don't use any data in our WM_CREATE */
- );
-#endif
-hWnd = hParent;
- // 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, SW_SHOW); // Show the window
- SetCursor(NULL);
- UpdateWindow(hWnd); // Sends WM_PAINT message
-
- hPenWall = CreatePen(PS_SOLID, 3, RGB(150,150,150));
-
- return (TRUE); // We succeeded...
+ 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;
+ }
+}
+static void start_timer(HWND hWnd, int iTimeout)
+{
+ SetTimer(hWnd, 1, iTimeout, NULL);
}
-static BOOL
-OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct)
+static BOOL OnCreate(HWND hWnd, LPCREATESTRUCT lpCreateStruct)
{
- RECT rc;
- int size;
+ int size;
- srand((unsigned) time(NULL));
+ srand((unsigned) time(NULL));
+ size = GetPrivateProfileIntW(L"maze", L"gridsize", 10, L"maze.ini");
+ pre_solve_delay = GetPrivateProfileIntW(L"maze", L"predelay", 5000, L"maze.ini");
+ post_solve_delay = GetPrivateProfileIntW(L"maze", L"postdelay", 5000, L"maze.ini");
+ solve_delay = GetPrivateProfileIntW(L"maze", L"solvedelay", 1, L"maze.ini");
+
+ if (size < 2) {
+ size = 7 + (rand() % 30);
+ }
+ grid_width = grid_height = size;
+ bw = (size > 6 ? 3 : (size - 1) / 2);
+
#if 0
- /* FIXME GetPrivateProfileInt not yet implemented in ReactOS */
- size = GetPrivateProfileInt("maze", "gridsize", 0, "maze.ini");
- pre_solve_delay = GetPrivateProfileInt("maze", "predelay", 5000,
- "maze.ini");
- post_solve_delay = GetPrivateProfileInt("maze", "postdelay", 5000,
- "maze.ini");
- solve_delay = GetPrivateProfileInt("maze", "solvedelay", 10,
- "maze.ini");
+ /* FIXME Pattern brushes not yet implemented in ReactOS */
+ {
+ static long grayPattern [] = {
+ 0x55555555,
+ 0xaaaaaaaa,
+ 0x55555555,
+ 0xaaaaaaaa,
+ 0x55555555,
+ 0xaaaaaaaa,
+ 0x55555555,
+ 0xaaaaaaaa
+ };
+ static RGBQUAD argbq [] = {
+ { 0, 0, 255, 0 },
+ { 255, 255, 255, 0 }
+ };
+ BITMAPINFO *pbmi;
+
+ 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));
+ hBrushDead = CreateDIBPatternBrushPt(pbmi, DIB_RGB_COLORS);
+ // hBrushDead = CreateHatchBrush(HS_DIAGCROSS, RGB(255, 0, 0));
+ free(pbmi);
+ }
#else
- size = 10;
- pre_solve_delay = 5000;
- post_solve_delay = 5000;
- solve_delay = 1;
+ hBrushDead = CreateSolidBrush(RGB(255, 0, 0));
#endif
+ hBrushLiving = CreateSolidBrush(RGB(0, 255, 0));
+ hPenWall = CreatePen(PS_SOLID, 3, RGB(150, 150, 150));
- if (size < 2) {
- size = 7 + (rand() % 30);
- }
- grid_width = grid_height = size;
- bw = (size > 6 ? 3 : (size-1)/2);
+ hDC = GetDC(hWnd);
- GetClientRect(hWnd, &rc);
- set_maze_sizes(rc.right - rc.left, rc.bottom - rc.top);
+ start_timer(hWnd, 1);
- return TRUE;
+ return TRUE;
}
-void OnTimer(HWND hwnd, UINT id)
+LRESULT CALLBACK ScreenSaverProc(
+ HWND hWnd, // window handle
+ UINT message, // type of message
+ WPARAM wParam, // additional information
+ LPARAM lParam) // additional information
{
- waiting = FALSE;
+ switch (message)
+ {
+ case WM_CREATE:
+ OnCreate(hWnd, (LPCREATESTRUCT) lParam);
+ break;
+ case WM_SIZE:
+ set_maze_sizes(LOWORD(lParam), HIWORD(lParam));
+ break;
+ case WM_TIMER:
+ switch (state)
+ {
+ case 2:
+ begin_solve_maze(hWnd);
+
+ state = 3;
+
+ start_timer(hWnd, solve_delay);
+ break;
+
+ case 3:
+ if (!solve_maze(hWnd))
+ {
+ start_timer(hWnd, solve_delay);
+ }
+ else
+ {
+ state = 1;
+ start_timer(hWnd, post_solve_delay);
+ }
+ break;
+
+ default:
+ initialize_maze();
+
+ SendMessage(hWnd, WM_ERASEBKGND, (WPARAM) hDC, (LPARAM) 0);
+ draw_maze_border(hWnd);
+
+ create_maze(hWnd);
+
+ state = 2;
+
+ start_timer(hWnd, pre_solve_delay);
+ break;
+ }
+ break;
+
+ case WM_DESTROY: // message: window being destroyed
+ DeleteObject(hBrushLiving);
+ DeleteObject(hBrushDead);
+ ReleaseDC(hWnd, hDC);
+ break;
+
+ default: // Passes it on if unproccessed
+ return DefScreenSaverProc(hWnd, message, wParam, lParam);
+ }
+ return 0;
}
-/****************************************************************************
-
- FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
-
- PURPOSE: Processes messages
-
- MESSAGES:
+BOOL WINAPI ScreenSaverConfigureDialog(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
+{
+ return TRUE;
+}
- WM_DESTROY - destroy window
+BOOL WINAPI RegisterDialogClasses(HANDLE hmodule)
+{
+ TCHAR szTitle[256];
+ TCHAR szText[256];
- COMMENTS:
+ LoadString(hmodule, IDS_TITLE, szTitle, 256);
-****************************************************************************/
+ LoadString(hmodule, IDS_TEXT, szText, 256);
-LRESULT CALLBACK MazeWndProc(
- HWND hWnd, // window handle
- UINT message, // type of message
- WPARAM wParam, // additional information
- LPARAM lParam) // additional information
-{
- 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);
+ MessageBox(0, szText, szTitle, MB_OK | MB_ICONWARNING);
+ return TRUE;
}
projects / reactos.git / blobdiff