MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
srand(time(NULL));
ui->setupUi(this);
//Wygląd - wyśrodkowanie, tytuł itd.
this->move(QApplication::desktop()->screen()->rect().center() - this->rect().center());
this->setWindowTitle(VERSION);
//TODO: Poprawić buttony i align na oknie nowej gry
//this->newGameDialog.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
gameHandler = new GameHandler(ui->GraphicsView);
//podpinanie sygnałów
QObject::connect(ui->ActionZakoncz, SIGNAL(triggered()), this, SLOT(close()));
QObject::connect(ui->ActionPomoc, SIGNAL(triggered()), this, SLOT(showHelp()));
QObject::connect(ui->ActionAutor, SIGNAL(triggered()), this, SLOT(showAuthor()));
QObject::connect(ui->ActionNowa, SIGNAL(triggered()), &newGameDialog, SLOT(exec()));
QObject::connect(&newGameDialog, SIGNAL(accepted()), this, SLOT(newGame()));
QObject::connect(this->gameHandler, SIGNAL(moveMade()), this, SLOT(reactToMove()));
QObject::connect(ui->ActionPokazRozwiazanie, SIGNAL(triggered()), this, SLOT(showSolution()));
QObject::connect(&this->solutionTimer, SIGNAL(timeout()), gameHandler, SLOT(makeNextSolutionMove()));
QObject::connect(this->gameHandler->getScene(), SIGNAL(pauseSolution()), this, SLOT(pauseSolution()));
QObject::connect(this->gameHandler->getScene(), SIGNAL(resumeSolution()), this, SLOT(resumeSolution()));
solutionTimer.setInterval(solutionTimerInterval);
solutionTimer.setSingleShot(false);
}
void Sim1D::solve(int loglevel, bool refine_grid)
{
int new_points = 1;
int nsteps;
doublereal dt = m_tstep;
int soln_number = -1;
finalize();
while (new_points > 0) {
size_t istep = 0;
nsteps = m_steps[istep];
bool ok = false;
if (loglevel > 0) {
writeline('.', 78, true, true);
}
while (!ok) {
writelog("Attempt Newton solution of steady-state problem...", loglevel);
int status = newtonSolve(loglevel-1);
if (status == 0) {
if (loglevel > 0) {
writelog(" success.\n\n");
writelog("Problem solved on [");
for (size_t mm = 1; mm < nDomains(); mm+=2) {
writelog(int2str(domain(mm).nPoints()));
if (mm + 2 < nDomains()) {
writelog(", ");
}
}
writelog("] point grid(s).\n");
}
if (loglevel > 6) {
save("debug_sim1d.xml", "debug",
"After successful Newton solve");
}
if (loglevel > 7) {
saveResidual("debug_sim1d.xml", "residual",
"After successful Newton solve");
}
ok = true;
soln_number++;
} else {
char buf[100];
writelog(" failure. \n", loglevel);
if (loglevel > 6) {
save("debug_sim1d.xml", "debug",
"After unsuccessful Newton solve");
}
if (loglevel > 7) {
saveResidual("debug_sim1d.xml", "residual",
"After unsuccessful Newton solve");
}
writelog("Take "+int2str(nsteps)+" timesteps ", loglevel);
dt = timeStep(nsteps, dt, DATA_PTR(m_x), DATA_PTR(m_xnew),
loglevel-1);
if (loglevel > 6) {
save("debug_sim1d.xml", "debug", "After timestepping");
}
if (loglevel > 7) {
saveResidual("debug_sim1d.xml", "residual",
"After timestepping");
}
if (loglevel == 1) {
sprintf(buf, " %10.4g %10.4g \n", dt,
log10(ssnorm(DATA_PTR(m_x), DATA_PTR(m_xnew))));
writelog(buf);
}
istep++;
if (istep >= m_steps.size()) {
nsteps = m_steps.back();
} else {
nsteps = m_steps[istep];
}
dt = std::min(dt, m_tmax);
}
}
if (loglevel > 0) {
writeline('.', 78, true, true);
}
if (loglevel > 2) {
showSolution();
}
if (refine_grid) {
new_points = refine(loglevel);
if (new_points) {
// If the grid has changed, preemptively reduce the timestep
// to avoid multiple successive failed time steps.
dt = m_tstep;
}
if (new_points && loglevel > 6) {
save("debug_sim1d.xml", "debug", "After regridding");
}
if (new_points && loglevel > 7) {
saveResidual("debug_sim1d.xml", "residual",
"After regridding");
}
if (new_points < 0) {
writelog("Maximum number of grid points reached.");
new_points = 0;
}
} else {
writelog("grid refinement disabled.\n", loglevel);
new_points = 0;
}
}
}
/**
* \fn int gameLoop(sInterface *p_interface, sMap *p_map)
* \brief Fonction de rendu de l'enigme et d'interfacage avec l'utilisateur
*
* \param *p_interface pointeur vers une structure de type sInterface
* \param *p_map pointeur vers une structure de type sMap
* \return int représentant le déroulement de la fonction
*/
int gameLoop(sInterface *p_interface, sMap *p_map) {
bool l_loop = TRUE, l_solve = FALSE;
char txtCmpt[32] = "";
SDL_Rect l_posText = {(WINDOW_WIDTH / CASE_COLUMN_AMOUNT)/2, (WINDOW_HEIGHT / CASE_LINE_AMOUNT)/2, 50, 50};
SDL_Color l_color = {255, 0, 0};
p_interface->player.mapPosition.x = p_map->starting.x;
p_interface->player.mapPosition.y = p_map->starting.y;
p_interface->player.realPosition = getRealPosition(p_interface->player.mapPosition);
p_interface->player.realDestination = getRealPosition(p_interface->player.mapPosition);
displayMap(p_interface, p_map);
while (l_loop){
if(SDL_PollEvent(&(p_interface->event))) {
switch (p_interface->event.type) {
case(SDL_KEYDOWN):
switch (p_interface->event.key.keysym.sym) {
case(SDLK_z):
updateGoal(p_interface, p_map, DUP);
break;
case(SDLK_d):
updateGoal(p_interface, p_map, DRIGHT);
break;
case(SDLK_s):
updateGoal(p_interface, p_map, DDOWN);
break;
case(SDLK_q):
updateGoal(p_interface, p_map, DLEFT);
break;
case(SDLK_x):
l_solve = !l_solve;
break;
case(SDLK_ESCAPE):
l_loop = FALSE;
break;
}
break;
case(SDL_MOUSEBUTTONDOWN):
break;
}
while (SDL_PollEvent(&(p_interface->event)));
}
SDL_RenderClear(p_interface->renderer);
SDL_RenderCopy(p_interface->renderer, p_interface->backgroundSprite, NULL, NULL);
if(l_solve)
showSolution(p_interface, p_interface->solution);
renderParticle(&(p_interface->effect.particle), p_interface, p_map, TRUE);
updateVision(p_interface, p_map);
sprintf_s(txtCmpt, 30, "%d", p_interface->compteur);
displayText(p_interface->renderer, txtCmpt, l_color, l_posText);
SDL_RenderPresent(p_interface->renderer);
if (WinOrNot(p_interface, p_map)) {
l_loop = FALSE;
}
SDL_Delay(SDL_ANIMATION_FRAMETIME);
}
return 0;
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
setMinimumSize(450, 480);
newGameMenu = menuBar()->addMenu("New game");
optionsMenu = menuBar()->addMenu("Options");
helpMenu = menuBar()->addMenu("Help");
easyGame = new QAction("Easy", this);
newGameMenu->addAction(easyGame);
connect(easyGame, SIGNAL(triggered()), this, SLOT(generateEasy()));
easyGame->setShortcut(Qt::CTRL + Qt::Key_1);
mediumGame = new QAction("Medium", this);
newGameMenu->addAction(mediumGame);
connect(mediumGame, SIGNAL(triggered()), this, SLOT(generateMedium()));
mediumGame->setShortcut(Qt::CTRL + Qt::Key_2);
hardGame = new QAction("Hard", this);
newGameMenu->addAction(hardGame);
connect(hardGame, SIGNAL(triggered()), this, SLOT(generateHard()));
hardGame->setShortcut(Qt::CTRL + Qt::Key_3);
/*randomGame = new QAction("Random", this);
newGameMenu->addAction(randomGame);
connect(randomGame, SIGNAL(triggered()), this, SLOT(generateRandom()));
randomGame->setShortcut(Qt::CTRL + Qt::Key_4);*/
solve = new QAction("Solve", this);
optionsMenu->addAction(solve);
connect(solve, SIGNAL(triggered()), this, SLOT(showSolution()));
solve->setShortcut(Qt::CTRL + Qt::Key_F);
stopSolving = new QAction("Stop solving", this);
optionsMenu->addAction(stopSolving);
connect(stopSolving, SIGNAL(triggered()), this, SLOT(solvingStopped()));
stopSolving->setShortcut(Qt::CTRL + Qt::Key_R);
previousMove = new QAction("Move back", this);
optionsMenu->addAction(previousMove);
connect(previousMove, SIGNAL(triggered()), this, SLOT(moveBack()));
previousMove->setShortcut(Qt::CTRL + Qt::Key_Z);
nextMove = new QAction("Move forward", this);
optionsMenu->addAction(nextMove);
connect(nextMove, SIGNAL(triggered()), this, SLOT(moveForward()));
nextMove->setShortcut(Qt::CTRL + Qt::Key_Y);
getInfo = new QAction("Instructions", this);
helpMenu->addAction(getInfo);
connect(getInfo, SIGNAL(triggered()), this, SLOT(showInstructions()));
getInfo->setShortcut(Qt::Key_F1);
gview = new Graphics();
setCentralWidget(gview);
scene = new QGraphicsScene();
scene->setBackgroundBrush(QColor("#e0e0e0"));
gview->setScene(scene);
gview->setEnabled(true);
counter = new QLabel();
for (int i = 1; i <= 15; i++)
tiles[i] = NULL;
srand(time(NULL));
gameBoard = NULL;
generateEasy();
statusBar()->addWidget(counter);
timer = new QTimer(this);
timer->setInterval(400);
connect(timer, SIGNAL(timeout()), this, SLOT(moveForward()));
}
