std::vector<JumpPointSearch::Node*> JumpPointSearch::operator()(IntType startX, IntType startY, IntType endX, IntType endY, Grid<IntType>& grid) {
m_Grid = &grid;
m_Goal = m_Grid->GetNode(endX, endY);
ResetGrid();
Node* start = m_Grid->GetNode(startX, startY);
m_Start = start;
if (!start || !m_Goal) return std::vector<Node*>();
start->opened = true;
m_OpenSet.Push(start);
while (!m_OpenSet.Empty()) {
Node* current = m_OpenSet.Pop();
if (!current) continue;
current->closed = true;
if (NearGoal(current, m_Goal))
return Backtrace(current);
IdentifySuccessors(current);
}
return std::vector<Node*>();
}
void GRIHist1DGridScrollWidget::SetDefaultGrid() {
int n = gri_hist_vec_.size();
if (n == 0) {
n = 1;
} else {
n = (int)TMath::Ceil(TMath::Sqrt((double)n));
}
SetGridMajor(n,n);
SetGridMinor(n,n);
SetGridMinorUpperLeft(0,0);
ResetGrid();
}
void NavGrid::Init(int aGridSize)
{
myMoveCost = 100;
myGridSize = aGridSize;
myGrid.Reserve(myGridSize * myGridSize);
for (int i = 0; i < myGridSize * myGridSize; ++i)
myGrid[i].myGridIndex = i;
ResetGrid();
}
void Randomize(int size)
{
if (size < GRIDSIZE)
{
ResetGrid();
}
for (int X = (GRIDSIZE - size) / 2; X < (GRIDSIZE + size) / 2; X++)
{
for (int Y = (GRIDSIZE - size) / 2; Y < (GRIDSIZE + size) / 2; Y++)
{
int chance = 2;
grid[X][Y].state = rand() % chance;
if (grid[X][Y].state < chance - 1)
{
grid[X][Y].state = 0;
}
else
{
grid[X][Y].state = 1;
}
if (grid[X][Y].state == 1)
{
switch (globalMode)
{
case 0:
grid[X][Y].color = 255;
break;
case 1:
if (rand() % 2 == 0)
{
grid[X][Y].color = 255;
}
else
{
grid[X][Y].color = 0;
}
break;
case 2:
grid[X][Y].color = rand() % 256;
break;
}
}
}
}
};
void GRIHist1DGridScrollWidget::SetGridMinorUpperLeft(int row, int col) {
minor_upper_left_row_ = row;
minor_upper_left_col_ = col;
if (minor_upper_left_col_ < 0) {
minor_upper_left_col_ = 0;
}
if (minor_upper_left_col_ > (major_nx_ - minor_nx_)) {
minor_upper_left_col_ = (major_nx_ - minor_nx_);
}
if (minor_upper_left_row_ < 0) {
minor_upper_left_row_ = 0;
}
if (minor_upper_left_row_ > (major_ny_ - minor_ny_)) {
minor_upper_left_row_ = (major_ny_ -minor_ny_);
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetOutlineColor(GRIHistogrammer *h, QColor qcolor) {
if (HistIsPresent(h)) {
hist_outline_color_vec_[HistIndex(h)] = qcolor;
}
ResetGrid();
}
LRESULT CALLBACK WindowCallback(
HWND Window,
UINT Message,
WPARAM wParam,
LPARAM lParam)
{
LRESULT Result = 0;
struct window_dimension Dimension = GetWindowDimension(Window);
switch (Message)
{
case WM_LBUTTONDOWN:
{
if (globalIterating == 0 && screen == 0)
{
int xPos = GET_X_LPARAM(lParam);
int yPos = GET_Y_LPARAM(lParam);
xPos -= GRIDOFFSET;
yPos -= GRIDOFFSET;
switch (grid[xPos / SPACING][yPos / SPACING].state)
{
case 0:
grid[xPos / SPACING][yPos / SPACING].state = 1;
grid[xPos / SPACING][yPos / SPACING].color = 255;
break;
case 1:
grid[xPos / SPACING][yPos / SPACING].state = 0;
break;
}
RenderGrid();
}
}break;
case WM_RBUTTONDOWN:
{
if (globalIterating == 0 && screen == 0 && globalMode != 0)
{
int xPos = GET_X_LPARAM(lParam) - GRIDOFFSET;
int yPos = GET_Y_LPARAM(lParam) - GRIDOFFSET;
if (grid[xPos / SPACING][yPos / SPACING].state == 1)
{
if (grid[xPos / SPACING][yPos / SPACING].color < 128)
{
grid[xPos / SPACING][yPos / SPACING].color = 255;
}
else
{
grid[xPos / SPACING][yPos / SPACING].color = 0;
}
}
RenderGrid();
}
}break;
case WM_KEYDOWN:
switch (wParam)
{
case VK_SPACE:
switch (globalIterating)
{
case 0:
globalIterating = 1;
break;
case 1:
globalIterating = 0;
break;
}
break;
case VK_UP:
switch (screen)
{
case 0:
sleepTime /= 2;
break;
case 1:
if (highlight > 0)
{
highlight--;
}
RenderMenuScreen();
break;
case 2:
if (highlight > 0)
{
highlight--;
}
ClearScreen();
RenderLoadScreen();
break;
}
break;
case VK_DOWN:
switch (screen)
{
case 0:
if (sleepTime == 0)
{
sleepTime = 1;
}
else
{
sleepTime *= 2;
}
break;
case 1:
if (highlight < 2)
{
highlight++;
}
RenderMenuScreen();
break;
case 2:
highlight++;
ClearScreen();
RenderLoadScreen();
break;
}
break;
case VK_ESCAPE:
screen = 1;
globalIterating = 0;
ClearScreen();
highlight = 0;
RenderMenuScreen();
break;
case VK_RETURN:
switch (screen)
{
case 1:
screen = 0;
globalIterating = 0;
ClearScreen();
ResetGrid();
globalMode = highlight;
RenderGrid();
break;
case 2:
FILE *fp;
fp = fopen(fileList[highlight], "r");
int X, Y, length, skip;
X = Y = length = skip = 0;
ResetGrid();
while (X < GRIDSIZE)
{
unsigned char state = fgetc(fp);
if (skip == 1)
{
if (state == '\n')
{
skip = 0;
}
continue;
}
switch (state)
{
case 255:
X = GRIDSIZE;
break;
case '.':
gridTemp[X++][Y].state = 0;
break;
case 'O':
gridTemp[X++][Y].state = 1;
break;
case '\n':
if (X > length)
{
length = X;
}
X = 0;
Y++;
break;
case '!':
skip = 1;
break;
}
}
fclose(fp);
int xShift = (GRIDSIZE - length) / 2;
int yShift = (GRIDSIZE - Y) / 2;
int height = Y;
for (int Y = 0; Y <= height; Y++)
{
for (int X = 0; X <= length; X++)
{
grid[X + xShift][Y + yShift].state = gridTemp[X][Y].state;
grid[X + xShift][Y + yShift].color = 255;
}
}
globalIterating = 0;
screen = 0;
ClearScreen();
RenderGrid();
break;
}
break;
case 0x43: //c, clears
if (screen == 0)
{
ResetGrid();
globalIterating = 0;
RenderGrid();
}
break;
case 0x47: //g, toggles grid
switch (gridLines)
{
case 0:
gridLines = 1;
break;
case 1:
gridLines = 0;
break;
}
RenderGrid();
break;
case 0x4C: //l, loads
if (screen == 0)
{
unsigned char *pathPointer;
pathPointer = str;
GetModuleFileName(NULL, str, MAX_PATH);
pathPointer += strlen(str);
while (*(pathPointer - 1) != '\\')
{
pathPointer--;
}
strcpy(pathPointer, "*.cells");
WIN32_FIND_DATA data;
HANDLE h = FindFirstFile(str, &data);
if (GetLastError() == ERROR_FILE_NOT_FOUND)
{
FindClose(h);
break;
}
strcpy(pathPointer, data.cFileName);
strcpy(fileList[0], str);
for (int i = 1; i < MAXFILES; i++)
{
FindNextFile(h, &data);
if (GetLastError() == ERROR_NO_MORE_FILES)
{
FindClose(h);;
break;
}
strcpy(pathPointer, data.cFileName);
strcpy(fileList[i], str);
}
screen = 2;
highlight = 0;
ClearScreen();
RenderLoadScreen();
}
break;
case 0x52: //r, randomize
if (screen == 0)
{
Randomize(100);
globalIterating = 0;
RenderGrid();
}
break;
} break;
case WM_DESTROY:
globalRunning = 0;
free(str);
break;
case WM_CLOSE:
globalRunning = 0;
free(str);
break;
case WM_ACTIVATEAPP:
break;
case WM_PAINT:
{
PAINTSTRUCT Paint;
HDC devicecontext = BeginPaint(Window, &Paint);
Display();
EndPaint(Window, &Paint);
} break;
default:
Result = DefWindowProc(Window, Message, wParam, lParam);
break;
return(Result);
}
}
void GRIHist1DGridScrollWidget::SetGridMinor(int Nrow, int Ncol) {
minor_nx_ = Ncol;
minor_ny_ = Nrow;
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetAutoScale(GRIHistogrammer *h, bool autoscale_on) {
if (HistIsPresent(h)) {
hist_autoscale_on_vec_[HistIndex(h)] = autoscale_on;
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetAutoScaleAll(bool autoscale_on) {
for (int i = 0; i < hist_autoscale_on_vec_.size(); ++i) {
hist_autoscale_on_vec_[i] = autoscale_on;
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetLogScale(GRIHistogrammer *h, bool logscale_on) {
if (HistIsPresent(h)) {
hist_logscale_on_vec_[HistIndex(h)] = logscale_on;
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetLogScaleAll(bool logscale_on) {
for (int i = 0; i < hist_logscale_on_vec_.size(); ++i) {
hist_logscale_on_vec_[i] = logscale_on;
}
ResetGrid();
}
bool NavGrid::FindPath(const CU::Vector2i& aStartPoint, const CU::Vector2i& aEndPoint, CU::GrowingArray<CU::Vector2f>& aOutPath)
{
aOutPath.RemoveAll();
ResetGrid();
int startIndex = WorldIndexToGridIndex(aStartPoint);
int goalIndex = WorldIndexToGridIndex(aEndPoint);
if (!IsPositionOnGrid(aStartPoint) || !IsPositionOnGrid(aEndPoint))
return false;
Node& startNode = myGrid[startIndex];
startNode.myG = 0;
startNode.myH = CalculateHeuristic(startIndex, goalIndex);
startNode.myF = startNode.myG + startNode.myH;
startNode.myListState = IN_OPEN;
Node* currentClosestNode = &myGrid[startIndex];
CU::Heap<Node*, NavGrid_NodeComparer<Node*>> heap;
heap.Enqueue(&startNode);
while (!heap.IsEmpty())
{
Node* currNode = heap.Dequeue();
currNode->myListState = IN_CLOSED;
if (CalculateHeuristic(currNode->myGridIndex, goalIndex) < currentClosestNode->myH)
currentClosestNode = currNode;
if (currNode->myGridIndex == goalIndex)
{
while (currNode != nullptr)
{
CU::Vector2f worldPosition = ArrayIndexToWorldPosition(currNode->myGridIndex);
aOutPath.Add(worldPosition);
currNode = currNode->myParent;
}
return true;
}
int currIndex = currNode->myGridIndex;
if (currIndex > myGridSize)
{
ExamineNeighbour(currNode, currIndex - myGridSize, goalIndex, heap);
}
if (currIndex < myGridSize * (myGridSize - 1))
{
ExamineNeighbour(currNode, currIndex + myGridSize, goalIndex, heap);
}
if (currIndex % myGridSize != 0)
{
ExamineNeighbour(currNode, currIndex - 1, goalIndex, heap);
}
if ((currIndex + 1) % myGridSize != 0)
{
ExamineNeighbour(currNode, currIndex + 1, goalIndex, heap);
}
currNode->myListState = IN_CLOSED;
}
return FindPath(aStartPoint, ArrayIndexToGridIndex(currentClosestNode->myGridIndex), aOutPath);
}
void GRIHist1DGridScrollWidget::SetYLabel(GRIHistogrammer *h, QString ylabel) {
if (HistIsPresent(h)) {
hist_ylabel_vec_[HistIndex(h)] = ylabel;
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetBackgroundColorAll(QColor qcolor) {
for (int i = 0; i < hist_background_color_vec_.size(); ++i) {
hist_background_color_vec_[i] = qcolor;
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetBackgroundColor(GRIHistogrammer *h, QColor qcolor) {
if (HistIsPresent(h)) {
hist_background_color_vec_[HistIndex(h)] = qcolor;
}
ResetGrid();
}
int CALLBACK WinMain(HINSTANCE Instance,
HINSTANCE PrevInstance,
LPSTR CmdLine,
int CmdShow)
{
WNDCLASS wc = { 0 };
ResizeDIBSection(&GlobalBackbuffer, WINSIZE + 17, WINSIZE + 41);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WindowCallback;
wc.hInstance = Instance;
wc.lpszClassName = "LifeWindowClass";
RegisterClass(&wc);
HWND Window =
CreateWindowEx(
0,
wc.lpszClassName,
"Game of Life",
WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT,
WINSIZE + 17,
WINSIZE + 41,
0,
0,
Instance,
0);
DeviceContext = GetDC(Window);
srand(time(NULL));
globalRunning = 1;
globalIterating = globalMode = gridLines = highlight = 0;
screen = 1; //0 is main grid, 1 is menu, 2 is load list
str = (unsigned char *)malloc(MAX_PATH);
int MSElapsed = 0;
sleepTime = 128; //milliseconds
ResetGrid();
RenderMenuScreen();
LARGE_INTEGER perfCountFrequencyResult;
QueryPerformanceFrequency(&perfCountFrequencyResult);
long long perfCountFrequency = perfCountFrequencyResult.QuadPart;
LARGE_INTEGER lastCounter;
QueryPerformanceCounter(&lastCounter);
while (globalRunning)
{
MSG Message;
while (PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
{
if (Message.message == WM_QUIT)
{
globalRunning = 0;
}
TranslateMessage(&Message);
DispatchMessage(&Message);
}
switch (screen)
{
case 0:
if (globalIterating == 1)
{
Sleep(1);
LARGE_INTEGER endCounter;
QueryPerformanceCounter(&endCounter);
long long counterElapsed = endCounter.QuadPart - lastCounter.QuadPart;
MSElapsed += (1000 * counterElapsed) / perfCountFrequency;
lastCounter = endCounter;
if (MSElapsed >= sleepTime)
{
Iterate();
RenderGrid();
MSElapsed = 0;
}
}
else
{
Sleep(50);
}
break;
default:
Sleep(50);
break;
}
Display();
}
return 0;
}
void GRIHist1DGridScrollWidget::SetYLabelAll(QString ylabel) {
for (int i = 0; i < hist_ylabel_vec_.size(); ++i) {
hist_ylabel_vec_[i] = ylabel;
}
ResetGrid();
}
void GRIHist1DGridScrollWidget::SetOutlineColorAll(QColor qcolor) {
for (int i = 0; i < hist_outline_color_vec_.size(); ++i) {
hist_outline_color_vec_[i] = qcolor;
}
ResetGrid();
}
