pathfinder2d.cpp

一个VC写A*寻路的程序库

			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=false;
			vSetup->Map_Clear_Path();
			update(hWnd);
			break;
			
			//
		case IDM_ALTDEBUG12:
			vGeneric->set_GameMode(false);
			vSetup->set_start(10,10);
			vSetup->set_end(190,190);
			vSetup->distance_method=PYTHAGORAS_DISTANCE;
			vSetup->directions=8;
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=true;
			vSetup->diagonal_cost=1.4f;
			vSetup->Load("mars200x200.tga");
			update(hWnd);
			break;
		case IDM_ALTDEBUG11:
			vSetup->directions=8;
			vGeneric->set_GameMode(false);
			vSetup->set_start(2,10);
			vSetup->set_end(252,244);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=false;
			vSetup->Load("square_maze.tga");
			update(hWnd);
			break;
		case IDM_ALTDEBUG10:
			vSetup->directions=8;
			vGeneric->set_GameMode(false);
			vSetup->set_start(30,2);
			vSetup->set_end(224,240);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=false;
			vSetup->Load("unicursal_maze.tga");
			update(hWnd);
			break;
		case IDM_ALTDEBUG9:
			vSetup->directions=8;
			vGeneric->set_GameMode(false);
			vSetup->set_start(4,4);
			vSetup->set_end(250,240);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=false;
			vSetup->Load("hex_maze.tga");
			update(hWnd);
			break;
		case IDM_ALTDEBUG8:
			vSetup->directions=8;
			vGeneric->set_GameMode(false);
			vSetup->set_start(252,128);
			vSetup->set_end(138,128);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=false;
			vSetup->Load("labyrinth.tga");
			update(hWnd);
			break;
		case IDM_ALTDEBUG7:
			vSetup->directions=8;
			vGeneric->set_GameMode(false);
			vSetup->set_start(72,252);
			vSetup->set_end(128,128);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=false;
			vSetup->Load("circle_maze.tga");
			update(hWnd);
			break;
		case IDM_ALTDEBUG5:
			vGeneric->set_GameMode(false);
			vSetup->starty=rand()%(HEIGHT-1);
			vSetup->startx=rand()%(WIDTH-1);
			vSetup->endy=rand()%(HEIGHT-1);
			vSetup->endx=rand()%(WIDTH-1);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=true;
			vSetup->Map_Random();
			update(hWnd);
			break;
		case IDM_ALTDEBUG1:
			vGeneric->set_GameMode(false);
			vSetup->starty=3;
			vSetup->startx=3;
			vSetup->endy=WIDTH-20;
			vSetup->endx=HEIGHT-45;
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->directions=4;
			vSetup->use_terrain=false;
			vSetup->Map_Gates();
			update(hWnd);
			break;
			
			//
		case IDM_CTRLDEBUG12:
			vSetup->distance_method=MANHATTAN_DISTANCE;
			vSetup->directions=8;
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=true;
			vSetup->Load("clutter.tga");
			vGeneric->set_GameMode(true);
			update(hWnd);
			break;
		case IDM_CTRLDEBUG5:
			vGeneric->set_GameMode(true);
			vSetup->starty=rand()%(HEIGHT-1);
			vSetup->startx=rand()%(WIDTH-1);
			vSetup->endy=rand()%(HEIGHT-1);
			vSetup->endx=rand()%(WIDTH-1);
			vSetup->iterations_per_frame=WIDTH*HEIGHT;
			vSetup->use_terrain=true;
			vSetup->Map_Random();
			update(hWnd);
			break;
			
			//
		case IDM_MAP_OPEN:
			{
				char strFile[256]="\0";
				char strFileTitle[256]="\0";
				
				LPOPENFILENAME lpofn=new OPENFILENAME;
				if(lpofn)
				{
					lpofn->lStructSize=sizeof(OPENFILENAME);
					lpofn->hwndOwner=hWnd;
					lpofn->hInstance=hInst;
					lpofn->lpstrFilter="*.tga";
					lpofn->lpstrCustomFilter=NULL;
					lpofn->nMaxCustFilter=0; 
					lpofn->nFilterIndex=0;
					lpofn->lpstrFile=strFile;
					lpofn->nMaxFile=256;
					lpofn->lpstrFileTitle=strFileTitle;
					lpofn->nMaxFileTitle=256;
					lpofn->lpstrInitialDir=NULL;
					lpofn->lpstrTitle="Load 256-color 200x200 TGA Map";
					lpofn->Flags=OFN_FILEMUSTEXIST;
					lpofn->nFileOffset=0;
					lpofn->nFileExtension=NULL;
					lpofn->lpstrDefExt=NULL; 
					lpofn->lCustData=0;
					lpofn->lpfnHook=NULL; 
					lpofn->lpTemplateName=NULL ;
					
					if(GetOpenFileName(lpofn))
					{
						vSetup->Load(lpofn->lpstrFile);
						update(hWnd);
					}
					
					delete lpofn;
				}
			}
			break;
			
			//
		case IDM_MAP_SAVE:
			{
				char strFile[256]="\0";
				char strFileTitle[256]="\0";
				
				LPOPENFILENAME lpofn=new OPENFILENAME;
				if(lpofn)
				{
					lpofn->lStructSize=sizeof(OPENFILENAME);
					lpofn->hwndOwner=hWnd;
					lpofn->hInstance=hInst;
					lpofn->lpstrFilter="*.tga";
					lpofn->lpstrCustomFilter=NULL;
					lpofn->nMaxCustFilter=0; 
					lpofn->nFilterIndex=0;
					lpofn->lpstrFile=strFile;
					lpofn->nMaxFile=256;
					lpofn->lpstrFileTitle=strFileTitle;
					lpofn->nMaxFileTitle=256;
					lpofn->lpstrInitialDir=NULL;
					lpofn->lpstrTitle="Save 256-color 200x200 TGA Map";
					lpofn->Flags=OFN_FILEMUSTEXIST;
					lpofn->nFileOffset=0;
					lpofn->nFileExtension=NULL;
					lpofn->lpstrDefExt=NULL; 
					lpofn->lCustData=0;
					lpofn->lpfnHook=NULL; 
					lpofn->lpTemplateName=NULL ;
					
					if(GetSaveFileName(lpofn))
					{
						vSetup->Save(lpofn->lpstrFile);
						Redraw(hWnd);
					}
					
					delete lpofn;
				}
			}
			break;
			
		case IDM_MAP_MARS200X200:
			vSetup->Load("mars200x200.tga");
			update(hWnd);
			break;
		case IDM_MAP_BOXONBOXNOG:
			vSetup->Map_BoxOnBoxNoG();
			update(hWnd);
			break;
		case IDM_MAP_BOXONBOX:
			vSetup->Map_BoxOnBox();
			update(hWnd);
			break;
		case IDM_MAP_MARS:
			vSetup->Load("mars.tga");
			update(hWnd);
			break;
		case IDM_MAP_CLUTTER:
			vSetup->Load("clutter.tga");
			update(hWnd);
			break;
		case IDM_MAP_SWIRL:
			vSetup->Load("swirl.tga");
			update(hWnd);
			break;
		case IDM_MAP_CHI:
			vSetup->Load("chi.tga");
			update(hWnd);
			break;
		case IDM_MAP_AUTHOR:
			vSetup->Load("author.tga");
			update(hWnd);
			break;
		case IDM_MAP_X:
			vSetup->Load("x.tga");
			update(hWnd);
			break;
		case IDM_MAP_WIGGLINGSNAKE:
			vSetup->Load("wigglingsnake.tga");
			update(hWnd);
			break;
		case IDM_MAP_HILL:
			vSetup->Load("hill.tga");
			update(hWnd);
			break;
		case IDM_MAP_ISLANDS:
			vSetup->Load("islands.tga");
			update(hWnd);
			break;
		case IDM_MAP_ISLAND:
			vSetup->Load("island.tga");
			update(hWnd);
			break;

		//
		case IDM_MAP_STRAIGHTLINE:
			vSetup->Map_StraightLine();
			update(hWnd);
			break;
		case IDM_MAP_CHECKERBOARD:
			vSetup->Map_CheckerBoard();
			update(hWnd);
			break;
		case IDM_MAP_GRID:
			vSetup->Map_Grid();
			update(hWnd);
			break;
		case IDM_MAP_PIPEMAZE:
			vSetup->Map_PipeMaze();
			update(hWnd);
			break;
		case IDM_MAP_RANDOM:
			vSetup->Map_Random();
			update(hWnd);
			break;
		case IDM_MAP_CLEAR_PATH:
			vSetup->Map_Clear_Path();
			update(hWnd);
			break;
		case IDM_MAP_NO_PATH:
			vSetup->Map_No_Path();
			update(hWnd);
			break;
		case IDM_MAP_CRASHME:
			vSetup->Map_CrashMe();
			update(hWnd);
			break;
		case IDM_MAP_FLOWER:
			vSetup->Load("flower.tga");
			update(hWnd);
			break;
		case IDM_MAP_BIGBOX:
			vSetup->Map_BigBox();
			update(hWnd);
			break;
		case IDM_MAP_RANDOMBOXES:
			vSetup->Map_RandomBoxes();
			update(hWnd);
			break;
		case IDM_MAP_RANDOMOPENBOXES:
			vSetup->Map_RandomOpenBoxes();
			update(hWnd);
			break;
		case IDM_MAP_RANDOMTERRAIN:
			vSetup->Map_RandomTerrain();
			update(hWnd);
			break;
		case IDM_MAP_GATES:
			vSetup->Map_Gates();
			update(hWnd);
			break;

			//
		case IDM_MAP_LABYRINTH:
			vSetup->Load("labyrinth.tga");
			update(hWnd);
			break;
		case IDM_MAP_SQUARE_MAZE:
			vSetup->Load("square_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_CIRCLE_MAZE:
			vSetup->Load("circle_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_HEX_MAZE:
			vSetup->Load("hex_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_UNICURSAL_MAZE:
			vSetup->Load("unicursal_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_PERFECT_MAZE:
			vSetup->Load("perfect_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_BRAID_MAZE:
			vSetup->Load("braid_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_CRACK_MAZE:
			vSetup->Load("crack_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_CAVERN_MAZE:
			vSetup->Load("cavern_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_DIAGONAL_MAZE:
			vSetup->Load("diagonal_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_SPIRAL_MAZE:
			vSetup->Load("spiral_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_SEGMENT_MAZE:
			vSetup->Load("segment_maze.tga");
			update(hWnd);
			break;
		case IDM_MAP_REPLICA_LABYRINTH:
			vSetup->Load("replica_labyrinth.tga");
			update(hWnd);
			break;
		case IDM_MAP_CRETAN_LABYRINTH:
			vSetup->Load("cretan_labyrinth.tga");
			update(hWnd);
			break;
		case IDM_MAP_MAN_IN_THE_MIDDLE_LABYRINTH:
			vSetup->Load("man_in_the_middle_labyrinth.tga");
			update(hWnd);
			break;
			
			
			//
		case IDM_DIRECTIONS4:
			vSetup->directions=4;
			vGeneric->UpdateSettings();
			vGeneric->Reset();
			Redraw(hWnd);
			break;
		case IDM_DIRECTIONS8:
			vSetup->directions=8;
			vGeneric->UpdateSettings();
			vGeneric->Reset();
			Redraw(hWnd);
			break;
			
			//
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
			
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
		
		case WM_ERASEBKGND:
			return 1;
			
		case WM_PAINT:
			{
				//
				RefreshMenu(hWnd);
				
				// begin to repaint the screen....
				hdc = BeginPaint(hWnd, &ps);
				RECT rt;
				GetClientRect(hWnd, &rt);
				
				// first, since we don't want the screen to flicker or use slow-as-hell GDI
				//primatives to try to do the graphics rendering, we crate a temporary memory buffer
				// to do all our rendering to....
				hdctmp=CreateCompatibleDC(hdc);
				
				// now prepare to give it a directly accessable RGBA memory buffer
				//that we can draw to directly as a block of memory.
				bi.bV4BitCount = 32;
				bi.bV4ClrImportant = 0;
				bi.bV4ClrUsed = 0;
				bi.bV4V4Compression = BI_RGB;
				bi.bV4Planes = 1;
				bi.bV4Size = sizeof(BITMAPV4HEADER);
				bi.bV4SizeImage = 0; //(rt.right-rt.left)*(rt.bottom-rt.top);
				bi.bV4Width = (rt.right-rt.left);
				bi.bV4Height = -(rt.bottom-rt.top);
				bi.bV4XPelsPerMeter = 0;
				bi.bV4YPelsPerMeter = 0;
				bi.bV4AlphaMask = 0;
				bi.bV4CSType = 0;
				
				// get the DIB....
				hbmtmp = CreateDIBSection(hdc, (BITMAPINFO *) &bi, DIB_RGB_COLORS, (LPVOID *)&pwBits, NULL, 0);
				hOld = SelectObject(hdctmp, hbmtmp); //and select it to draw on.
				
				// We render the screen here to a block of DIB memoory we created...
				BITMAPV4HEADER biinfo;
				//int binfobytes=
				GetObject(hbmtmp,sizeof(BITMAPV4HEADER),&biinfo);
				// first however we check to make sure the user didn't try to resize the window
				// smaller than what we're trying to directly draw to.
				if(biinfo.bV4Width>=MINIMUM_CLIENT_WIDTH && biinfo.bV4Height>=MINIMUM_CLIENT_HEIGHT)
				{
					//do it, if all's ok.
					if(drawmode)
						DrawMode(pwBits,hdctmp,hWnd);
					else if(presearch_view)
						Presearch_View(pwBits,hdctmp,hWnd);
					else
					{
						vGeneric->Paint(pwBits,hdctmp,hWnd);
						if(zoom && !vGeneric->routing_view) Zoom_Composite(pwBits,hWnd);
					}
				}
				else // if they shrank the screen this would normally crash the app hard
					// so instead render another screen instructing them to reenlarge it.
					PaintFunc_TooSmall(hdctmp,hWnd,MINIMUM_CLIENT_WIDTH-biinfo.bV4Width,MINIMUM_CLIENT_HEIGHT-biinfo.bV4Height);
				
				// Now we copy what we rendered from our buffer to the screen as fast
				//as possible to avoid flickering.
				BitBlt(hdc,rt.left,rt.top,rt.right-rt.left,rt.bottom-rt.top,hdctmp,0,0,SRCCOPY);
				
				// un allocate the memory we grabbed.
				SelectObject(hdctmp,hOld);
				DeleteObject(hbmtmp);
				DeleteDC(hdctmp);
				
				// we're done
				EndPaint(hWnd, &ps);
			}
			break;
			
			//
		case WM_TIMER:
			if(runflag)
			{
				if(!vGeneric->isDone()) //if we're not pathfinding, keep the cpu's low
				{
					vGeneric->FindPath();
					Redraw(hWnd);
				}
			}
			break;
			
		case WM_DESTROY:
			PostQuitMessage(0);
			KillTimer(hWnd, TIMER_ID);
			break;
			
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

// Mesage handler for about box.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	lParam=lParam;
	switch (message)
	{
	case WM_INITDIALOG:
		PlaySound(MAKEINTRESOURCE(IDR_WAVE_ABOUT), GetModuleHandle(NULL), SND_RESOURCE | SND_ASYNC);
		return TRUE;
		
	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) 
		{
			EndDialog(hDlg, LOWORD(wParam));
			return TRUE;
		}
		break;
	}
    return FALSE;
}