#include <windows.h>
#include <scrnsave.h>
#include <tchar.h>
#include <stdlib.h>
#include <commctrl.h>
#include <string.h>
#include <time.h>
#include "resource.h"

Include dependency graph for maze.c:

Macros
#define	STRICT

#define	APPNAME _T("Maze")

#define	MAX_MAZE_SIZE_X ((unsigned long) 1000)

#define	MAX_MAZE_SIZE_Y ((unsigned long) 1000)

#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
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)

static void	SetDefaults ()

static void	ReadRegistry ()

static void	WriteRegistry ()

static void	set_maze_sizes (int width, int height)

static void	initialize_maze ()

static void	create_maze (HWND hWnd)

static int	choose_door (HDC hDC)

static void	draw_maze_border (HWND hWnd)

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

static void	begin_solve_maze (HWND hWnd)

static int	solve_maze (HWND hWnd)

static void	start_timer (HWND hWnd, int iTimeout)

static BOOL	OnCreate (HWND hWnd, LPCREATESTRUCT lpCreateStruct)

INT_PTR CALLBACK	AboutProc (HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)

static void	ReadSettings (HWND hWnd)

BOOL WINAPI	ScreenSaverConfigureDialog (HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)

BOOL WINAPI	RegisterDialogClasses (HANDLE hmodule)

Variables
HINSTANCE	hMainInstance

HBRUSH	hBrushDead

HBRUSH	hBrushLiving

HPEN	hPenWall

HDC	hDC

static int	solve_delay

static int	pre_solve_delay

static int	post_solve_delay

static int	size

static unsigned short	maze [MAX_MAZE_SIZE_X][MAX_MAZE_SIZE_Y]

struct {
unsigned int x

unsigned int y

unsigned int dir

}	move_list [MOVE_LIST_SIZE]

struct {
unsigned int x

unsigned int y

unsigned int dir

}	save_path [MOVE_LIST_SIZE]

struct {
unsigned int x

unsigned int y

unsigned int dir

}	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	bw

static int	state = 1

static int	pathi = 0

static LPCWSTR	registryPath = _T("Software\\Microsoft\\ScreenSavers\\mazescr")

Macro Definition Documentation

◆ APPNAME

#define APPNAME _T("Maze")

Definition at line 61 of file maze.c.

◆ border_x

#define border_x (0)

Definition at line 102 of file maze.c.

◆ border_y

#define border_y (0)

Definition at line 103 of file maze.c.

◆ DOOR_IN_ANY

#define DOOR_IN_ANY 0xF00

Definition at line 92 of file maze.c.

◆ DOOR_IN_BOTTOM

#define DOOR_IN_BOTTOM 0x200

Definition at line 90 of file maze.c.

◆ DOOR_IN_LEFT

#define DOOR_IN_LEFT 0x100

Definition at line 91 of file maze.c.

◆ DOOR_IN_RIGHT

#define DOOR_IN_RIGHT 0x400

Definition at line 89 of file maze.c.

◆ DOOR_IN_TOP

#define DOOR_IN_TOP 0x800

Definition at line 88 of file maze.c.

◆ DOOR_OUT_BOTTOM

#define DOOR_OUT_BOTTOM 0x20

Definition at line 96 of file maze.c.

◆ DOOR_OUT_LEFT

#define DOOR_OUT_LEFT 0x10

Definition at line 97 of file maze.c.

◆ DOOR_OUT_RIGHT

#define DOOR_OUT_RIGHT 0x40

Definition at line 95 of file maze.c.

◆ DOOR_OUT_TOP

#define DOOR_OUT_TOP 0x80

Definition at line 94 of file maze.c.

◆ END_SQUARE

#define END_SQUARE 0x1

Definition at line 100 of file maze.c.

◆ get_random

#define get_random ( x ) (rand() % (x))

Definition at line 105 of file maze.c.

◆ MAX_MAZE_SIZE_X

#define MAX_MAZE_SIZE_X ((unsigned long) 1000)

Definition at line 78 of file maze.c.

◆ MAX_MAZE_SIZE_Y

#define MAX_MAZE_SIZE_Y ((unsigned long) 1000)

Definition at line 79 of file maze.c.

◆ MOVE_LIST_SIZE

#define MOVE_LIST_SIZE (MAX_MAZE_SIZE_X * MAX_MAZE_SIZE_Y)

Definition at line 81 of file maze.c.

◆ START_SQUARE

#define START_SQUARE 0x2

Definition at line 99 of file maze.c.

◆ STRICT

#define STRICT

Definition at line 50 of file maze.c.

◆ WALL_BOTTOM

#define WALL_BOTTOM 0x2000

Definition at line 85 of file maze.c.

◆ WALL_LEFT

#define WALL_LEFT 0x1000

Definition at line 86 of file maze.c.

◆ WALL_RIGHT

#define WALL_RIGHT 0x4000

Definition at line 84 of file maze.c.

◆ WALL_TOP

#define WALL_TOP 0x8000

Definition at line 83 of file maze.c.

Function Documentation

◆ AboutProc()

INT_PTR CALLBACK AboutProc	(	HWND	hWnd,
		UINT	message,
		WPARAM	wparam,
		LPARAM	lparam
	)

Definition at line 635 of file maze.c.

{
    switch(message){
    case WM_COMMAND:
        switch(LOWORD(wparam)){
        case IDOK:
            EndDialog(hWnd, LOWORD(wparam));
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by ScreenSaverConfigureDialog().

◆ backup()

static long backup ( )

static

Definition at line 403 of file maze.c.

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

Referenced by AddDelBackupEntryA(), AddDelBackupEntryW(), context_set_gl_context(), create_maze(), CreateVssBackupComponents(), CreateVssBackupComponentsInternal(), fb_copy_to_texture_hwstretch(), GdipAddPathRectangle(), GdipAddPathRectangles(), GdipAddPathString(), gl_fixup(), test_backup(), test_clear(), test_count(), test_oldest(), test_openbackup(), test_ReplaceFileA(), test_ReplaceFileW(), TestSetAndGetExtraFormat(), and VSSAPI_CreateVssBackupComponents().

◆ begin_solve_maze()

static void begin_solve_maze ( HWND hWnd )

static

Definition at line 508 of file maze.c.

{
    /* 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;
}

◆ choose_door() [1/2]

static int choose_door ( )

static

Referenced by create_maze().

◆ choose_door() [2/2]

static int choose_door ( HDC hDC )

static

Definition at line 324 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 ( HWND hWnd )

static

Definition at line 280 of file maze.c.

{
    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);
}

◆ draw_maze_border()

static void draw_maze_border ( HWND hWnd )

static

Definition at line 449 of file maze.c.

{
    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);
        }
    }
    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(WHITE_BRUSH);
    draw_solid_square(start_x, start_y, start_dir, hDC, hBrush);
    draw_solid_square(end_x, end_y, end_dir, hDC, hBrush);
}

Referenced by ScreenSaverProc(), and WinMain().

◆ draw_solid_square()

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

static

Definition at line 413 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);
}

Referenced by draw_maze_border(), enter_square(), and solve_maze().

◆ draw_wall() [1/2]

static void draw_wall ( )

static

Referenced by choose_door().

◆ draw_wall() [2/2]

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

static

Definition at line 482 of file maze.c.

{
    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;
    }
}

◆ enter_square()

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

static

Definition at line 552 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;
    }
}

Referenced by solve_maze().

◆ initialize_maze()

static void initialize_maze ( )

static

Definition at line 191 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;
}

Referenced by ScreenSaverProc(), and WinMain().

◆ OnCreate()

static BOOL OnCreate	(	HWND	hWnd,
		LPCREATESTRUCT	lpCreateStruct
	)

static

Definition at line 578 of file maze.c.

{
    srand((unsigned) time(NULL));
 
    ReadRegistry();
 
    if (size < 2) {
        size = 7 + (rand() % 30);
    }
    grid_width = grid_height = size;
    bw = (size > 6 ? 3 : (size - 1) / 2);
 
#if 0
    /* 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
    hBrushDead = CreateSolidBrush(RGB(255, 0, 0));
#endif
    hBrushLiving = CreateSolidBrush(RGB(0, 255, 0));
    hPenWall = CreatePen(PS_SOLID, 3, RGB(150, 150, 150));
 
    hDC = GetDC(hWnd);
 
    start_timer(hWnd, 1);
 
    return TRUE;
}

Referenced by ScreenSaverProc(), and WndProc().

◆ ReadRegistry()

static void ReadRegistry ( )

static

Definition at line 132 of file maze.c.

{
    LONG result;
    HKEY skey;
    DWORD valuetype, valuesize, val_size, val_presd, val_postsd, val_sd;
 
    SetDefaults();
 
    result = RegOpenKeyEx(HKEY_CURRENT_USER, registryPath, 0, KEY_READ, &skey);
    if(result != ERROR_SUCCESS)
        return;
 
    valuesize = sizeof(DWORD);
 
    result = RegQueryValueEx(skey, _T("size"), NULL, &valuetype, (LPBYTE)&val_size, &valuesize);
    if(result == ERROR_SUCCESS)
        size = val_size;
    result = RegQueryValueEx(skey, _T("pre_solve_delay"), NULL, &valuetype, (LPBYTE)&val_presd, &valuesize);
    if(result == ERROR_SUCCESS)
        pre_solve_delay = val_presd;
    result = RegQueryValueEx(skey, _T("post_solve_delay"), NULL, &valuetype, (LPBYTE)&val_postsd, &valuesize);
    if(result == ERROR_SUCCESS)
        post_solve_delay = val_postsd;
    result = RegQueryValueEx(skey, _T("solve_delay"), NULL, &valuetype, (LPBYTE)&val_sd, &valuesize);
    if(result == ERROR_SUCCESS)
        solve_delay = val_sd;
 
    RegCloseKey(skey);
}

Referenced by OnCreate(), and ScreenSaverConfigureDialog().

◆ ReadSettings()

static void ReadSettings ( HWND hWnd )

static

Definition at line 648 of file maze.c.

{
    size = SendDlgItemMessage(hWnd, IDC_SLIDER_SIZE, TBM_GETPOS, 0, 0);
    SetDlgItemInt(hWnd, IDC_TEXT_SIZE, size, FALSE);
 
    pre_solve_delay = SendDlgItemMessage(hWnd, IDC_SLIDER_PRESD, TBM_GETPOS, 0, 0);
    SetDlgItemInt(hWnd, IDC_TEXT_PRESD, pre_solve_delay, FALSE);
 
    post_solve_delay = SendDlgItemMessage(hWnd, IDC_SLIDER_POSTSD, TBM_GETPOS, 0, 0);
    SetDlgItemInt(hWnd, IDC_TEXT_POSTSD, post_solve_delay, FALSE);
 
    solve_delay = SendDlgItemMessage(hWnd, IDC_SLIDER_SD, TBM_GETPOS, 0, 0);
    SetDlgItemInt(hWnd, IDC_TEXT_SD, solve_delay, FALSE);
}

Referenced by ScreenSaverConfigureDialog().

◆ RegisterDialogClasses()

BOOL WINAPI RegisterDialogClasses ( HANDLE hmodule )

Definition at line 766 of file maze.c.

{
    return TRUE;
}

◆ ScreenSaverConfigureDialog()

BOOL WINAPI ScreenSaverConfigureDialog	(	HWND	hWnd,
		UINT	message,
		WPARAM	wparam,
		LPARAM	lparam
	)

Definition at line 723 of file maze.c.

{
    switch (message)
    {
        case WM_INITDIALOG:
            ReadRegistry();
            //Set slider ranges
            SendDlgItemMessage(hWnd, IDC_SLIDER_SIZE, TBM_SETRANGE, FALSE, MAKELPARAM(5, 64));
            SendDlgItemMessage(hWnd, IDC_SLIDER_PRESD, TBM_SETRANGE, FALSE, MAKELPARAM(1, 10000));
            SendDlgItemMessage(hWnd, IDC_SLIDER_POSTSD, TBM_SETRANGE, FALSE, MAKELPARAM(1, 10000));
            SendDlgItemMessage(hWnd, IDC_SLIDER_SD, TBM_SETRANGE, FALSE, MAKELPARAM(1, 10000));
            //Set current values to slider
            SendDlgItemMessage(hWnd, IDC_SLIDER_SIZE, TBM_SETPOS, TRUE, size);
            SendDlgItemMessage(hWnd, IDC_SLIDER_PRESD, TBM_SETPOS, TRUE, pre_solve_delay);
            SendDlgItemMessage(hWnd, IDC_SLIDER_POSTSD, TBM_SETPOS, TRUE, post_solve_delay);
            SendDlgItemMessage(hWnd, IDC_SLIDER_SD, TBM_SETPOS, TRUE, solve_delay);
            //Set current values to texts
            SetDlgItemInt(hWnd, IDC_TEXT_SIZE, size, FALSE);
            SetDlgItemInt(hWnd, IDC_TEXT_PRESD, pre_solve_delay, FALSE);
            SetDlgItemInt(hWnd, IDC_TEXT_POSTSD, post_solve_delay, FALSE);
            SetDlgItemInt(hWnd, IDC_TEXT_SD, solve_delay, FALSE);
            return TRUE;
        case WM_COMMAND:
            switch (LOWORD(wparam))
            {
                case IDOK:
                    WriteRegistry();
                    EndDialog(hWnd, TRUE);
                    return TRUE;
                case IDCANCEL:
                    EndDialog(hWnd, TRUE);
                    break;
                case IDABOUT:
                    DialogBox(hMainInstance, MAKEINTRESOURCE(IDD_DLG_ABOUT), hWnd, AboutProc);
                    break;
            }
        case WM_HSCROLL:
            ReadSettings(hWnd);
            return TRUE;
    }
    return FALSE;
}

◆ ScreenSaverProc()

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

Definition at line 663 of file maze.c.

{
    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 unprocessed
        return DefScreenSaverProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

◆ set_maze_sizes()

static void set_maze_sizes	(	int	width,
		int	height
	)

static

Definition at line 180 of file maze.c.

{
    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;
}

Referenced by OnCreate(), and ScreenSaverProc().

◆ SetDefaults()

static void SetDefaults ( )

static

Definition at line 124 of file maze.c.

{
    size = 10;
    pre_solve_delay = 5000;
    post_solve_delay = 5000;
    solve_delay = 1;
}

Referenced by ReadRegistry().

◆ solve_maze()

static int solve_maze ( HWND hWnd )

static

Definition at line 521 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) {
 
                ret = 1;
            }
            else {
                ret = 0;
            }
        }
        else {
            action_done = 0;
        }
    } while (!action_done);
    return ret;
}

◆ start_timer()

static void start_timer	(	HWND	hWnd,
		int	iTimeout
	)

static

Definition at line 573 of file maze.c.

{
    SetTimer(hWnd, 1, iTimeout, NULL);
}

Referenced by OnCreate(), ScreenSaverProc(), and WinMain().

◆ WriteRegistry()

static void WriteRegistry ( )

static

Definition at line 162 of file maze.c.

{
    LONG result;
    HKEY skey;
    DWORD disp;
 
    result = RegCreateKeyEx(HKEY_CURRENT_USER, registryPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey, &disp);
    if(result != ERROR_SUCCESS)
        return;
 
    RegSetValueEx(skey, _T("size"), 0, REG_DWORD, (LPBYTE)&size, sizeof(size));
    RegSetValueEx(skey, _T("pre_solve_delay"), 0, REG_DWORD, (LPBYTE)&pre_solve_delay, sizeof(pre_solve_delay));
    RegSetValueEx(skey, _T("post_solve_delay"), 0, REG_DWORD, (LPBYTE)&post_solve_delay, sizeof(post_solve_delay));
    RegSetValueEx(skey, _T("solve_delay"), 0, REG_DWORD, (LPBYTE)&solve_delay, sizeof(solve_delay));
 
    RegCloseKey(skey);
}