├── Action.cpp
├── Action.h
├── CONTRIBUTORS
├── Config.h
├── Field.cpp
├── Field.h
├── LICENSE
├── Makefile
├── Player.cpp
├── Player.h
├── README
├── Replay.cpp
├── Replay.h
├── Timer.cpp
├── Timer.h
├── common.cpp
├── common.h
├── main.cpp
├── scores.cpp
├── scores.h
└── screenshot.png


/Action.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <iomanip>
 3 | #include "Action.h"
 4 | 
 5 | using namespace std;
 6 | 
 7 | Action::Action() {}
 8 | 
 9 | Action::Action(int px, int py, int pb, long pp) {
10 |     x=px;
11 |     y=py;
12 |     button=pb;
13 |     timeSinceStart=pp;
14 | }
15 | 
16 | void Action::dump() {
17 |     cout <<setw(7)<<timeSinceStart<<setw(7) <<x<<setw(7)<<y<<setw(7)<<button<< endl;
18 | }
19 | 


--------------------------------------------------------------------------------
/Action.h:
--------------------------------------------------------------------------------
 1 | #ifndef ACTION_H
 2 | #define ACTION_H
 3 | 
 4 | class Action {
 5 | public:
 6 |     
 7 |     int x, y;
 8 |     int button;
 9 |     long timeSinceStart;
10 | 
11 |     Action();
12 | 
13 |     Action(int, int, int, long);
14 | 
15 |     void dump();
16 | };
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/CONTRIBUTORS:
--------------------------------------------------------------------------------
1 | spacecamper at github	main developer
2 | adminq80 at github	Makefile improvement
3 | zkittleson at github	code refactoring
4 | 


--------------------------------------------------------------------------------
/Config.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONFIG_H
 2 | #define CONFIG_H
 3 | 
 4 | #include "Player.h"
 5 | 
 6 | struct Config {
 7 |     Player* player;
 8 |     int windowWidth;
 9 |     int windowHeight;
10 |     int originalWidth;
11 |     int originalHeight;
12 |     int squareSize;
13 |     int scoreListLength;
14 | };
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/Field.cpp:
--------------------------------------------------------------------------------
  1 | #ifdef __APPLE__
  2 | #include <OpenGL/OpenGL.h>
  3 | #include <GLUT/glut.h>
  4 | #else
  5 | #include <GL/glut.h>
  6 | #include <GL/freeglut_ext.h>
  7 | #endif
  8 | 
  9 | #include <sys/stat.h>
 10 | #include "Config.h"
 11 | #include "common.h"
 12 | #include "Field.h"
 13 | #include "Timer.h"
 14 | #include "Replay.h"
 15 | #include "scores.h"
 16 | 
 17 | using namespace std;
 18 | 
 19 | extern void redisplay();
 20 | 
 21 | extern bool playReplay;
 22 | extern int gameState;
 23 | extern bool isFlagging;
 24 | extern bool gamePaused;
 25 | 
 26 | //extern unsigned short hitMineX, hitMineY;
 27 | extern int squareSize;
 28 | //extern char playerName[21];
 29 | extern char configDirectory[100];
 30 | 
 31 | 
 32 | Field::Field() {
 33 | 
 34 |     val3BV=0;
 35 |     
 36 | }
 37 | 
 38 | 
 39 | bool Field::replayFileNumberExists(long nr) {
 40 |     struct stat buffer;  
 41 |     char rfname[100];
 42 |         
 43 |     char tmp[110];
 44 |     strcpy(tmp,configDirectory);
 45 |     sprintf(rfname,"%lu.replay",nr);
 46 | 
 47 |     strcat(tmp,rfname);
 48 |     
 49 |     if (stat(tmp, &buffer) != 0) {
 50 |         return false;
 51 |     }
 52 | 
 53 |     return true;
 54 | }
 55 | 
 56 | long Field::findLowestUnusedReplayNumber() {
 57 |     long lower=1;
 58 |     long upper=1;
 59 |     
 60 |     while (true) {
 61 |         if (!replayFileNumberExists(upper)) break;
 62 | 
 63 |         lower=upper;
 64 |         upper*=2;
 65 |     }
 66 | 
 67 |     long middle=0;
 68 | 
 69 |     // binary search
 70 |     while (lower<upper-1) {
 71 |         middle=(lower+upper)/2;
 72 |         
 73 |         if (replayFileNumberExists(middle)) {
 74 |             lower=middle;
 75 |         }
 76 |         else {
 77 |             upper=middle;
 78 |         }
 79 |     }
 80 | 
 81 |     return upper;
 82 | }
 83 | 
 84 | void Field::unpauseGame() {
 85 |     gamePaused=false;
 86 |     timer.unpause();
 87 |     replay.recording = true;
 88 |     cout << "Game unpaused."<<endl;
 89 | }
 90 | 
 91 | void Field::saveReplay(const char *fname, Score *score) {
 92 |     ofstream ofile;
 93 |     
 94 |     char fullpath[110];
 95 |     strcpy(fullpath,configDirectory);
 96 |     strcat(fullpath,fname);
 97 | 
 98 |     ofile.open (fullpath);
 99 | 
100 |     if (!ofile.is_open()) {
101 |         cerr<<"Error opening file " << fullpath << " for writing replay."<<endl;
102 |         return;
103 |     }
104 | 
105 |     replay.writeToFile(&ofile, this, score);
106 |     ofile.close();
107 | }
108 | 
109 | void Field::ffmProc(int tmpField[MAX_WIDTH][MAX_HEIGHT],int i,int j) {
110 |     if (tmpField[i][j]!=3) { 
111 |         bool isZero=(tmpField[i][j]==0);
112 | 
113 |         tmpField[i][j]=3;
114 | 
115 |         if (isZero) {
116 |             floodFillMark(tmpField,i,j);
117 |         }
118 |     }
119 | 
120 | }
121 | 
122 | 
123 | void Field::floodFillMark(int tmpField[MAX_WIDTH][MAX_HEIGHT],int i,int j) {
124 | 
125 |     if (i>0) {
126 |         if (j>0) ffmProc(tmpField,i-1,j-1);
127 |         ffmProc(tmpField,i-1,j);
128 |         if (j<height-1) ffmProc(tmpField,i-1,j+1);
129 |         
130 |     }
131 | 
132 |     if (j>0) ffmProc(tmpField,i,j-1);
133 |     if (j<height-1) ffmProc(tmpField,i,j+1);
134 | 
135 |     if (i<width-1) {
136 |         if (j>0) ffmProc(tmpField,i+1,j-1);
137 |         ffmProc(tmpField,i+1,j);
138 |         if (j<height-1) ffmProc(tmpField,i+1,j+1);
139 |     }
140 |     
141 | 
142 | }
143 | 
144 | int Field::calculate3BV() {
145 | 
146 | 
147 |     int tmpField[MAX_WIDTH][MAX_HEIGHT];    // 0=0, 1=other number, 2=mine, 3=processed
148 | 
149 |     int tmp3BV=0;
150 | 
151 | 
152 |     // temp zero all
153 | 
154 |     for (int i=0;i<width;i++) 
155 |         for (int j=0;j<height;j++) 
156 |             tmpField[i][j]=0;
157 | 
158 | 
159 |     // mark "numbers" as 1
160 | 
161 |     for (int i=0;i<width;i++) 
162 |         for (int j=0;j<height;j++) 
163 |             if (mine[i][j]) {
164 |                 
165 |                 if (i>0) {
166 |                     if (j>0) tmpField[i-1][j-1]=1;
167 |                     tmpField[i-1][j]=1;
168 |                     if (j<height-1) tmpField[i-1][j+1]=1;
169 |                 }
170 |                 
171 |                 if (j>0) tmpField[i][j-1]=1;
172 |                 if (j<height-1) tmpField[i][j+1]=1;
173 |             
174 |                 if (i<width-1) {
175 |                     if (j>0) tmpField[i+1][j-1]=1;
176 |                     tmpField[i+1][j]=1;
177 |                     if (j<height-1) tmpField[i+1][j+1]=1;
178 |                 }
179 |             }
180 | 
181 |     // mark mines as 2
182 | 
183 |     for (int i=0;i<width;i++) 
184 |         for (int j=0;j<height;j++) 
185 |             if (mine[i][j]) 
186 |                 tmpField[i][j]=2;
187 | 
188 |     for (int i=0;i<width;i++) 
189 |         for (int j=0;j<height;j++) 
190 |             if (tmpField[i][j]==0) {
191 |                 tmp3BV++;
192 |                 tmpField[i][j]=3;
193 | 
194 |                 floodFillMark(tmpField,i,j);
195 |             }
196 | 
197 |     for (int i=0;i<width;i++) 
198 |         for (int j=0;j<height;j++) 
199 |             if (tmpField[i][j]==1)
200 |                 tmp3BV++;
201 | 
202 | //    cout << "[ 3BV calculated as "<<tmp3BV<<"]"<<endl;
203 | 
204 |     return tmp3BV;
205 | 
206 | }
207 | 
208 | int Field::get3BV() {
209 |     if (val3BV==0)
210 |         val3BV=calculate3BV();
211 | 
212 |     return val3BV;
213 | 
214 | }
215 | 
216 | 
217 | void Field::checkValues() {
218 | 
219 |    if (height<2) 
220 |         height=2;
221 |     else if (height>MAX_HEIGHT) 
222 |         height=MAX_HEIGHT;
223 |     
224 | 
225 |     if (width<2) 
226 |         width=2;
227 |     else if (width>MAX_WIDTH) 
228 |         width=MAX_WIDTH;
229 |     
230 |     if (mineCount>=height*width)
231 |         mineCount=height*width-2;
232 |     else if (mineCount<2)
233 |         mineCount=2;
234 | 
235 | }
236 | 
237 | 
238 | bool Field::isMine(int x, int y) {
239 | 
240 |     if (x<0 || x>=width) {
241 |         cerr << "x=="<<x<<" out of bounds"<<endl;
242 |         exit(1);
243 |     }
244 |     else if (y<0 || y>=height) {
245 |         cerr << "y=="<<y<<" out of bounds"<<endl;
246 |         exit(1);
247 |     }
248 |     else
249 |         return mine[x][y];
250 | 
251 | 
252 |     return false;
253 | }
254 | 
255 | void Field::setMine(int x, int y) {
256 | 
257 |     mine[x][y]=true;
258 | }
259 | 
260 | 
261 | void Field::placeMines(int firstClickX, int firstClickY) {
262 | 
263 |     for (int i=0;i<width;i++) {
264 |         for (int j=0;j<width;j++) {
265 |             mine[i][j]=false;
266 |         }
267 |     }
268 | 
269 | 
270 |     for (int i=0;i<mineCount;i++) {
271 |         int x=rand()%width;
272 |         int y=rand()%height;
273 |         if (mine[x][y] or (firstClickX==x and firstClickY==y))
274 |             i--;
275 |         else
276 |             mine[x][y]=true;
277 |     }
278 | 
279 |     val3BV=0;
280 | 
281 |     redisplay();
282 | 
283 | 
284 | }
285 | 
286 | void Field::init() {
287 |     
288 | 
289 |     for (int i=0;i<width;i++) {
290 |         for (int j=0;j<height;j++) {
291 |             state[i][j]=9;
292 |         }
293 |     }
294 |     gameState=GAME_INITIALIZED;
295 |     isFlagging=false;
296 |     timer.reset();
297 | 
298 |     gamePaused=false;
299 | 
300 |     effectiveClicks=0;
301 |     ineffectiveClicks=0;
302 | }
303 | 
304 | void Field::newGame() {
305 |     init();
306 |     replay.deleteData();
307 |     cout << "------------------------------------------------------------" << endl; 
308 | }
309 | 
310 | void Field::showStatistics(bool won, Score score, bool playingReplay) {
311 | 
312 |     if (won) {
313 | 
314 |         
315 |         cout << endl<<"YOU WIN!"<<endl;
316 | 
317 |         if (playingReplay) {
318 |             cout << setw(8)<<left << "Time: " << setprecision(3) << fixed << score.time/1000.0
319 |                 << " s" << endl;
320 |             cout << setw(8)<<left << "3BV/s: " << setprecision(4)<< fixed<<score.get3BVs()<<endl;
321 | 
322 |             cout <<setw(8)<<left << "IOE: " << setprecision(4)<<fixed<< score.getIOE()<<endl;
323 |         
324 |             cout << setw(8)<<left << "3BV: " << get3BV()<<endl;
325 |         }
326 |         
327 |         cout << "You played " << (isFlagging?"":"non-") << "flagging."<<endl;
328 |         cout << endl;
329 |     }
330 |     else {
331 |         cout << endl<< "YOU HIT A MINE. You played for " << setprecision(3) << fixed <<
332 |             score.time/1000.0 <<" seconds." << endl << "3BV: " 
333 |             << setprecision(4) << fixed << score.val3BV << endl;
334 |     }
335 | 
336 | }
337 | 
338 | void Field::endGame(const bool won) {
339 |     timer.stop();
340 |     replay.recording = false;
341 |     gameState=won ? GAME_WON : GAME_LOST;
342 | 
343 |     redisplay();
344 | 
345 |     const long timeTaken=timer.calculateElapsedTime();
346 |     const long ts=time(NULL);
347 |     
348 |     Score newScore;
349 | 
350 |     newScore.timeStamp=ts;
351 |     strcpy(newScore.name,playerName);
352 |     newScore.width=width;
353 |     newScore.height=height;
354 |     newScore.mines=mineCount;
355 | 
356 |     newScore.time=timeTaken;
357 |     newScore.val3BV=get3BV();
358 |     newScore.flagging=isFlagging;
359 | 
360 | 
361 |     newScore.effectiveClicks=effectiveClicks;
362 |     newScore.ineffectiveClicks=ineffectiveClicks;
363 | 
364 |     newScore.squareSize=squareSize;
365 |     newScore.gameWon=won;
366 | 
367 |     viewClicks();
368 | 
369 | 
370 | 
371 |     
372 |     
373 |     
374 |     if(!playReplay) {
375 |         char fullpath[110];
376 |         strcpy(fullpath,configDirectory);
377 |         strcat(fullpath,"scores.dat");
378 |  
379 |         showStatistics(won,newScore,playReplay);
380 |         
381 |         if(won) {
382 |       //      cout << endl << "YOU WIN!" << endl;
383 |       //      cout << "You played " << (isFlagging?"":"non-") << "flagging."<<endl;
384 |             
385 |             int scoreListLength = ((Config*)glutGetWindowData())->scoreListLength;
386 |             int oldFinalResultDisplay = ((Config*)glutGetWindowData())->player->field.oldFinalResultDisplay;
387 | 
388 |             Score *scores;
389 | 
390 |             int count=loadScores(fullpath,&scores);
391 | 
392 | 
393 |             int *zero;
394 |             zero=0;
395 |             
396 |             evalScore(newScore,scores, count, width, height, mineCount,oldFinalResultDisplay,scoreListLength); // XXX
397 | 
398 |             free(scores); 
399 | 
400 |             // find the lowest unused replay file number
401 |             
402 |             long nr=1;
403 | 
404 |             nr=findLowestUnusedReplayNumber();
405 |             newScore.replayNumber=nr;
406 |             appendScore(fullpath,newScore);
407 | 
408 |             char rfname[100];
409 | 
410 |             char tmp[110];
411 |             strcpy(tmp,configDirectory);
412 |             sprintf(rfname,"%lu.replay",nr);
413 | 
414 |             saveReplay(rfname,&newScore);
415 | 
416 |             saveReplay("last.replay",&newScore);
417 |         } 
418 |         else {
419 |        //     cout << endl << "YOU HIT A MINE!" << endl;
420 |         //    cout << "You played " << (isFlagging?"":"non-") << "flagging."<<endl;
421 |             
422 |             newScore.replayNumber=0;
423 |             appendScore(fullpath,newScore);
424 | 
425 |             saveReplay("last.replay", &newScore  );
426 |         }
427 |     }
428 |     else {
429 |         //showStatistics(won,newScore);
430 | 
431 | 
432 |         Config* config = (Config*)glutGetWindowData();
433 |         if (config->player->replayHasScore) {
434 |             
435 |             showStatistics(won, config->player->score, playReplay);
436 |         }
437 |     }
438 | }
439 | 
440 | void Field::revealAround(int squareX, int squareY) {
441 | 
442 |     // reveal squares around a square
443 | 
444 |     if (squareX>0) {
445 |         if (squareY>0) revealSquare(squareX-1,squareY-1);
446 |         revealSquare(squareX-1,squareY);
447 |         if (squareY<height-1) revealSquare(squareX-1,squareY+1);
448 |         
449 |     }
450 | 
451 |     if (squareY>0) revealSquare(squareX,squareY-1);
452 |     if (squareY<height-1) revealSquare(squareX,squareY+1);
453 | 
454 |     if (squareX<width-1) {
455 |         if (squareY>0) revealSquare(squareX+1,squareY-1);
456 |         revealSquare(squareX+1,squareY);
457 |         if (squareY<height-1) revealSquare(squareX+1,squareY+1);
458 |     }
459 |     
460 | }
461 | 
462 | 
463 | void Field::revealSquare(int squareX, int squareY) {
464 | 
465 |     // clicked (or asked to reveal) unrevealed square
466 | 
467 | 
468 |     if (state[squareX][squareY]==9) {
469 |         if (mine[squareX][squareY]) {
470 | 
471 |             state[squareX][squareY] = 11;            
472 |             
473 |             endGame(false);
474 |         }
475 |         else {
476 | 
477 |             int adjacentMines=0;
478 |             if (squareX>0) {
479 |                 if (squareY>0) adjacentMines+=mine[squareX-1][squareY-1]?1:0;
480 |                 adjacentMines+=mine[squareX-1][squareY]?1:0;
481 |                 if (squareY<height) adjacentMines+=mine[squareX-1][squareY+1]?1:0;
482 |                 
483 |             }
484 | 
485 |             if (squareY>0) adjacentMines+=mine[squareX][squareY-1]?1:0;
486 |             if (squareY<height-1) adjacentMines+=mine[squareX][squareY+1]?1:0;
487 | 
488 |             if (squareX<width-1) {
489 |                 if (squareY>0) adjacentMines+=mine[squareX+1][squareY-1]?1:0;
490 |                 adjacentMines+=mine[squareX+1][squareY]?1:0;
491 |                 if (squareY<height-1) adjacentMines+=mine[squareX+1][squareY+1]?1:0;
492 |             }
493 |             
494 |             state[squareX][squareY]=adjacentMines;
495 | 
496 |             if (adjacentMines==0) {
497 |                 revealAround(squareX,squareY);
498 |             }
499 | 
500 |             if (gameState==GAME_INITIALIZED or gameState==GAME_PLAYING) {
501 |                 
502 |                 bool notFinished=false;
503 | 
504 |                 for (int i=0;i<width;i++) 
505 |                     for (int j=0;j<height;j++) 
506 |                         if ((state[i][j]==9 or state[i][j]==10) and not mine[i][j])
507 |                             notFinished=true;
508 | 
509 |                 if (!notFinished) {
510 |                     endGame(true);
511 |                 }    
512 |             }
513 |     
514 |         }
515 |     } 
516 | }
517 | 
518 | bool Field::adjacentMinesFlagged(int squareX,int squareY) {
519 |     // count adjacent mines and possibly reveal adjacent squares
520 | 
521 |     int flaggedAdjacentMines=0;
522 |     if (squareX>0) {
523 |         if (squareY>0) flaggedAdjacentMines+=state[squareX-1][squareY-1]==10?1:0;
524 |         flaggedAdjacentMines+=state[squareX-1][squareY]==10?1:0;
525 |         if (squareY<height) flaggedAdjacentMines+=state[squareX-1][squareY+1]==10?1:0;
526 |         
527 |     }
528 | 
529 |     if (squareY>0) flaggedAdjacentMines+=state[squareX][squareY-1]==10?1:0;
530 |     if (squareY<height) flaggedAdjacentMines+=state[squareX][squareY+1]==10?1:0;
531 | 
532 |     if (squareX<width) {
533 |         if (squareY>0) flaggedAdjacentMines+=state[squareX+1][squareY-1]==10?1:0;
534 |         flaggedAdjacentMines+=state[squareX+1][squareY]==10?1:0;
535 |         if (squareY<height) flaggedAdjacentMines+=state[squareX+1][squareY+1]==10?1:0;
536 |     }
537 | 
538 |     if (flaggedAdjacentMines==state[squareX][squareY]) 
539 |         return true;
540 |     else
541 |         return false;
542 | }
543 | 
544 | int Field::calculateRemainingMines() {
545 |     int remaining=mineCount;
546 |     
547 |     for (int i=0;i<width;i++) 
548 |         for (int j=0;j<width;j++) 
549 |             if (state[i][j]==10)
550 |                 remaining--;
551 | 
552 |     return remaining;
553 | }
554 | 
555 | void Field::viewClicks() {
556 |     cout << "Clicks: "<<effectiveClicks<<" / "<<ineffectiveClicks<<endl;
557 | }
558 | 
559 | void Field::startGame(int squareX, int squareY) {
560 |     if (!playReplay)
561 |         placeMines(squareX,squareY);
562 | 
563 |     timer.start();
564 |     gameState=GAME_PLAYING;
565 | }
566 | 
567 | void Field::click(int x,int y,int button) {
568 | 
569 |     int squareX=(x-FIELD_X)/squareSize;
570 |     int squareY=(y-FIELD_Y)/squareSize;
571 | 
572 | 
573 |     if (!replay.recording and !playReplay and !gamePaused) {
574 |         replay.recording = true;
575 |     }    
576 | 
577 |     if (gameState==GAME_INITIALIZED and button==GLUT_LEFT_BUTTON) {
578 |         startGame(squareX, squareY);
579 |     }
580 |     
581 |     replay.recordEvent(x, y, button, timer.calculateElapsedTime());   
582 |     
583 | 
584 |     if (button!=-1) {
585 | 
586 |         if(state[squareX][squareY]==9 and (button==GLUT_LEFT_BUTTON or button==GLUT_RIGHT_BUTTON)) { // unrevealed
587 |             if(button==GLUT_LEFT_BUTTON) {
588 |                 effectiveClicks++;
589 |                 revealSquare(squareX, squareY);
590 |             }
591 |             else if(button==GLUT_RIGHT_BUTTON) {
592 |                 state[squareX][squareY]=10;
593 |                 if (!isFlagging) {
594 |                     cout<<"You are now playing with flagging."<<endl;
595 |                     isFlagging=true;
596 |                 }
597 |                 effectiveClicks++;
598 |             }
599 |         }
600 | 
601 |         else if(state[squareX][squareY]==10 and button==GLUT_RIGHT_BUTTON){ // flag
602 |             state[squareX][squareY]=9;
603 |             effectiveClicks++;
604 |         }
605 |         
606 |         else if (state[squareX][squareY]<=8 and state[squareX][squareY]!=0 and
607 |                 adjacentMinesFlagged(squareX,squareY) and
608 |                 (button==GLUT_LEFT_BUTTON or button==GLUT_RIGHT_BUTTON or button==GLUT_MIDDLE_BUTTON)) {
609 |             effectiveClicks++;
610 |             revealAround(squareX,squareY);
611 |         }
612 |         else if (button==GLUT_LEFT_BUTTON or button==GLUT_RIGHT_BUTTON or button==GLUT_MIDDLE_BUTTON) {
613 |             ineffectiveClicks++;
614 |         }
615 |         
616 |         if (gameState==0)
617 |             viewClicks();
618 |     }
619 | }
620 | 


--------------------------------------------------------------------------------
/Field.h:
--------------------------------------------------------------------------------
 1 | #ifndef FIELD_H
 2 | #define FIELD_H
 3 | 
 4 | #include "Replay.h"
 5 | #include "Timer.h"
 6 | #include "common.h"
 7 | #include "scores.h"
 8 | 
 9 | 
10 | class Field {
11 | public:
12 |     short width, height;
13 |     short mineCount;
14 |     char playerName[21];
15 |     
16 |     bool oldFinalResultDisplay;
17 |     
18 |     Replay replay;
19 |     Timer timer;
20 | 
21 |     bool mine[MAX_WIDTH][MAX_HEIGHT];
22 |     int state[MAX_WIDTH][MAX_HEIGHT];  // 0-8 - adjacent mine count for revealed field, 9 - not revealed, 10 - flag
23 |     int val3BV;
24 |     unsigned int effectiveClicks;
25 |     unsigned int ineffectiveClicks;
26 | 
27 |     bool isMine(int x, int y);
28 |     void setMine(int x, int y);
29 |     void init();
30 |     void newGame();
31 |     int calculateRemainingMines();
32 |     void checkValues();
33 |     void click(int x, int y, int button);
34 |     void unpauseGame();
35 |     int calculate3BV(); //Calculates minimum number of clicks to solve the board
36 |     Field();
37 | private:
38 |     void endGame(const bool);
39 |     void viewClicks();
40 |     int get3BV();
41 |     void startGame(int, int);
42 |     void placeMines(int firstClickX, int firstClickY);
43 |     void saveReplay(const char*,Score*);
44 |     long findLowestUnusedReplayNumber();
45 |     void revealAround(int squareX, int squareY);
46 |     bool adjacentMinesFlagged(int squareX,int squareY);
47 |     void revealSquare(int squareX, int squareY);
48 |     bool replayFileNumberExists(long);
49 |     void floodFillMark(int [MAX_WIDTH][MAX_HEIGHT],int,int);
50 |     void ffmProc(int [MAX_WIDTH][MAX_HEIGHT],int,int);
51 |     void showStatistics(bool, Score, bool);
52 | };
53 | 
54 | #endif
55 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015-2019, 2021, 2023 spacecamper
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CXX = g++
 2 | CXXFLAGS = -Wall -g
 3 | PROG = miny
 4 | 
 5 | 
 6 | ifeq ($(shell uname),Darwin)
 7 | 	LDLIBS = -framework OpenGL -framework GLUT
 8 | else
 9 | 	LDLIBS = -lglut -lGL -lGLU
10 | endif
11 | 
12 | all: $(PROG)
13 | 
14 | $(PROG): Timer.o main.o Replay.o Field.o scores.o common.o Player.o Action.o
15 | 	${CXX} -o $@ $^ ${LDLIBS}
16 | 
17 | main.o: main.cpp 
18 | 
19 | clean:
20 | 	rm -f $(PROG) *.o
21 | 


--------------------------------------------------------------------------------
/Player.cpp:
--------------------------------------------------------------------------------
  1 | #ifdef __APPLE__
  2 | #include <OpenGL/OpenGL.h>
  3 | #include <GLUT/glut.h>
  4 | #else
  5 | #include <GL/glut.h>
  6 | #endif
  7 | 
  8 | #include "Timer.h"
  9 | #include "Player.h"
 10 | #include "Field.h"
 11 | #include "Action.h"
 12 | #include "scores.h"
 13 | 
 14 | //extern char playerName[21];
 15 | extern int squareSize;
 16 | extern int gameState;
 17 | extern int originalWidth;
 18 | extern int originalHeight;
 19 | extern bool playReplay;
 20 | extern bool gamePaused;
 21 | 
 22 | int Player::loadReplay(const char *fname) {
 23 |     ifstream ifile;
 24 | 
 25 |     ifile.open(fname);
 26 |     if (!ifile.is_open()) {
 27 |         cerr<<"Error opening replay file '"<<fname<<"'."<<endl;
 28 |         return 1;
 29 |     }
 30 |     string content((istreambuf_iterator<char>(ifile) ), (istreambuf_iterator<char>()    )) ;
 31 |     if (string::npos != content.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_.@- \x0d\x0a-:")) {
 32 |         cout << "Replay file contains invalid characters. Exiting."<<endl;
 33 |         exit(1);
 34 |     }
 35 | 
 36 |     ifile.close();
 37 |     ifile.open(fname);
 38 | 
 39 |     readFromFile(&ifile);
 40 | 
 41 |     ifile.close();
 42 | 
 43 |     return 0;
 44 | }
 45 | 
 46 | Player::Player() {
 47 |     refreshQueue();
 48 |     nextPlayed = data.begin();
 49 | }
 50 | 
 51 | void Player::refreshQueue() {
 52 |     Action* action = new Action(0, 0, -1, 0);
 53 |     data.push_back(*action);
 54 | }
 55 | 
 56 | void Player::readFromFile(ifstream *ifile) {
 57 | 
 58 |     string firstString;
 59 | 
 60 |     *ifile >> firstString;
 61 | 
 62 |     int fileVersion;
 63 | 
 64 |     if (firstString=="miny-replay-file-version:") {
 65 |         *ifile >> fileVersion;
 66 |     }
 67 |     else {
 68 |         fileVersion=-1;
 69 |     }
 70 | 
 71 | 
 72 |     replayHasScore=false;
 73 | 
 74 |     switch(fileVersion) {
 75 |     case -1:
 76 |         cout << "Unknown replay file format. Exiting." << endl;
 77 |         exit(1);
 78 |     case 1: {
 79 | 
 80 |         string tmpname;
 81 |         
 82 |         *ifile >> field.playerName; 
 83 |         
 84 |         *ifile >> squareSize;
 85 |         
 86 |         *ifile >> field.width >> field.height;
 87 |         
 88 |         int mineCount=0;
 89 |         bool tmpmine;
 90 |         for (int j=0;j<field.height;j++) 
 91 |             for (int i=0;i<field.width;i++) {
 92 |                 
 93 |                 *ifile >> tmpmine;
 94 |                 if (tmpmine) {
 95 |                     field.setMine(i,j);
 96 |                     mineCount++;    
 97 |                 }
 98 |             }
 99 | 
100 |         field.mineCount=mineCount;
101 | 
102 |         int count;
103 |         *ifile>>count;
104 |         Action *rp;
105 | 
106 |         for (int i=0;i<count;i++) {
107 |             rp=new Action();
108 | 
109 |             *ifile >> rp->timeSinceStart >> rp->x >> rp->y >> rp->button;
110 | 
111 |             if (i==0)
112 |                 rp->timeSinceStart=0;
113 | 
114 |             data.push_back(*rp);
115 | //            cout << "rp" << endl;
116 |         }
117 | 
118 |         break;
119 |         }
120 |     case 2: {
121 | 
122 |         string tmpname;
123 |         
124 |         replayHasScore=true;
125 |         score.readFromFile(ifile);
126 |         strcpy(field.playerName,score.name);
127 |         squareSize=score.squareSize;
128 |         field.width=score.width;
129 |         field.height=score.height;
130 | 
131 | 
132 |         int mineCount=0;
133 |         bool tmpmine;
134 |         for (int j=0;j<field.height;j++) 
135 |             for (int i=0;i<field.width;i++) {
136 |                 
137 |                 *ifile >> tmpmine;
138 |                 if (tmpmine) {
139 |                     field.setMine(i,j);
140 |                     mineCount++;    
141 |                 }
142 |             }
143 | 
144 |         field.mineCount=mineCount;
145 | 
146 |         int count;
147 |         *ifile>>count;
148 |         Action *rp;
149 | 
150 |         for (int i=0;i<count;i++) {
151 |             rp=new Action();
152 | 
153 |             *ifile >> rp->timeSinceStart >> rp->x >> rp->y >> rp->button;
154 | 
155 |             if (i==0)
156 |                 rp->timeSinceStart=0;
157 | 
158 |             data.push_back(*rp);
159 |         }
160 | 
161 |         break;
162 |         }
163 |         
164 | 
165 |     default:
166 |         cout << "Unknown replay file version. You are probably running an old version of the"<<endl<<"game. Please upgrade to the latest version." << endl;
167 |         exit(1);
168 |     }
169 | 
170 | 
171 | 
172 | }
173 | 
174 | bool Player::playStep(bool firstClick) {
175 |     std::list<Action>::iterator next;
176 |     next=nextPlayed;
177 |     next++;
178 |     
179 |     if (nextPlayed->timeSinceStart!=-1){
180 |         if (nextPlayed->timeSinceStart > field.timer.calculateElapsedTime()) {
181 |             return true;
182 |         }
183 |         
184 |         if ((*nextPlayed).button>=-1) {
185 |             takeAction(nextPlayed->button, nextPlayed->x, nextPlayed->y);
186 |         }
187 |         else {
188 |             takeAction((unsigned char)(-nextPlayed->button), nextPlayed->x, nextPlayed->y);
189 |         }
190 |         nextPlayed->timeSinceStart=-1;
191 |     }
192 | 
193 |     if (next==data.end()) {
194 |         if (playReplay) {
195 |             cout<<"End of Replay."<<endl;
196 |             return false;
197 |         }
198 |     }
199 |     else {
200 |         nextPlayed=next;
201 |     }
202 |     return true;
203 | }
204 | 
205 | void Player::takeAction(int button, int x, int y) {
206 |     if ((gameState==GAME_INITIALIZED or gameState==GAME_PLAYING)) {
207 |         // this should've been "x>=FIELD_X" and "y>=FIELD_Y", now
208 |         // the top row and left column are 1 pixel narrower
209 |         if (x>FIELD_X and x<FIELD_X+field.width*squareSize 
210 |             and y>FIELD_Y and y<FIELD_Y+field.height*squareSize) { // field
211 |             field.click(x, y, button);
212 |         }
213 | 
214 |         else if (x>originalWidth/2-12-DISPLAY_BORDER_WIDTH/2 and 
215 |                 x<originalWidth/2+12+DISPLAY_BORDER_WIDTH/2 and
216 |                 y>BORDER_WIDTH and 
217 |                 y<BORDER_WIDTH+24+DISPLAY_BORDER_WIDTH and
218 |                 button!=-1) {
219 |             field.newGame();
220 |         }
221 |         glutPostRedisplay();
222 |     }
223 |     else if (!(x>FIELD_X and 
224 |             x<FIELD_X+field.width*squareSize and 
225 |             y>FIELD_Y and 
226 |             y<FIELD_Y+field.height*squareSize) and
227 |             button!=-1) { // outside of field - new game
228 |         field.newGame();
229 |     }
230 |     cursorX=x;
231 |     cursorY=y;
232 | }
233 | 
234 | void Player::takeAction(unsigned char button, int x, int y) {
235 |     switch (button) {
236 |     case ' ':
237 |         if (!gamePaused and !playReplay) {
238 |             field.newGame();
239 |         }
240 |         break;
241 |     case 'p':   // pause
242 |         if (gameState==GAME_PLAYING and !playReplay) {
243 |             if (!gamePaused) {
244 | 
245 |                 gamePaused=true;
246 |                 field.timer.pause(); 
247 |                 field.replay.recording = false;
248 |                 cout << "Game paused. Press P to continue. Elapsed time: "
249 |                     <<field.timer.calculateElapsedTime()<<" ms"<<endl;
250 |             }
251 |             else {
252 |                 field.unpauseGame();
253 |             }
254 |         }
255 |         break;
256 |     case 'r':
257 |         field.replay.dump();
258 |         cout << field.calculate3BV() << endl;
259 |         break;
260 |     case 'd':
261 |         cout << sizeof(Score)<<endl;
262 |         break;
263 | 
264 |     case 'q':
265 |         exit(0);
266 |     case 27:    // escape
267 |         exit(0);
268 |         break;
269 |     }
270 | }
271 | 
272 | void Player::handleInput(int button, int x, int y) {
273 |     Action* input = new Action(x, y, button, 0);
274 |     data.push_back(*input);
275 |  //   field.replay.data.push_back(*(new Action(x,y,button,(gameState==GAME_INITIALIZED ? 0 : field.timer.calculateElapsedTime()))));   
276 |  //   field.replay.recordEvent(x,y,button,field.timer.calculateElapsedTime());
277 | 
278 | 
279 | 
280 | }
281 | 


--------------------------------------------------------------------------------
/Player.h:
--------------------------------------------------------------------------------
 1 | #ifndef PLAYER_H
 2 | #define PLAYER_H
 3 | 
 4 | #include <list>
 5 | #include <fstream>
 6 | 
 7 | #include <iostream>
 8 | #include <iomanip>
 9 | 
10 | #include "Action.h"
11 | #include "Field.h"
12 | #include "scores.h"
13 | 
14 | class Player {
15 | public:
16 |     Field field;
17 |     bool playbackOn;
18 |     Score score;
19 | 	bool replayHasScore;
20 |     int cursorX,cursorY; //player
21 |     
22 |     Player();
23 |     
24 |     void handleInput(int, int, int);
25 |     bool playStep(bool); //player
26 |     int loadReplay(const char* fname);
27 |     
28 | private:
29 |     std::list<Action> data;
30 |     std::list<Action>::iterator nextPlayed;
31 |     
32 |     void readFromFile(ifstream*); //player
33 |     void takeAction(unsigned char, int, int);
34 |     void takeAction(int, int, int);
35 |     void refreshQueue();
36 | };
37 | 
38 | #endif
39 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
  1 | Miny
  2 | 
  3 | A minesweeper clone.
  4 | 
  5 | 
  6 | FEATURES
  7 | 
  8 |  - Linux native
  9 |  - time, 3BV/s and IOE high scores, including percentiles and non-flagging 
 10 |    versions
 11 |  - scores kept indefinitely for all played games
 12 |  - recording and playing replays
 13 |  - CSV export
 14 |  - timing in milliseconds
 15 |  - responsive on slow hardware
 16 |  - adjustable square size
 17 |  - to reveal squares around a numbered square with flagged adjacent mines you
 18 |    can click the square with any button
 19 |  - no "?" marks
 20 |  - pause
 21 | 
 22 | 
 23 | TO DO
 24 | 
 25 |  - set window class to use with some window managers
 26 |  - prevent buffer overflows
 27 |  - estimate final statistics for a lost game, based on progress until losing
 28 | 
 29 | 
 30 | COMPILING AND PLAYING
 31 | 
 32 |  To compile run 'make'. You'll need to have OpenGL libraries installed, on
 33 |  Ubuntu and Debian those should be covered by the package freeglut3-dev.
 34 | 
 35 |  To play run './miny [options]'. For best results run from terminal.
 36 | 
 37 |  While playing, you can see how many effective / ineffective clicks you have
 38 |  made.
 39 | 
 40 |  After every game the replay is saved in the .miny subdirectory of the user's 
 41 |  home directory as 'last.replay'. Replays for won games are also saved as 
 42 |  [number].replay. See below for how to play them.
 43 | 
 44 | 
 45 | CURRENT GAME RESULTS TABLE
 46 | 
 47 |  After every won game there's a table showing how the current game ranks among
 48 |  all other results, and, if this game was non-flagging, among all other
 49 |  non-flagging results. That includes this game's place and percentile.
 50 | 
 51 |  Place is the position of this game among all other games (e.g. 213th).
 52 | 
 53 |  Percentile is a number between 0 and 100 saying how many percent of results 
 54 |  were worse than this game. 100 means this is the best result of all, 50 
 55 |  means this is the middle result etc. The higher this number is, the better.
 56 |  As of now this number is not exact but gives an approximate idea of how your
 57 |  game ranks.
 58 | 
 59 |  
 60 | MOUSE AND KEYBOARD CONTROLS
 61 | 
 62 |  Apart from intuitive minesweeper mouse controls, these work:
 63 | 
 64 |  To start a new game press Space or click the yellow square or, after a game 
 65 |  has ended, click anywhere outside the playfield.
 66 | 
 67 |  To pause/unpause while playing press P.
 68 | 
 69 |  To quit press Escape or Q.
 70 | 
 71 | 
 72 | OPTIONS
 73 | 
 74 |   Options with a question mark take a value.
 75 | 
 76 |   Game setup:
 77 | 
 78 |  -n?  player name. If this option is missing, system username is used.
 79 |  -d?  difficulty - 0, 1, 2, 3 or 4 (1 - Beginner, 2 - Intermediate (default), 
 80 |       3 - Expert, 4 - Beginner Classic, 0 - all of the preceding four. 0 can
 81 |       be used when displaying scores) If -w, -h and -m are set, this option
 82 |       is ignored.
 83 |  -s?  square size in pixels (3 to 100, default=35)
 84 |  -m?  number of mines (min=2, max depends on field dimensions)
 85 |  -w?  field width (2 to 100)
 86 |  -h?  field height (2 to 100)
 87 | 
 88 | 
 89 |   Result display:
 90 | 
 91 |  -t   list best times for the selected setup
 92 |  -3   list best 3BV/s for the selected setup
 93 |  -i   list best IOEs for the selected setup
 94 |  -c   list results as CSV, e.g. for further analysis in Excel/Calc. Scores are
 95 |       listed in the order they were achieved, i.e. ordered by date. The -l 
 96 |       option is ignored in this case, all scores specified by other options
 97 |       are displayed.
 98 | 
 99 | 
100 |   Result filter:
101 | 
102 |  -f?  select results by flagging (0 - all (default), 1 - flagging only, 
103 |       2 - non-flagging only)
104 |  -g?  select results by whether the game was won (0 - all, 1 - won only 
105 |       (default), 2 - lost only) (using this option may produce buggy results)
106 |  -l?  number of best results to display. (0 - all, default=20)
107 | 
108 | 
109 |   Other:
110 | 
111 |  -p?  play replay file. Value is by default either 'last' for the last played 
112 |       game or a number found in the Rep column of the high score table for 
113 |       other games.
114 |  -C?  config directory different to the default $HOME/.miny
115 |  -o   display the currently finished game result the more brief, old way
116 | 
117 | 
118 | NOTES
119 |  
120 |  Since version 0.5.0, the game stores scores in a new way, with more data 
121 |  about played games. There currently isn't and probably won't be a tool to 
122 |  convert old scores to the new system. If you don't want to keep them, you 
123 |  can delete *.hiscore (and whichever *.replay you don't want) files from your 
124 |  $HOME/.miny directory.
125 | 
126 | 
127 | EXAMPLES
128 | 
129 |  ./miny                     # start game on intermediate difficulty
130 | 
131 |  ./miny -d3 -njoe -s40      # start game on expert difficulty, player name joe,
132 |                             # square size 40
133 | 
134 |  ./miny -w10 -h10 -m10      # start game with the specified parameters
135 | 
136 |  ./miny -t                  # list best times for intermediate
137 | 
138 |  ./miny -d0 -3              # list best 3BV/s for beg, int, exp and beC
139 |                               combined
140 | 
141 |  ./miny -d3 -f2 -t          # list best times for expert, non-flagging 
142 |                             # only
143 | 
144 |  ./miny -d1 -3              # list best 3BV/s for beginner
145 | 
146 |  ./miny -w10 -h10 -m10 -t   # list best times for games with the specified 
147 |                             # parameters
148 | 
149 |  ./miny -d2 -c > scores.csv # export intermediate scores as CSV to scores.csv
150 | 
151 |  ./miny -p last             # play replay for the last game played
152 | 
153 |  ./miny -p 4                # play the selected replay
154 | 
155 | 


--------------------------------------------------------------------------------
/Replay.cpp:
--------------------------------------------------------------------------------
 1 | #ifdef __APPLE__
 2 | #include <OpenGL/OpenGL.h>
 3 | #include <GLUT/glut.h>
 4 | #else
 5 | #include <GL/glut.h>
 6 | #endif
 7 | 
 8 | #include "common.h"
 9 | #include "Timer.h"
10 | #include "Replay.h"
11 | #include "Action.h"
12 | #include "Field.h"
13 | 
14 | extern int gameState;
15 | //extern Timer timer;
16 | extern int squareSize;
17 | 
18 | Replay::Replay() {
19 |     recording=false;
20 | }
21 | 
22 | void Replay::deleteData() {
23 |     data.clear();
24 | }
25 | 
26 | void Replay::recordEvent(int x, int y, int button, long elapsedTime) {
27 |     if (recording) {
28 |         data.push_back(*(new Action(x,y,button,(gameState==GAME_INITIALIZED ? 0 : elapsedTime))));
29 |     //    cout << "Elapsed time: " << elapsedTime << endl;
30 |     }
31 | }
32 | 
33 | void Replay::writeToFile(ofstream *file, void* fieldPtr, Score *score) {
34 |     Field* field = (Field*)fieldPtr;
35 | 
36 |     *file << "miny-replay-file-version: 2" << endl;
37 | 
38 |    /* *file << field->playerName << endl << squareSize << endl;
39 | 
40 |     *file << field->width << " " << field->height << endl;
41 | */
42 | 
43 |     score->writeToFile(file);
44 | 
45 |     for (int j=0;j<field->height;j++) {
46 |         for (int i=0;i<field->width;i++) 
47 |             *file << field->isMine(i,j) << " ";
48 |         *file << endl;
49 |     }
50 | 
51 |     *file << endl;
52 |     *file << data.size() << endl;
53 | 
54 |     std::list<Action>::iterator iter;
55 | 
56 |     for (iter=data.begin(); iter!=data.end(); iter++) {
57 |         *file << (*iter).timeSinceStart << " " << (*iter).x << " " << (*iter).y << " " << (*iter).button << endl;
58 |     }
59 | }
60 | 
61 | void Replay::dump() {
62 |     cout << "Dumping replay data."<<endl;
63 |     
64 |     std::list<Action>::iterator iter;
65 | 
66 |     for (iter=data.begin(); iter!=data.end(); iter++) {
67 |         (*iter).dump();
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/Replay.h:
--------------------------------------------------------------------------------
 1 | #ifndef REPLAY_H
 2 | #define REPLAY_H
 3 | 
 4 | #include <list>
 5 | #include <fstream>
 6 | 
 7 | #include <iostream>
 8 | #include <iomanip>
 9 | 
10 | #include "Action.h"
11 | #include "scores.h"
12 | 
13 | 
14 | using namespace std;
15 | 
16 | class Replay {
17 | public:
18 | 
19 |     bool recording;
20 |     Score score;
21 | 
22 |     std::list<Action> data;
23 | 
24 |     Replay();
25 | 
26 |     void deleteData(); //recorder
27 |     void recordEvent(int, int, int, long); //recorder
28 |     void writeToFile(ofstream*, void*,Score*); //recorder
29 |     void dump();
30 | };
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/Timer.cpp:
--------------------------------------------------------------------------------
  1 | #include "Timer.h"
  2 | #include "common.h"
  3 | 
  4 | 
  5 | extern int gameState;
  6 | extern bool gamePaused;
  7 | 
  8 | 
  9 | 
 10 | long Timer::calculateTimeSinceStart() {
 11 |     
 12 |     if (gameState==GAME_INITIALIZED)
 13 |         return 0;
 14 |     else {
 15 | 
 16 |         long seconds, useconds;    
 17 | 
 18 |         struct timeval now;
 19 | 
 20 |         gettimeofday(&now, NULL);
 21 | 
 22 |         seconds  = now.tv_sec  - timeStarted.tv_sec;
 23 |         useconds = now.tv_usec - timeStarted.tv_usec;
 24 | 
 25 |         return ((seconds) * 1000 + useconds/1000.0) + 0.5;
 26 |     }
 27 | 
 28 | }
 29 | 
 30 | 
 31 | long Timer::calculateTimePaused() {
 32 | 
 33 |     if (gameState==GAME_INITIALIZED) {
 34 |         return 0;
 35 |     }
 36 |     else if (gameState==GAME_PLAYING) {
 37 |         if (gamePaused) {
 38 |             return totalTimePaused+calculateTimeSinceStart()-pausedSince;
 39 |         }
 40 |         else {
 41 |             return totalTimePaused;
 42 |         }
 43 |     }
 44 |     else {
 45 |         return totalTimePaused;
 46 |     }
 47 | 
 48 | 
 49 | }
 50 | 
 51 | long Timer::calculateElapsedTime() {
 52 | 
 53 |     // calculates time from first click till now (when playing) or till game has ended,
 54 |     //  minus the time when game was paused
 55 | 
 56 |     long seconds, useconds;    
 57 |     long elapsedTime;
 58 | 
 59 |     
 60 | 
 61 |     if (gameState==GAME_PLAYING) {
 62 | 
 63 | 
 64 |         elapsedTime=calculateTimeSinceStart()-calculateTimePaused();
 65 |         
 66 |     }
 67 |     else if (gameState==GAME_LOST or gameState==GAME_WON) {
 68 | 
 69 |         seconds  = timeFinished.tv_sec  - timeStarted.tv_sec;
 70 |         useconds = timeFinished.tv_usec - timeStarted.tv_usec;
 71 | 
 72 |         elapsedTime=((seconds) * 1000 + useconds/1000.0) + 0.5-totalTimePaused;
 73 | 
 74 |     }
 75 |     else
 76 |         elapsedTime=0;
 77 | 
 78 |     return elapsedTime;
 79 | 
 80 |         
 81 | }
 82 | 
 83 | void Timer::start() {
 84 | 
 85 |     gettimeofday(&timeStarted, NULL);
 86 | }
 87 | 
 88 | void Timer::stop() {
 89 |     gettimeofday(&timeFinished, NULL);
 90 | }
 91 | 
 92 | void Timer::reset() {
 93 |     totalTimePaused=0;
 94 | }
 95 | 
 96 | void Timer::pause() {
 97 |     pausedSince=calculateTimeSinceStart();
 98 | }
 99 | 
100 | void Timer::unpause() {
101 |     totalTimePaused+=calculateTimeSinceStart()-pausedSince;
102 | }
103 | 
104 | 
105 | 


--------------------------------------------------------------------------------
/Timer.h:
--------------------------------------------------------------------------------
 1 | #ifndef TIMER_H
 2 | #define TIMER_H
 3 | 
 4 | #include <stdlib.h>
 5 | #include <sys/time.h>
 6 | 
 7 | class Timer {
 8 | public:
 9 |     long calculateElapsedTime();
10 | 
11 |     void start();
12 | 
13 |     void stop();
14 | 
15 |     void reset();
16 | 
17 |     void pause();
18 | 
19 |     void unpause();
20 |     
21 | private:
22 |     struct timeval timeStarted, timeFinished;
23 |     
24 |     long pausedSince;
25 |     
26 |     long totalTimePaused;
27 |     
28 |     long calculateTimePaused();
29 |     
30 |     long calculateTimeSinceStart();
31 | };
32 | #endif
33 | 


--------------------------------------------------------------------------------
/common.cpp:
--------------------------------------------------------------------------------
 1 | #include "common.h"
 2 |  
 3 | using namespace std;
 4 | 
 5 | bool isValidName(char *n) {
 6 | 
 7 |     char *c=n;
 8 |     char *validChars="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_.@-";
 9 |             
10 | 
11 |     while(*c) {
12 |         if (!strchr(validChars,*c)) {
13 |             return false;
14 |         }
15 |         c++;
16 |     }
17 | 
18 | 
19 |     if (strlen(n)>MAX_NAME_LENGTH) {
20 |         return false;
21 |     }
22 | 
23 |     return true;
24 |     
25 | 
26 | }
27 | 
28 | 
29 | 
30 | void ordinalNumberSuffix(char *suffix, int n) {
31 | 
32 |     int rem100=n%100;
33 | 
34 |     if (rem100==11 or rem100==12 or rem100==13) {
35 |         strcpy(suffix,"th");
36 |         return;
37 |     }
38 | 
39 |     switch(n%10) {
40 |     case 1: strcpy(suffix,"st"); break;
41 |     case 2: strcpy(suffix,"nd"); break;
42 |     case 3: strcpy(suffix,"rd"); break;
43 |     default: strcpy(suffix,"th"); break;
44 |     }
45 |     
46 | }
47 | 
48 | 
49 | unsigned int terminalWidth() {
50 | 
51 |     struct winsize w;
52 |     ioctl(0, TIOCGWINSZ, &w);
53 | 
54 |   //  printf ("lines %d\n", w.ws_row);
55 |    // printf ("columns %d\n", w.ws_col);
56 | 
57 |     return w.ws_col;
58 | 
59 | 
60 | }
61 | 
62 | 
63 | bool outputLine(string l,int w) {
64 | 
65 | //    int tw=terminalWidth();
66 |     bool truncated=false;
67 | 
68 |     if (l.size()>w) {
69 |         l.resize(w);
70 |         truncated=true;
71 |     }
72 | 
73 |     cout << l << endl;
74 |     return truncated;
75 | }
76 | 
77 | 


--------------------------------------------------------------------------------
/common.h:
--------------------------------------------------------------------------------
 1 | #ifndef COMMON_H
 2 | #define COMMON_H
 3 | 
 4 | #include <stdio.h>
 5 | #include <cstring>
 6 | #include <string>
 7 | #include <iostream>
 8 | #include <sys/ioctl.h>
 9 | 
10 | #include <unistd.h>
11 | 
12 | using namespace std;
13 | 
14 | #define GAME_INITIALIZED -1
15 | #define GAME_PLAYING 0
16 | #define GAME_LOST 1
17 | #define GAME_WON 2
18 | 
19 | #define MAX_WIDTH 100
20 | #define MAX_HEIGHT 100
21 | 
22 | 
23 | #define BORDER_WIDTH 10
24 | #define DISPLAY_BORDER_WIDTH 4
25 | #define FIELD_X 10
26 | #define FIELD_Y 48
27 | 
28 | 
29 | #define MAX_HS 20
30 | #define SCORE_FILE_VERSION 5
31 | 
32 | #define MAX_NAME_LENGTH 20
33 | 
34 | void ordinalNumberSuffix(char *, int);
35 | 
36 | unsigned int terminalWidth();
37 | 
38 | bool outputLine(string,int);
39 | 
40 | bool isValidName(char *);
41 | 
42 | #endif
43 | 
44 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Miny
  3 |  * a minesweeper clone
  4 |  * (c) 2015-2019, 2021, 2023 spacecamper
  5 |  */
  6 | 
  7 | #include <stdlib.h>
  8 | #include <iostream>
  9 | #include <math.h>
 10 | 
 11 | #include <unistd.h>
 12 | #include <stdio.h>
 13 | #include <string.h>
 14 | #include <dirent.h>
 15 | #include <sys/stat.h>
 16 | #include <errno.h>
 17 | #include <fstream>
 18 | #include <sstream>
 19 | #include <algorithm>
 20 | #include <list>
 21 | #include <iomanip>
 22 | 
 23 | #ifdef __APPLE__
 24 | #include <OpenGL/OpenGL.h>
 25 | #include <GLUT/glut.h>
 26 | #else
 27 | #include <GL/glut.h>
 28 | #include <GL/freeglut_ext.h>
 29 | #endif
 30 | 
 31 | #include "Config.h"
 32 | #include "Replay.h"
 33 | #include "Player.h"
 34 | #include "common.h"
 35 | 
 36 | #include "Timer.h"
 37 | 
 38 | #include "scores.h"
 39 | 
 40 | 
 41 | #define VERSION "0.6.0"
 42 | 
 43 | 
 44 | 
 45 | 
 46 | // TODO prevent buffer overflows (strcpy and strcat)
 47 | // TODO free allocated memory (after using scores from loadScores and filterScores is finished)
 48 | 
 49 | using namespace std;
 50 | 
 51 | 
 52 | int windowWidth, windowHeight, originalWidth, originalHeight;
 53 | int squareSize;
 54 | 
 55 | int gameState; // -1 - initialized, 0 - playing, 1 - lost, 2 - won
 56 | char option_char;
 57 | char configDirectory[100];
 58 | bool isFlagging;
 59 | bool gamePaused;
 60 | bool playReplay;
 61 | bool boolDrawCursor;
 62 | 
 63 | void redisplay() {
 64 |     glutPostRedisplay();
 65 | }
 66 | 
 67 | 
 68 | bool directoryExists( const char* pzPath )
 69 | {
 70 |     if ( pzPath == NULL) return false;
 71 | 
 72 |     DIR *pDir;
 73 |     bool bExists = false;
 74 | 
 75 |     pDir = opendir (pzPath);
 76 | 
 77 |     if (pDir != NULL)
 78 |     {
 79 |         bExists = true;    
 80 |         (void) closedir (pDir);
 81 |     }
 82 | 
 83 |     return bExists;
 84 | }
 85 | 
 86 | // ----------------------- GRAPHICS -------------------- //
 87 | 
 88 | void drawRect(float x, float y, float w, float h) {
 89 |     glBegin(GL_TRIANGLES);
 90 | 
 91 |     glVertex2f(x,y);
 92 |     glVertex2f(x+w,y);
 93 |     glVertex2f(x,y+h);
 94 | 
 95 |     glVertex2f(x,y+h);
 96 |     glVertex2f(x+w,y+h);
 97 |     glVertex2f(x+w,y);
 98 | 
 99 |     glEnd();
100 | }
101 | 
102 | void drawDigitRect(int i, int x, int y, float zoom=1) {
103 |     // Draws a segment of a number
104 |     float u=2*zoom; 
105 |     
106 |     switch(i) {
107 |     case 0: drawRect(x,y,3*u,u); break;
108 |     case 1: drawRect(x,y,u,3*u); break;
109 |     case 2: drawRect(x+2*u,y,u,3*u); break;
110 |     case 3: drawRect(x,y+2*u,3*u,u); break;
111 |     case 4: drawRect(x,y+2*u,u,3*u); break;
112 |     case 5: drawRect(x+2*u,y+2*u,u,3*u); break;
113 |     case 6: drawRect(x,y+4*u,3*u,u); break;
114 |     case 7: drawRect(x+u,y,u,3*u); break;
115 |     case 8: drawRect(x+u,y+2*u,u,3*u); break;
116 |     }
117 | }
118 | 
119 | void drawDigit(int n, int x, int y, float zoom) {
120 |     // draw a digit 10 px high, 6 px wide (if zoom==1)
121 |     switch(n) {
122 |     case 0:
123 |         drawDigitRect(0,x,y,zoom);
124 |         drawDigitRect(1,x,y,zoom);
125 |         drawDigitRect(2,x,y,zoom);
126 |         drawDigitRect(4,x,y,zoom);
127 |         drawDigitRect(5,x,y,zoom);
128 |         drawDigitRect(6,x,y,zoom);
129 |         break;
130 |     case 1:
131 |         drawDigitRect(7,x,y,zoom);
132 |         drawDigitRect(8,x,y,zoom);
133 |         break;
134 |     case 2:
135 |         drawDigitRect(0,x,y,zoom);
136 |         drawDigitRect(2,x,y,zoom);
137 |         drawDigitRect(3,x,y,zoom);
138 |         drawDigitRect(4,x,y,zoom);
139 |         drawDigitRect(6,x,y,zoom);
140 |         break;
141 |     case 3:
142 |         drawDigitRect(0,x,y,zoom);
143 |         drawDigitRect(2,x,y,zoom);
144 |         drawDigitRect(3,x,y,zoom);
145 |         drawDigitRect(5,x,y,zoom);
146 |         drawDigitRect(6,x,y,zoom);
147 |         break;
148 |     case 4:
149 |         drawDigitRect(1,x,y,zoom);
150 |         drawDigitRect(2,x,y,zoom);
151 |         drawDigitRect(3,x,y,zoom);
152 |         drawDigitRect(5,x,y,zoom);
153 |         break;
154 |     case 5:
155 |         drawDigitRect(0,x,y,zoom);
156 |         drawDigitRect(1,x,y,zoom);
157 |         drawDigitRect(3,x,y,zoom);
158 |         drawDigitRect(5,x,y,zoom);
159 |         drawDigitRect(6,x,y,zoom);
160 |         break;
161 |     case 6:
162 |         drawDigitRect(0,x,y,zoom);
163 |         drawDigitRect(1,x,y,zoom);
164 |         drawDigitRect(3,x,y,zoom);
165 |         drawDigitRect(4,x,y,zoom);
166 |         drawDigitRect(5,x,y,zoom);
167 |         drawDigitRect(6,x,y,zoom);
168 |         break;
169 |     case 7:
170 |         drawDigitRect(0,x,y,zoom);
171 |         drawDigitRect(2,x,y,zoom);
172 |         drawDigitRect(5,x,y,zoom);
173 |         break;
174 |     case 8:
175 |         drawDigitRect(0,x,y,zoom);
176 |         drawDigitRect(1,x,y,zoom);
177 |         drawDigitRect(2,x,y,zoom);
178 |         drawDigitRect(3,x,y,zoom);
179 |         drawDigitRect(4,x,y,zoom);
180 |         drawDigitRect(5,x,y,zoom);
181 |         drawDigitRect(6,x,y,zoom);
182 |         break;
183 |     case 9:
184 |         drawDigitRect(0,x,y,zoom);
185 |         drawDigitRect(1,x,y,zoom);
186 |         drawDigitRect(2,x,y,zoom);
187 |         drawDigitRect(3,x,y,zoom);
188 |         drawDigitRect(5,x,y,zoom);
189 |         drawDigitRect(6,x,y,zoom);
190 |         break;
191 |     default:
192 |         drawDigitRect(3,x,y,zoom);
193 |     }
194 | }
195 | 
196 | void drawFlag(int squareSize, int x, int y) {
197 |     glColor3f(1,0,0);
198 |     glBegin(GL_TRIANGLES);
199 |     glVertex2f(x+.1*squareSize,y+.3*squareSize);
200 |     glVertex2f(x+.6*squareSize,y+.1*squareSize);
201 |     glVertex2f(x+.6*squareSize,y+.5*squareSize);
202 |     glColor3f(0,0,0);
203 |     glVertex2f(x+.6*squareSize,y+.6*squareSize);
204 |     glVertex2f(x+.15*squareSize,y+.9*squareSize);
205 |     glVertex2f(x+.9*squareSize,y+.9*squareSize);
206 | 
207 |     glEnd();
208 | }
209 | 
210 | void drawBackground(int fieldWidth, int fieldHeight) {
211 |     // highlight boxes for in game statistics    
212 |     glColor3f(0,0,0);
213 |     drawRect(BORDER_WIDTH,
214 |             BORDER_WIDTH,
215 |             48+DISPLAY_BORDER_WIDTH,
216 |             24+DISPLAY_BORDER_WIDTH);
217 |     glColor3f(0,0,0);
218 |     drawRect(originalWidth-(BORDER_WIDTH+DISPLAY_BORDER_WIDTH+48),
219 |             BORDER_WIDTH,
220 |             48+DISPLAY_BORDER_WIDTH,
221 |             24+DISPLAY_BORDER_WIDTH);
222 |     // new game button
223 |     glColor3f(1,1,0);
224 |     drawRect(originalWidth/2-12-DISPLAY_BORDER_WIDTH/2,
225 |             BORDER_WIDTH,
226 |             24+DISPLAY_BORDER_WIDTH,
227 |             24+DISPLAY_BORDER_WIDTH);
228 | 
229 |     // grid lines
230 |     glColor3f(.3,.3,.3);
231 |     glBegin(GL_LINES); 
232 |     for (int i=0;i<fieldHeight+1;i++) {
233 |         glVertex2f(FIELD_X,FIELD_Y+i*squareSize);
234 |         glVertex2f(FIELD_X+fieldWidth*squareSize,FIELD_Y+i*squareSize);
235 |     }
236 |     for (int i=0;i<fieldWidth+1;i++) {
237 |         glVertex2f(FIELD_X+i*squareSize,FIELD_Y);
238 |         glVertex2f(FIELD_X+i*squareSize,FIELD_Y+fieldHeight*squareSize);
239 |     }
240 |     glEnd();
241 | 
242 | 
243 | }
244 | 
245 | void drawMine(int x, int y, int squareSize) {
246 |     glColor3f(0,0,0);
247 |     glBegin(GL_TRIANGLES);
248 |     glVertex2f((FIELD_X+x*squareSize)+.5*squareSize,(FIELD_Y+y*squareSize)+.1*squareSize);
249 |     glVertex2f((FIELD_X+x*squareSize)+.1*squareSize,(FIELD_Y+y*squareSize)+.5*squareSize);
250 |     glVertex2f((FIELD_X+x*squareSize)+.5*squareSize,(FIELD_Y+(y+1)*squareSize-1)-.1*squareSize);
251 | 
252 |     glVertex2f((FIELD_X+x*squareSize)+.5*squareSize,(FIELD_Y+y*squareSize)+.1*squareSize);
253 |     glVertex2f((FIELD_X+(x+1)*squareSize-1)-.1*squareSize,(FIELD_Y+y*squareSize)+.5*squareSize);
254 |     glVertex2f((FIELD_X+x*squareSize)+.5*squareSize,(FIELD_Y+(y+1)*squareSize-1)-.1*squareSize);
255 | 
256 |     const float gap=.25*squareSize;
257 | 
258 |     glBegin(GL_TRIANGLES);
259 |     glVertex2f((FIELD_X+x*squareSize)+gap,(FIELD_Y+y*squareSize)+gap);
260 |     glVertex2f((FIELD_X+(x+1)*squareSize-1)-gap,(FIELD_Y+y*squareSize)+gap);
261 |     glVertex2f((FIELD_X+(x+1)*squareSize-1)-gap,(FIELD_Y+(y+1)*squareSize-1)-gap);
262 | 
263 |     glVertex2f((FIELD_X+x*squareSize)+gap,(FIELD_Y+y*squareSize)+gap);
264 |     glVertex2f((FIELD_X+x*squareSize)+gap,(FIELD_Y+(y+1)*squareSize-1)-gap);
265 |     glVertex2f((FIELD_X+(x+1)*squareSize-1)-gap,(FIELD_Y+(y+1)*squareSize-1)-gap);
266 | 
267 |     glEnd();
268 | }
269 | 
270 | void drawField(Field field, int squareSize){
271 |     for (int x=0;x<field.width;x++) {
272 |         for (int y=0;y<field.height;y++) {
273 |             const int x1=FIELD_X+x*squareSize;
274 |             const int x2=FIELD_X+(x+1)*squareSize;
275 |             const int y1=FIELD_Y+y*squareSize;
276 |             const int y2=FIELD_Y+(y+1)*squareSize;
277 | 
278 |             const float zoom=1.5*squareSize/25;
279 | 
280 | /*
281 |             // pretty square borders
282 |             if (field.state[x][y]>=0 and field.state[x][y]<=8) {    // revealed square
283 |                 glColor3f(.5,.5,.5);
284 |                 glBegin(GL_LINES); 
285 | 
286 |                 // top
287 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+y*squareSize);
288 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+y*squareSize);
289 |                 
290 |                 // left
291 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+y*squareSize);
292 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+(y+1)*squareSize-1);
293 | 
294 | 
295 |                 // bottom
296 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+(y+1)*squareSize-1);
297 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+(y+1)*squareSize-1);
298 |                 
299 |                 // right
300 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+y*squareSize);
301 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+(y+1)*squareSize-1);
302 |                 
303 | 
304 |                 
305 |                 glEnd();
306 | 
307 |             }
308 |             else if (field.state[x][y]==9 or field.state[x][y]==10) {    // unrevealed or flag
309 |                 
310 |                 glColor3f(.85,.85,.85);
311 |                 glBegin(GL_LINES); 
312 | 
313 |                 // top
314 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+y*squareSize);
315 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+y*squareSize);
316 | 
317 |                 glVertex2f(FIELD_X+x*squareSize+1,FIELD_Y+y*squareSize+1);
318 |                 glVertex2f(FIELD_X+(x+1)*squareSize-2,FIELD_Y+y*squareSize+1);
319 |                 
320 |                 // left
321 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+y*squareSize);
322 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+(y+1)*squareSize-1);
323 | 
324 |                 glVertex2f(FIELD_X+x*squareSize+1,FIELD_Y+y*squareSize+1);
325 |                 glVertex2f(FIELD_X+x*squareSize+1,FIELD_Y+(y+1)*squareSize-2);
326 | 
327 |                 glEnd();
328 | 
329 |                 glColor3f(.55,.55,.55);
330 |                 glBegin(GL_LINES); 
331 | 
332 |                 // bottom
333 |                 glVertex2f(FIELD_X+x*squareSize,FIELD_Y+(y+1)*squareSize-1);
334 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+(y+1)*squareSize-1);
335 | 
336 |                 glVertex2f(FIELD_X+x*squareSize+1,FIELD_Y+(y+1)*squareSize-2);
337 |                 glVertex2f(FIELD_X+(x+1)*squareSize-2,FIELD_Y+(y+1)*squareSize-2);
338 |                 
339 |                 // right
340 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+y*squareSize);
341 |                 glVertex2f(FIELD_X+(x+1)*squareSize-1,FIELD_Y+(y+1)*squareSize-1);
342 |                 
343 |                 glVertex2f(FIELD_X+(x+1)*squareSize-2,FIELD_Y+y*squareSize+1);
344 |                 glVertex2f(FIELD_X+(x+1)*squareSize-2,FIELD_Y+(y+1)*squareSize-2);
345 |                 
346 |                 
347 |                 glEnd();
348 |             }
349 | */
350 | 
351 | 
352 |             if (field.state[x][y]>=0 and field.state[x][y]<=8) {    // revealed square
353 | 
354 | 
355 | 
356 |                 switch(field.state[x][y]) {
357 |                     case 0: glColor3f(.5,.5,.5); break;
358 |                     case 1: glColor3f(0,0,1); break;
359 |                     case 2: glColor3f(0,1,0); break;
360 |                     case 3: glColor3f(1,0,0); break;
361 |                     case 4: glColor3f(0,0,.5); break;
362 |                     case 5: glColor3f(.5,0,0); break;
363 |                     case 6: glColor3f(0,1,1); break;
364 |                     case 7: glColor3f(0,0,0); break;
365 |                     case 8: glColor3f(.7,.7,.7); break;
366 | 
367 |                     default: glColor3f(0,0,0);
368 |                 }
369 |                 if (field.state[x][y]!=0) {
370 |                     // number
371 |                     drawDigit(field.state[x][y],x1+.5*squareSize-3.0*zoom,
372 |                                 y1+.5*squareSize-5.0*zoom,zoom);
373 |                 }
374 |                 //square background
375 | 
376 |                 glColor3f(.5,.5,.5);
377 |                 
378 |                 drawRect(x1, y1, squareSize-1, squareSize-1);
379 |             }
380 |             if ((field.state[x][y]==9 or field.state[x][y]==11) 
381 |                  and (gameState==GAME_LOST or gameState==GAME_WON)
382 |                  and field.isMine(x,y)
383 |                 ) { // unflagged mine after game
384 |                                 
385 |                 drawMine(x, y, squareSize);
386 |                 
387 |             }
388 |             if(field.state[x][y]==11) { // Hit mine
389 |                 glColor3f(1,0,0);
390 |                 drawRect(x1, y1, squareSize-1, squareSize-1);
391 |             }
392 |             if (field.state[x][y]==10) {  // flag
393 |                 // cross out flag where there is no mine
394 |                 if (gameState==GAME_LOST and !field.isMine(x,y)) {
395 |                     const short crossGap=.1*squareSize;
396 |                     
397 |                     glColor3f(0,0,0);
398 | 
399 |                     glBegin(GL_LINES);
400 | 
401 |                     glVertex2f(x1+crossGap,y1+crossGap);
402 |                     glVertex2f(x2-crossGap,y2-crossGap);
403 | 
404 |                     glVertex2f(x2-crossGap,y1+crossGap);
405 |                     glVertex2f(x1+crossGap,y2-crossGap);
406 | 
407 |                     glEnd();
408 |                 }
409 |                 drawFlag(squareSize, x1, y1);
410 |             }
411 |         }
412 |     }
413 | }
414 | 
415 | void displayRemainingMines(int rem) {
416 |     glColor3f(1,0,0);
417 | 
418 |     if (rem>999) rem=999;
419 | 
420 |     int dxy=BORDER_WIDTH+DISPLAY_BORDER_WIDTH;
421 | 
422 |     for (int i=0;i<3;i++) {
423 |         const int digit=rem%10;
424 |         rem/=10;
425 |         drawDigit(digit,32-16*i+dxy,dxy,2);
426 |     }
427 | }
428 | 
429 | void displayElapsedTime(long etime) {
430 |     glColor3f(1,0,0);
431 | 
432 |     if (etime>999) etime=999;
433 | 
434 |     const int dx=originalWidth-BORDER_WIDTH-16;
435 |     const int dy=BORDER_WIDTH+DISPLAY_BORDER_WIDTH;
436 | 
437 |     for (int i=0;i<3;i++) {
438 |         int digit=etime%10;
439 |         etime/=10;
440 |         drawDigit(digit,-16*i+dx,dy,2);
441 |     }
442 | }
443 | 
444 | void drawCursor(int x, int y) {
445 |     glColor3f(1,1,0);
446 |     glBegin(GL_TRIANGLES);
447 | 
448 |     glVertex2f(x,y);
449 |     glVertex2f(x,y+20);
450 |     glVertex2f(x+11,y+17);
451 |     glEnd();
452 | }
453 | 
454 | void drawScene() {
455 | 
456 |     
457 |     glClearColor(.7, .7, .7, 1);
458 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
459 | 
460 |     glOrtho(0.0, windowWidth, windowHeight, 0.0, -1.0, 10.0);
461 |     glMatrixMode(GL_MODELVIEW);
462 |     glLoadIdentity();
463 | 
464 |     Config* config = (Config*)glutGetWindowData();
465 | 
466 |     //cout<< config->player->field.timer.calculateElapsedTime() << endl;
467 | 
468 |     if(!config) { // if the field hasn't yet been configured
469 |         return;
470 |     }
471 | 
472 |     if (boolDrawCursor) {
473 |         drawCursor(config->player->cursorX, config->player->cursorY);
474 |     }
475 |     
476 |     displayRemainingMines(config->player->field.calculateRemainingMines());
477 | 
478 |     displayElapsedTime(config->player->field.timer.calculateElapsedTime()/1000);
479 | 
480 |     if (gamePaused) {    // hide field when game is paused
481 | 
482 |         glColor3f(.5,.5,.5);
483 |         
484 |         drawRect(FIELD_X + .5, FIELD_Y + .5, config->player->field.width*squareSize - 1, config->player->field.height*squareSize - 1);
485 | 
486 |     }
487 |     else {
488 |         drawField(config->player->field, squareSize);
489 |     }
490 | 
491 |     drawBackground(config->player->field.width, config->player->field.height);    
492 | 
493 |     glutSwapBuffers();
494 | }
495 | 
496 | // -------------------------- GLUT ----------------------- //
497 | 
498 | void handleResize(int w, int h) {
499 |     windowWidth=w;
500 |     windowHeight=h;
501 |     glViewport(0, 0, windowWidth, windowHeight);
502 |     glMatrixMode(GL_PROJECTION);
503 |     glLoadIdentity();
504 | }
505 | 
506 | void keyDown(unsigned char key, int x, int y) {
507 |     
508 |     Config* config = (Config*)glutGetWindowData();
509 | 
510 |     config->player->handleInput(-((int)key), 0, 0);
511 | }
512 | 
513 | void mouseClick(int button, int mState, int x, int y) {
514 |     if (!gamePaused and mState==GLUT_DOWN) {
515 |         Config* config = (Config*)glutGetWindowData();
516 |         config->player->handleInput(button, x, y);
517 |     }
518 | }
519 | 
520 | void mouseMove(int x, int y) {
521 |     Config* const config = (Config*)glutGetWindowData();
522 |     config->player->handleInput(-1, x, y);
523 | }
524 | 
525 | 
526 | void update(int value) {
527 |     glutPostRedisplay();
528 |     
529 |     Player* player = ((Config*)glutGetWindowData())->player;
530 | 
531 |     if(!(player->playStep(false))){
532 |         playReplay=false;
533 |     }
534 | 
535 |     // On my computer the first argument here being zero causes the game to register two events close to each other about every 16 ms instead of one event about every 8 ms. This might worsen the experience especially on monitors with higher refresh rate.
536 |     glutTimerFunc(0, update, 0); 
537 | }
538 | 
539 | 
540 | void initGraph(Config* config) {
541 | 
542 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
543 |     windowWidth=FIELD_X+config->player->field.width*config->squareSize+BORDER_WIDTH;
544 |     windowHeight=FIELD_Y+config->player->field.height*config->squareSize+BORDER_WIDTH;
545 | 
546 |     originalWidth=windowWidth;
547 |     originalHeight=windowHeight;
548 | 
549 |     glutInitWindowSize(windowWidth, windowHeight);
550 |         
551 |     char title[100];
552 | 
553 |     strcpy(title,"Miny v");
554 |     strcpy(title+6,VERSION);
555 |     strcpy(title+6+strlen(VERSION),". Player: ");
556 |     strcpy(title+16+strlen(VERSION),config->player->field.playerName);
557 | 
558 |     glutCreateWindow(title);
559 |            
560 |     glEnable(GL_DEPTH_TEST);
561 |                             
562 |     glutSetWindowData((void*)config);
563 |     glutDisplayFunc(drawScene);
564 |     glutKeyboardFunc(keyDown);
565 |     glutReshapeFunc(handleResize);
566 | 
567 |     if(!playReplay) {
568 |         glutMouseFunc(mouseClick);
569 |         glutPassiveMotionFunc(mouseMove);
570 |         glutMotionFunc(mouseMove);
571 |     }
572 | }
573 | 
574 | void displayReplay(char replayFileName[100], Config* config) {
575 |     if (config->player->loadReplay(replayFileName)) {
576 |         exit(1);
577 |     }
578 |     config->squareSize=squareSize;
579 | 
580 |     config->player->field.init();
581 |     cout << "Playing replay..." << endl;
582 |     initGraph(config);
583 | 
584 |     config->player->playStep(true);
585 |     glutTimerFunc(0, update, 0);
586 | }
587 | 
588 | void listScores(int listScoresType, int scoreListLength, int listFlagging, int listFinished, Config* config) {
589 |     // TODO 'other' setups may produce too high 3BV/s etc and break layout
590 | 
591 |     char fullpath[110];
592 |     strcpy(fullpath,configDirectory);
593 |     strcat(fullpath,"scores.dat");
594 | 
595 |     Score *scores;
596 |     int count=loadScores(fullpath,&scores);
597 | 
598 |     if (count==0) {      // no scores in score file
599 |         if (listScoresType!=4)
600 |             cout<<"No high scores yet."<<endl;
601 |     }
602 |     else {
603 |         if (listScoresType!=4) {    // if not display as csv, then info about filter and sort
604 |             cout << endl << "Displaying scores."<<endl;
605 |             cout << setw(16)<<left<<"Sorted by: ";
606 | 
607 |             int (*compareFunc)(const void *,const void *)=NULL;
608 |             switch(listScoresType) {
609 |             case 1:
610 |                 cout << "time" << endl;
611 |                 compareFunc=compareByTime; break;
612 |             case 2:
613 |                 cout << "3BV/s" << endl;
614 |                 compareFunc=compareBy3BVs; break;
615 |             case 3:
616 |                 cout << "IOE" << endl;
617 |                 compareFunc=compareByIOE; break;
618 |             }
619 | 
620 |             cout << setw(16)<<left<<"Flagging: ";
621 |             switch (listFlagging) {
622 |             case 0: cout << "all"<<endl; break;
623 |             case 1: cout << "flagging only"<<endl; break;
624 |             case 2: cout << "non-flagging only"<<endl; break;
625 |             }
626 | 
627 |             cout << setw(16)<<left<<"Won: ";
628 |             switch (listFinished) {
629 |             case 0: cout << "all"<<endl; break;
630 |             case 1: cout << "won only"<<endl; break;
631 |             case 2: cout << "lost only"<<endl; break;
632 |             }
633 | 
634 |             cout << setw(16)<<left<<"Difficulty: ";
635 | 
636 |             
637 |             bool standardDifficulty=false;
638 | 
639 | 
640 |             if (config->player->field.width==0 and config->player->field.height==0 and config->player->field.mineCount==0) {
641 |                 cout << "beginner, intermediate, expert, beginner classic"<<endl; 
642 |                 standardDifficulty=true;
643 |             }
644 |             else if (config->player->field.width==9 and config->player->field.height==9 and config->player->field.mineCount==10) {
645 |                 cout << "beginner only"<<endl; 
646 |                 standardDifficulty=true;
647 |             }
648 |             else if (config->player->field.width==16 and config->player->field.height==16 and config->player->field.mineCount==40) {
649 |                 cout << "intermediate only"<<endl; 
650 |                 standardDifficulty=true;
651 |             }
652 |             else if (config->player->field.width==30 and config->player->field.height==16 and config->player->field.mineCount==99) {
653 |                 cout << "expert only"<<endl; 
654 |                 standardDifficulty=true;
655 |             }
656 |             else if (config->player->field.width==8 and config->player->field.height==8 and config->player->field.mineCount==10) {
657 |                 cout << "beginner classic only"<<endl; 
658 |                 standardDifficulty=true;
659 |             }
660 |             
661 | 
662 | 
663 |             if (!standardDifficulty) 
664 |                 cout << config->player->field.width << "x" << config->player->field.height << ", " << config->player->field.mineCount << " mines" << endl;
665 |             
666 | 
667 | 
668 |             cout << setw(16)<<left<<"Square size: ";
669 |             if (squareSize!=0)
670 |                 cout <<squareSize<<endl;
671 |             else
672 |                 cout << "all"<<endl;
673 | 
674 |             cout << setw(16)<<left<<"Player name: ";
675 |             if (!strcmp(config->player->field.playerName,""))
676 |                 cout<<"all"<<endl;
677 |             else
678 |                 cout<<config->player->field.playerName<<endl;
679 | 
680 |             cout << setw(16)<<left<<"Count: ";
681 |             if (scoreListLength!=0)
682 |                 cout <<scoreListLength<<endl;
683 |             else
684 |                 cout << "all"<<endl;
685 |         
686 |             cout<<endl;
687 | 
688 |             qsort(scores,count,sizeof(Score),compareFunc);
689 |         }
690 | 
691 | 
692 | 
693 |         Score *filteredScores;
694 | 
695 | 
696 |         count=filterScores(scores, count, &filteredScores,listFlagging, listFinished,
697 |             config->player->field.width, config->player->field.height, config->player->field.mineCount, squareSize,config->player->field.playerName);
698 | 
699 |     //    cout<<"count="<<count<<endl;
700 | 
701 |         displayScores(filteredScores,count,scoreListLength,listScoresType==4);
702 | 
703 |         cout<<endl;
704 |         free(scores);
705 |     }
706 | }
707 | 
708 | void beginGame(Config* config) {
709 |     
710 |     config->player->field.checkValues();    
711 | 
712 |     initGraph(config);
713 |     config->player->field.init();
714 | 
715 |     glutTimerFunc(50, update, 0);
716 | }
717 | 
718 | void configureSize(int difficulty, Field* field) {
719 |     if (field->width!=0 and field->height!=0 and field->mineCount!=0) {  // if these values were specified on the command line
720 |         difficulty=-1;      // prevent altering them in the switch
721 |     }
722 |     switch(difficulty) {
723 |         case 0:
724 |             field->height=0;
725 |             field->width=0;
726 |             field->mineCount=0;
727 |             break;
728 |         case 1:
729 |             field->height=9;
730 |             field->width=9;
731 |             field->mineCount=10;
732 |             break;
733 |         case 2:
734 |             field->height=16;
735 |             field->width=16;
736 |             field->mineCount=40;
737 |             break;
738 |         case 3:
739 |             field->height=16;
740 |             field->width=30;
741 |             field->mineCount=99;
742 |             break;
743 |         case 4:
744 |             field->height=8;
745 |             field->width=8;
746 |             field->mineCount=10;
747 |             break;
748 |     } 
749 | }
750 | 
751 | int main(int argc, char** argv) {
752 |     srand (time(NULL));
753 | 
754 |     glutInit(&argc, argv);
755 | 
756 |     Player player;
757 | 
758 |     player.field.height=0;
759 |     player.field.width=0;
760 |     player.field.mineCount=0;
761 |     player.field.replay.recording=false;
762 | 
763 |     
764 |     gameState=GAME_INITIALIZED;
765 |     gamePaused=false;
766 |     boolDrawCursor=false;
767 | 
768 |     char replayName[100];
769 |     char replayFileName[110];
770 |     int listScoresType=0; // 0 - none, 1 - time, 2 - 3bv/s, 3 - ioe, 4 - export as csv
771 | 
772 |     int difficulty=2;   // 0-all of 1 to 4; 1-beg; 2-int; 3-exp; 4-beg classic
773 |     int listFlagging=0;  // 0-both, 1-flagging, 2-nf
774 |     int listFinished=1; //  0-both, 1-finished, 2-unfinished
775 |     int scoreListLength=MAX_HS;        // how many scores to display
776 | 
777 |     bool defaultConfigDirectory=true;
778 | 
779 |     strcpy(configDirectory,getenv("HOME"));
780 |     strcat(configDirectory,"/.miny/");
781 | 
782 |     player.field.playerName[0]='\0';
783 | 
784 |     strcpy(player.field.playerName,"");
785 | 
786 |     player.field.oldFinalResultDisplay=false;
787 | 
788 |     while ((option_char = getopt (argc, argv, "d:s:w:h:m:n:p:t3f:cg:il:C:o")) != -1) {
789 |         switch (option_char) {  
790 |             case 'o':
791 |                 player.field.oldFinalResultDisplay=true;
792 |                 
793 |                 break;
794 |             case 'd': 
795 |                 difficulty=atoi(optarg);
796 |                 break;
797 |             case 's': 
798 |                 squareSize=atoi(optarg);
799 |                 break;
800 |             case 'm': 
801 |                 player.field.mineCount=atoi(optarg);
802 |                 break;
803 |             case 'w': 
804 |                 player.field.width=atoi(optarg);
805 |                 break;
806 |             case 'h': 
807 |                 player.field.height=atoi(optarg);
808 |                 break;
809 |             case 'n':
810 |                 if (strlen(optarg)<20)
811 |                     strcpy(player.field.playerName,optarg);
812 |                 else
813 |                     strncpy(player.field.playerName,optarg,20);
814 |                 
815 |                 break;
816 |             case 'p':
817 |                 strcpy(replayName,optarg);
818 |                 playReplay=true;
819 |                 boolDrawCursor=true;
820 |                 break;
821 |             case 'l':
822 |                 scoreListLength=atoi(optarg);
823 |                 break;
824 |             case '3':
825 |                 listScoresType=2;
826 |                 break;
827 |             case 't':
828 |                 listScoresType=1;
829 |                 break;
830 |             case 'i':
831 |                 listScoresType=3;
832 |                 break;
833 | 
834 |             case 'f':
835 |                 listFlagging=optarg[0]-'0';
836 |                 break;
837 |             case 'g':
838 |                 listFinished=optarg[0]-'0';
839 |                 break;
840 |             case 'c':
841 |                 listScoresType=4;
842 |                 break;
843 |             case 'C': {
844 |                 int length=strlen(optarg);
845 | 
846 |                 if (optarg[strlen(optarg)-1]!='/') 
847 |                     length++;
848 | 
849 |                 if (length>101) {
850 |                     cout<<"Config directory path must be shorter than 100 characters. Exiting."<<endl;
851 |                     exit(1);
852 |                 }
853 |                 else {
854 |                     defaultConfigDirectory=false;
855 |                     strcpy(configDirectory,optarg);
856 |                     if (optarg[strlen(optarg)-1]!='/') 
857 |                         strcat(configDirectory,"/");
858 |                 }
859 |                 break;
860 |                 }
861 |             case '?':
862 |                 exit(1);
863 | 
864 |         }
865 |     }
866 |     
867 |     if (listScoresType==0 and squareSize==0) {
868 |         squareSize=50;
869 |     }
870 | 
871 | 
872 |     if (strlen(player.field.playerName)!=0 && !isValidName(player.field.playerName)) {
873 |         cout << "Name can be max. 20 characters long and can only contain the characters a-z, "
874 |             <<endl<<"A-Z, 0-9, underscore (_), dot (.), at sign (@) and dash (-)."<<endl;
875 |         exit(1);   
876 |     }
877 | 
878 | 
879 |     if (listScoresType!=4) {
880 |         cout<<"Miny v"<<VERSION<<" (c) 2015-2019, 2021, 2023 spacecamper"<<endl;
881 |         cout << "See README for info and help."<<endl;
882 |     }
883 | 
884 |     // config directory
885 | 
886 |     if (!directoryExists(configDirectory)) {
887 |         if (defaultConfigDirectory) {
888 |             if (system("mkdir ~/.miny")) {
889 |                 cerr << "Error creating config directory. Exiting." << endl;
890 |                 exit(1);
891 |             }
892 |         }
893 |         else {
894 |             cout << "Specified config directory doesn't exist. Please create it first." << endl;
895 |             exit(1);
896 |         }
897 |             
898 |     }
899 | 
900 |     if (playReplay) {
901 |         strcpy(replayFileName,configDirectory);       
902 |         strcat(replayFileName,replayName);
903 |         strcat(replayFileName,".replay");
904 |     }
905 |     
906 |     Config config;
907 | 
908 |     config.windowWidth=windowWidth;
909 |     config.windowHeight=windowHeight;
910 |     config.originalWidth=originalWidth;
911 |     config.originalHeight=originalHeight;
912 |     config.squareSize=squareSize;
913 |     config.player=&player;
914 |     config.scoreListLength=scoreListLength;
915 | 
916 |     if (playReplay) {
917 |         displayReplay(replayFileName, &config);
918 |     }
919 |     else { 
920 |         
921 |         configureSize(difficulty, &(player.field));
922 |         
923 |         if (listScoresType!=0) { // list scores
924 |             listScores(listScoresType, scoreListLength, listFlagging, listFinished, &config);
925 |         }
926 |         else {
927 |            // play
928 |  
929 |  
930 |            // set player name to username if not entered with -n and username is a valid name, else set it to "unnamed"
931 | 
932 |             if (strlen(player.field.playerName)==0) {      
933 |                 if (isValidName(getenv("USER")))       
934 |                     if (strlen(getenv("USER"))>20) {
935 |                         strncpy(player.field.playerName,getenv("USER"),20);
936 |                         player.field.playerName[21]='\0';
937 |                     }
938 |                     else {
939 |                         strcpy(player.field.playerName,getenv("USER"));
940 |                     }
941 |                 else {
942 |                     strcpy(player.field.playerName,"unnamed");
943 |                 }
944 |             }
945 | 
946 |           /*  if (config.squareSize==0) {
947 |                 config.squareSize=35;
948 |             }*/
949 | 
950 |             if (config.squareSize<3) {
951 |                 config.squareSize=3;
952 |             }
953 |             else if (config.squareSize>100) {
954 |                 config.squareSize=100;
955 |             }
956 | 
957 |             squareSize=config.squareSize;
958 | 
959 |             beginGame(&config);
960 |         }
961 |     }
962 | 
963 |     if(listScoresType==0){
964 |         glutMainLoop();
965 |     }
966 | 
967 |     return 0;
968 | 
969 | }
970 | 


--------------------------------------------------------------------------------
/scores.cpp:
--------------------------------------------------------------------------------
  1 | #include "common.h"
  2 | #include "scores.h"
  3 | 
  4 | Score::Score() {
  5 |     timeStamp=0;
  6 |     strcpy(name,"not-set-yet");
  7 |     //strcpy(replayFile,"*");
  8 |     replayNumber=0;
  9 |     width=0;
 10 |     height=0;
 11 |     mines=0;
 12 |     time=0;
 13 |     val3BV=0;
 14 |     flagging=false;
 15 |     effectiveClicks=0;
 16 |     ineffectiveClicks=0;
 17 |     squareSize=0;
 18 |     gameWon=false;
 19 | 
 20 | 
 21 | }
 22 | 
 23 | float Score::getIOE() {
 24 |     return (float)val3BV/(float)(effectiveClicks+ineffectiveClicks);
 25 | }
 26 | 
 27 | float Score::get3BVs() {
 28 |     //cout << "val3BV=" << val3BV <<end;
 29 |     return 1000*(float)val3BV/time;
 30 | }
 31 | 
 32 | void Score::writeToFile(ofstream *f) {
 33 | 
 34 |     *f << timeStamp << " " << name << " " << replayNumber << " " << width << " " << height <<
 35 |          " " << mines << " " << time << " " << val3BV << " " << flagging << " " << effectiveClicks <<
 36 |          " " << ineffectiveClicks << " " << squareSize << " " << gameWon << endl;
 37 | 
 38 | 
 39 | }
 40 | 
 41 | void Score::readFromFile(ifstream *f) {
 42 | 
 43 | 
 44 |     *f >> timeStamp >> name >> replayNumber >> width >> height >> mines >> time >> val3BV >> flagging >> effectiveClicks >> ineffectiveClicks >> squareSize >> gameWon;
 45 | 
 46 | //    if (loadReplay) 
 47 |   //      cout << val3BV << endl;
 48 | 
 49 | 
 50 | //     cout << name << " "<<time<<endl;
 51 | 
 52 | }
 53 | 
 54 | 
 55 | 
 56 | 
 57 | int compareByTime(const void *a,const void *b) {
 58 | 
 59 |     if ( (*(Score*)a).time <  (*(Score*)b).time ) return -1;
 60 |     if ( (*(Score*)a).time >  (*(Score*)b).time ) return 1;
 61 | 
 62 |     return 0;
 63 | 
 64 | }
 65 | 
 66 | int compareBy3BVs(const void *a,const void *b) {
 67 | 
 68 |     float v1=(*(Score*)a).get3BVs();
 69 |     float v2=(*(Score*)b).get3BVs();
 70 | 
 71 |  /*   v1=1000*(*(Score*)a).val3BV/(*(Score*)a).time;
 72 |     v2=1000*(*(Score*)b).val3BV/(*(Score*)b).time;
 73 | */
 74 |     if ( v1 <  v2 ) return 1;
 75 |     if ( v1 >  v2 ) return -1;
 76 | 
 77 |     return 0;
 78 | 
 79 | }
 80 | 
 81 | 
 82 | int compareByIOE(const void *a,const void *b) {
 83 | 
 84 |     float v1=1000*(*(Score*)a).getIOE();
 85 |     float v2=1000*(*(Score*)b).getIOE();
 86 | 
 87 |     if ( v1 <  v2 ) return 1;
 88 |     if ( v1 >  v2 ) return -1;
 89 | 
 90 |     return 0;
 91 | 
 92 | }
 93 | 
 94 | 
 95 | int filterScores(Score *scores, int count, Score **filteredScores, int fla, int fin, int w, int h, int m, int ss, char *pname) {
 96 | 
 97 |     *filteredScores=new Score[count];    // just allocate array of the same size for the filtered scores
 98 | 
 99 | 
100 |     int counter=0;
101 | 
102 |     for (int i=0;i<count;i++) {        
103 |             
104 | 
105 |         bool isBeg=scores[i].width==9 and scores[i].height==9 and scores[i].mines==10;
106 |         bool isInt=scores[i].width==16 and scores[i].height==16 and scores[i].mines==40;
107 |         bool isExp=scores[i].width==30 and scores[i].height==16 and scores[i].mines==99;
108 |         bool isBegC=scores[i].width==8 and scores[i].height==8 and scores[i].mines==10;
109 |         bool isStandard=isBeg or isInt or isExp or isBegC;
110 | 
111 |         if (    // flagging
112 |             ((fla==0) or (fla==1 and scores[i].flagging) or (fla==2 and !scores[i].flagging))
113 |         
114 |             and
115 |                 // finished
116 |             ((fin==0) or (fin==1 and scores[i].gameWon) or (fin==2 and !scores[i].gameWon))
117 |         
118 |             and 
119 |                     // difficulty
120 |             /*((dif==0 and isStandard) or (dif==1 and isBeg) or (dif==2 and isInt) or (dif==3 and isExp)
121 |                 or (dif==4 and isBegC))*/
122 |             (
123 |                 (scores[i].width==w and scores[i].height==h and scores[i].mines==m)
124 |                 or
125 |                 (w==0 and h==0 and m==0 and isStandard) // XXX BUG - for non-standard sizes scores can't be filtered for nf without specifying w,h,m
126 |             )
127 | 
128 |             and 
129 |                 // square size
130 |             (ss==0 or scores[i].squareSize==ss)
131 | 
132 |             and 
133 |                 // player name
134 |             (pname[0]=='\0' or !strcmp(pname,scores[i].name))
135 | 
136 |             ) {
137 | 
138 |                 (*filteredScores)[counter]=scores[i];
139 |                 counter++;
140 |             
141 |         }
142 |     }
143 | 
144 |     return counter;
145 | 
146 | }
147 | 
148 | 
149 | unsigned int intLength(int n)
150 | {    
151 |    // cout << "length("<<n<<")==";
152 | 
153 |     int length=0;
154 |     while(n!=0) {        
155 |         n=n/10;
156 |         length++;
157 |     }
158 | 
159 |    // cout<<length<<endl;
160 | 
161 |     return length;
162 | }
163 | 
164 | void displayScores(Score *scores, int count,int limit,bool csv /*=false*/) {
165 |     if (count==0) {
166 |         if (!csv) 
167 |             cout << "No scores for this game setup yet." << endl;
168 |         return;
169 |     }
170 | 
171 |     if (!csv) {
172 | 
173 |         int outputCount;
174 | 
175 |     
176 |         if (limit==0)
177 |             outputCount=count;
178 |         else
179 |             if (limit<count)
180 |                 outputCount=limit;
181 |             else
182 |                 outputCount=count;
183 | 
184 | 
185 |         int tw=terminalWidth();
186 | 
187 |         unsigned int maxRankLen=intLength(outputCount);
188 |         unsigned int maxNameLen=4;
189 |         unsigned int maxTimeLen=4;
190 |         unsigned int max3BVLen=3;
191 | 
192 | 
193 |         // find max. lengths
194 | 
195 |         for (int i=0;i<outputCount;i++) {
196 | 
197 |             if (strlen(scores[i].name)>maxNameLen)
198 |                 maxNameLen=strlen(scores[i].name);
199 | 
200 |             int currentTimeLen=intLength(scores[i].time);
201 |             if (currentTimeLen>maxTimeLen) 
202 |                 maxTimeLen=currentTimeLen;
203 | 
204 |             int current3BVLen=intLength(scores[i].val3BV);
205 |             if (current3BVLen>maxTimeLen) 
206 |                 max3BVLen=current3BVLen;
207 | 
208 |         }
209 | 
210 |         maxTimeLen++;   // for decimal point
211 | 
212 | /*
213 |         if (maxNameLen<4) maxNameLen=4;
214 |         if (maxTimeLen<4) maxTimeLen=4;
215 |         if (max3BVLen<3) max3BVLen=3;
216 | 
217 |         */
218 | 
219 |         
220 | 
221 |         ostringstream headerLine;
222 | 
223 |         headerLine << setw(maxRankLen) << right << ""
224 |             <<"  "<<setw(maxNameLen) << left << "Name"
225 |             <<"  "<<setw(maxTimeLen)<<right<< "Time"
226 |             <<"  "<<setw(6)<<right<< "3BV/s"
227 |             <<"  "<<setw(max3BVLen)<<right<< "3BV"
228 |             <<"  "<<setw(6)<<right<< "IOE"
229 |             <<"  "<<setw(3)<<right<< "Fla"
230 |           //  <<"  "<<setw(3)<<right<< "Fin"
231 |             <<"  "<<setw(3)<<right<< "Dif"
232 |             <<"  "<<setw(19)<<left<< "Date"
233 |             <<"  "<<left<< "Rep";
234 | 
235 | 
236 |         // output table header
237 | 
238 |         bool truncated=false;
239 |         if (outputLine(headerLine.str(),tw)) {
240 |             truncated=true;
241 |         }
242 | 
243 |         cout<<endl;
244 | 
245 |     
246 | 
247 | 
248 |         // table rows
249 | 
250 | 
251 |         for (int i=0;i<outputCount;i++) {        
252 |                     
253 |             ostringstream currentLine;
254 | 
255 |             string dateString;
256 |             if (scores[i].timeStamp==0) {
257 |                 dateString=".";
258 |             
259 |             }
260 |             else {
261 |                 struct tm *lt;
262 |                 lt=localtime(&scores[i].timeStamp);
263 |                 ostringstream stringStream;
264 |                 stringStream <<setw(2)<< setfill('0')<<lt->tm_mday
265 |                     <<'-'
266 |                     <<setw(2)<< setfill('0')<<lt->tm_mon+1
267 |                     <<'-'
268 |                     <<setw(4)<< setfill(' ')<<right<< lt->tm_year+1900
269 |                     <<' '         
270 |                     <<setw(2)<< setfill('0')<<lt->tm_hour
271 |                     <<':'
272 |                     <<setw(2)<< setfill('0')<<lt->tm_min
273 |                     <<':'
274 |                     <<setw(2)<< setfill('0')<<lt->tm_sec;
275 | 
276 |                 dateString = stringStream.str();
277 |             }
278 | 
279 |             
280 |             float val3BVs=scores[i].get3BVs();//(float)1000*scores[i].val3BV/scores[i].time;
281 | 
282 |             
283 |             // name and time
284 | 
285 |             currentLine << setw(maxRankLen) << setfill(' ') << right << i+1
286 |                 << "  " << setw(maxNameLen) << left << scores[i].name
287 |                 << "  " << setw(maxTimeLen) << right << setprecision(3) << fixed 
288 |                 << scores[i].time/1000.0;
289 |                  
290 |             currentLine <<fixed;
291 | 
292 | 
293 |             // 3BV/s
294 |             // assume 3BV/s will always be of the format X.XXXX
295 |             if (val3BVs==0)
296 |                 currentLine <<"  "<<setw(5)<< setprecision(4)<<fixed<<right<<".";
297 |             else
298 |                 currentLine <<"  "<<setw(5)<< setprecision(4)<<fixed<<right<<val3BVs;
299 | 
300 |             // 3BV
301 |             if (scores[i].val3BV==0)
302 |                 currentLine <<"  "<<setw(max3BVLen)<<right<< setfill(' ')<< ".";
303 |             else
304 |                 currentLine <<"  "<<setw(max3BVLen)<<right<< setfill(' ')<< scores[i].val3BV;
305 |             
306 |             // IOE
307 |             currentLine <<"  "<<setw(6)<<right<< setfill(' ')<< setprecision(4)<<fixed
308 |                 << scores[i].getIOE();
309 |             
310 |             // flagging
311 |             currentLine <<"  "<<setw(3)<<right<< (scores[i].flagging?"yes":"no");
312 |           
313 |             // difficulty
314 | 
315 |             if (scores[i].width==8 and scores[i].height==8 and scores[i].mines==10)
316 |                 currentLine  <<"  "<< "beC";
317 |             else if (scores[i].width==9 and scores[i].height==9 and scores[i].mines==10)
318 |                 currentLine  <<"  "<< "beg";
319 |             else if (scores[i].width==16 and scores[i].height==16 and scores[i].mines==40)
320 |                 currentLine  <<"  "<< "int";
321 |             else if (scores[i].width==30 and scores[i].height==16 and scores[i].mines==99)
322 |                 currentLine  <<"  "<< "exp";
323 |             else
324 |                 currentLine  <<"  "<< "oth";
325 | 
326 |             // date and time
327 | 
328 |             currentLine  << "  " << setw(19) << left << dateString;
329 | 
330 |             // replay number
331 | 
332 |             if (scores[i].replayNumber!=0)
333 |                 currentLine<< "  " << scores[i].replayNumber;
334 |             else
335 |                 currentLine<< "  " << ".";
336 | 
337 |             if (outputLine(currentLine.str(),tw))
338 |                 truncated=true;
339 | 
340 | 
341 |         }
342 | 
343 | 
344 |         if (truncated)
345 |             cout <<endl<< "Lines truncated. To see the full output resize this terminal."<<endl;
346 | 
347 |     }
348 |     else {
349 |         cout << "dateOfGame,timeOfGame,width,height,mines,difficulty,won,time,3BV/s,IOE,3BV,flagging,name,effectiveClicks,ineffectiveClicks,squareSize,replay"<<endl;
350 | 
351 |         for (int i=0;i<count;i++) {        
352 |                     
353 |             ostringstream currentLine;
354 | 
355 |             string dateString;
356 |             if (scores[i].timeStamp==0) {
357 |                 dateString=".";
358 |             
359 |             }
360 |             else {
361 |                 struct tm *lt;
362 |                 lt=localtime(&scores[i].timeStamp);
363 |                 ostringstream stringStream;
364 |                 stringStream <<setw(4)<< setfill(' ')<<right<< lt->tm_year+1900
365 |                     <<'-'
366 |                     <<setw(2)<< setfill('0')<<lt->tm_mon+1
367 |                     <<'-'
368 |                     <<setw(2)<< setfill('0')<<lt->tm_mday
369 |                     <<','         
370 |                     <<setw(2)<< setfill('0')<<lt->tm_hour
371 |                     <<':'
372 |                     <<setw(2)<< setfill('0')<<lt->tm_min
373 |                     <<':'
374 |                     <<setw(2)<< setfill('0')<<lt->tm_sec;
375 | 
376 |                 dateString = stringStream.str();
377 |             }
378 | 
379 |             
380 |             
381 |             float val3BVs=scores[i].get3BVs();//(float)1000*scores[i].val3BV/scores[i].time;
382 | 
383 |             // date and time of game
384 | 
385 |             cout << dateString << ',';
386 | 
387 | 
388 |             // difficulty (in numbers and string)
389 | 
390 |             cout << scores[i].width << ',' << scores[i].height << ',' << scores[i].mines << ',';
391 | 
392 |             if (scores[i].width==8 and scores[i].height==8 and scores[i].mines==10)
393 |                 cout << "beC";
394 |             else if (scores[i].width==9 and scores[i].height==9 and scores[i].mines==10)
395 |                 cout << "beg";
396 |             else if (scores[i].width==16 and scores[i].height==16 and scores[i].mines==40)
397 |                 cout << "int";
398 |             else if (scores[i].width==30 and scores[i].height==16 and scores[i].mines==99)
399 |                 cout << "exp";
400 |             else
401 |                 cout << "oth";
402 | 
403 |             cout << ',';
404 | 
405 | 
406 | 
407 |             // won game
408 | 
409 |             cout << (scores[i].gameWon?"1":"0") << ',';
410 |  
411 |             // time taken
412 | 
413 |             cout << scores[i].time << ',';
414 | 
415 | 
416 |             // 3BV/s                 
417 |             if (val3BVs==0)
418 |                 cout <<".,";
419 |             else
420 |                 cout<<val3BVs<<',';
421 | 
422 | 
423 |             // IOE
424 |             cout<< scores[i].getIOE()<<',';
425 | 
426 |             // 3BV
427 |             if (scores[i].val3BV==0)
428 |                 cout<< ".,";
429 |             else
430 |                 cout<< scores[i].val3BV<<',';
431 |             
432 |             
433 |             // flagging
434 |             cout<< (scores[i].flagging?"1":"0") << ',';
435 | 
436 | 
437 |             // name, effective, ineffective clicks, square size
438 |             cout << scores[i].name << ',' << scores[i].effectiveClicks << ',' << scores[i].ineffectiveClicks << ',' << scores[i].squareSize << ',';
439 | 
440 |             // replay number
441 | 
442 |             if (scores[i].replayNumber!=0)
443 |                 cout << scores[i].replayNumber;
444 |             else
445 |                 cout << ".";
446 |             
447 |             cout << endl;
448 | 
449 |         }
450 | 
451 | 
452 |     }
453 | 
454 | }
455 | 
456 | 
457 | 
458 | 
459 | int loadScores(char *fname, Score **scores) {
460 | 
461 | 
462 |     *scores=NULL;
463 |     std::ifstream inFile(fname); 
464 | 
465 |     if (!inFile.is_open())
466 |         return 0;
467 | 
468 |     int version;
469 | 
470 |     //inFile.read((char *) &version, 4);
471 | 
472 |     inFile >> version;
473 | 
474 |     Score tmps;
475 |     int count=0;
476 |         
477 |     switch(version) {
478 |     case SCORE_FILE_VERSION:
479 |     {
480 |         string content((istreambuf_iterator<char>(inFile) ), (istreambuf_iterator<char>()    )) ;
481 |         if (string::npos != content.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_.@- \x0d\x0a")) {
482 |             cout << "Score file contains invalid characters. Exiting."<<endl;
483 |             exit(1);
484 |         }
485 |         
486 |         inFile.close();
487 |         inFile.open(fname);
488 |             
489 |         inFile >> version;
490 |         while (!inFile.eof()) {
491 |             tmps.readFromFile(&inFile);
492 |           //  inFile.read((char *) &tmphs, sizeof(Score));
493 |           //  cout << "hs "<<count<< " replay: "<<tmphs.replayFile<<endl;
494 |             count++; 
495 |         }
496 |         count--;
497 |     //    cout << "Counted "<<count<<" scores in score file."<<endl;
498 | 
499 |         if (count==0)
500 |             break;
501 | 
502 | 
503 |         inFile.close();
504 |         inFile.open(fname);
505 | 
506 |         //inFile.read((char *) &version, 4);
507 | 
508 | 
509 |         inFile >> version;
510 | 
511 |         *scores=new Score[count];
512 |         
513 | 
514 |         for (int i=0;i<count;i++) {
515 |             (*scores)[i].readFromFile(&inFile);
516 | 
517 |         }
518 |         
519 |         break;
520 |     }
521 |     default:
522 |         cerr << "Unsupported score file version. Try upgrading to the newest version of the program."<<endl;
523 |         exit(1);
524 |         count=0;
525 |         break;
526 |     }
527 | 
528 |     inFile.close();
529 | 
530 |     
531 |     return count;
532 | 
533 | }
534 | 
535 | 
536 | void appendScore(char *fname, Score score) {
537 | 
538 |  //   cout << "Opening score file... "<<flush;
539 |     
540 |     std::ifstream inFile(fname); 
541 | 
542 |     if (inFile.is_open()) {
543 |    //     cout << "Score file exists."<<endl;
544 |         int version;
545 |         inFile >> version;
546 |         if (version!=SCORE_FILE_VERSION) {
547 |             cerr << "Error saving score: unsupported score file version."<<endl;
548 |             inFile.close();
549 |             return;
550 |         }  
551 |         inFile.close();
552 |         std::ofstream outFile(fname,ios_base::app); 
553 |   //      cout << "Writing..."<<flush;
554 |         score.writeToFile(&outFile);
555 |   //      cout << "done."<<endl;
556 |         outFile.close();
557 |     }
558 |     else {
559 |   //      cout << "Score file doesn't exist."<<endl;
560 |         std::ofstream outFile(fname,ios_base::app); 
561 |         int version=5;
562 |         outFile << version <<endl;
563 |         score.writeToFile(&outFile);
564 |         outFile.close();
565 |     }
566 | 
567 | 
568 |     
569 | }
570 | 
571 | 
572 | 
573 | bool evalScore2v2(ostringstream *scoreString, Score s, Score *scoresAll,int countAll,int (*compareFunc)(const void *,const void *),int scoreListLength) {
574 |    
575 |     // prints the place and percentile of
576 |      
577 |     qsort(scoresAll,countAll,sizeof(Score),compareFunc);
578 | 
579 |     
580 | 
581 |     int position;
582 |     char suffix[3];
583 | 
584 |     for (position=0;position<countAll;position++) {   // "position" is the position of the score currently being evaluated among scoresAll
585 |         if (compareFunc((const void*) &s,(const void*) &scoresAll[position])<0)
586 |             break;
587 |     }
588 | 
589 |     ordinalNumberSuffix(suffix,position+1);
590 | 
591 |     float percentile;
592 |     /*
593 |     if (position==1) {
594 |         percentile=100;
595 |     }
596 |     else {*/
597 | 
598 | 
599 |         percentile=100*(float) (countAll-position+1)/(float)(countAll+1);     // fix this so that percentile is reported correctly
600 | //    }                                                                        // eg 0 when a score ranks as last
601 |                                                                                 
602 |                      
603 |     cout ;
604 |     
605 |     *scoreString << right << fixed << 
606 |         setw(7) << setprecision(0) << (position+1) <<   // position
607 |        /* setw(2) <<*/ suffix <<                            // suffix (-st, -th)
608 |         setw(10) << setprecision(3) << percentile << " ";       // percentile
609 | 
610 |    // *scoreString << ' ';
611 |     
612 |     //    | IOE   |   0.667   |    847th   100.000   |    470th   100.000   | 
613 | }
614 | 
615 | 
616 | int evalScoreMid(ostringstream *scoreString,string criterionName, Score s,Score *scoresFiltered,int countFiltered,Score *scoresFilteredNF,int countFilteredNF,int (*compareFunc)(const void *,const void *),int scoreListLength) {
617 | 
618 |     // compare how this score ranks against older ones based on compareFunc 
619 | 
620 | 
621 | 
622 |     // label on the left (time, 3bv/s, ioe)
623 |     
624 |     *scoreString<<"| "<<left<<setw(5)<<criterionName<<" | ";
625 | 
626 | //    | Time  |   6.317 s |    296th    78.180   |    259th    68.727   | 
627 | 
628 |     
629 |    // *scoreString<<" "<<left<<fixed<<setw(7)<<setprecision(3);
630 |     *scoreString<<setw(7)<<right;
631 |     
632 |     
633 |     // values
634 |     
635 |     // this game
636 |     if (criterionName=="Time") {
637 |         *scoreString<<setw(7)<<right<<s.time/1000.0<<" s";
638 |     }
639 |     else if (criterionName=="3BV/s") {
640 |         *scoreString<<setw(7)<<right<<s.get3BVs()<<"  ";
641 |     }
642 |     else if (criterionName=="IOE") {
643 |         *scoreString<<setw(7)<<right<<s.getIOE()<<"  ";
644 |     }
645 | 
646 |     *scoreString<<" |";
647 |     // f+nf
648 |     evalScore2v2(scoreString,s,scoresFiltered,countFiltered,compareFunc,scoreListLength) ;   
649 |     
650 |     
651 |     
652 |     if (!s.flagging) {
653 |         // nf only
654 |         *scoreString<<"  |";
655 |         evalScore2v2(scoreString,s,scoresFilteredNF,countFilteredNF,compareFunc,scoreListLength);
656 |     }
657 |             
658 |     *scoreString<<"  | "<<endl;
659 | }
660 |     
661 | 
662 | 
663 | void evalScore(Score s, Score *scores, int count, int w, int h, int m, bool oldFinalResultDisplay, int scoreListLength) {
664 | 
665 |     // compare how this score ranks against older ones
666 | 
667 |     //cout<<oldFinalResultDisplay<<endl;
668 |     if (oldFinalResultDisplay) {
669 |   //      cout<<"YOU WIN!"<<endl;
670 |         cout<<"Time:   "<<s.time/1000.0<<" s"<<endl;
671 |         cout<<"3BV/s:  "<<s.get3BVs()<<endl;
672 |         cout<<"IOE:    "<<s.getIOE()/1.0<<endl;
673 |         cout<<"3BV:    "<<s.val3BV/1.0<<endl;
674 | 
675 |         return;
676 |     }
677 |         
678 |         
679 |     cout<<"3BV: "<<s.val3BV/1.0<<endl;
680 | 
681 | 
682 | 
683 |     Score *scoresFiltered;
684 |     Score *scoresFilteredNF;
685 |     
686 |     char zero='\0';
687 | 
688 |     // only won games from the current difficulty
689 |     int countFiltered=filterScores(scores, count,&scoresFiltered,0,1,w,h,m,0,&zero); 
690 |      
691 |     // same but only NF scores
692 |     int countFilteredNF=filterScores(scores, count,&scoresFilteredNF,2,1,w,h,m,0,&zero); 
693 |     
694 | 
695 |     ostringstream scoreString;
696 | 
697 |     char strAll[50], strNF[50];
698 |     
699 |     
700 |     sprintf(strAll,"all games (%d)",countFiltered+1);
701 |     
702 |     
703 |     if (!s.flagging)
704 |         sprintf(strNF,"all NF games (%d)",countFilteredNF+1);
705 |     else
706 |         strNF[0]='\0';
707 |         
708 |         
709 |     cout << endl << "Your result's ranking (among won ";
710 | 
711 | 
712 |     if (w==9 and h==9 and m==10)
713 |         cout << "Beginner";
714 |     else if (w==16 and h==16 and m==40)
715 |         cout << "Intermediate";
716 |     else if (w==30 and h==16 and m==99)
717 |         cout << "Expert";
718 |     else if (w==8 and h==8 and m==10)
719 |         cout << "Beginner classic";
720 |     else
721 |         cout << "'" << w << "x" << h << ", " << m << " mines\'";
722 |             
723 |     cout << " results)"<<endl<<endl;
724 |     
725 |     cout << "Percentiles are approximate, see README for details." << endl << endl ;
726 |     
727 |     scoreString << "        +-----------+----------------------"<<((!s.flagging)?"-----------------------":"")<<"+"<<endl;
728 |     scoreString << "        |           |   compared to        "<<((!s.flagging)?"                       ":"")<<"|"<<endl;
729 |     scoreString << "        |   this    +----------------------"<<((!s.flagging)?"+----------------------":"")<<"+"<<endl;
730 |     scoreString << "        |   game    |"<<setw(19) <<right<<strAll<<"   |"<<setw(20) <<right<<(!s.flagging? strNF : "")<< "  |"<<endl;
731 |     scoreString << "        |           |    place    perc.    |"<<((!s.flagging)?"    place    perc.    |":"")<<endl;
732 |     scoreString << "+-------+-----------+----------------------+"<<((!s.flagging)?"----------------------+":"")<<endl;
733 | 
734 | //                  | Time  |   6.317 s |    296th    78.180   |    259th    68.727   | 
735 | 
736 |     evalScoreMid(&scoreString,"Time",s,scoresFiltered,countFiltered,scoresFilteredNF,countFilteredNF,compareByTime,scoreListLength);
737 |     evalScoreMid(&scoreString,"3BV/s",s,scoresFiltered,countFiltered,scoresFilteredNF,countFilteredNF,compareBy3BVs,scoreListLength);
738 |     evalScoreMid(&scoreString,"IOE",s,scoresFiltered,countFiltered,scoresFilteredNF,countFilteredNF,compareByIOE,scoreListLength);
739 |     
740 |     
741 |     
742 |     
743 |     scoreString << "+-------+-----------+----------------------+"<<((!s.flagging)?"----------------------+":"")<<endl;
744 |     
745 |     
746 |         
747 |     
748 |     cout<<scoreString.str();
749 | 
750 |  
751 |     free(scoresFiltered);
752 | 
753 | }
754 | 
755 | 


--------------------------------------------------------------------------------
/scores.h:
--------------------------------------------------------------------------------
 1 | #ifndef SCORES_H
 2 | #define SCORES_H
 3 | 
 4 | #include <time.h>
 5 | #include <fstream>
 6 | 
 7 | #include <iostream>
 8 | 
 9 | #include <string.h>
10 | 
11 | #include <iomanip>
12 | 
13 | #include <sstream>
14 | 
15 | #include <algorithm>
16 | 
17 | 
18 | using namespace std;
19 | 
20 | 
21 | class Score {
22 | public:
23 | 
24 |     time_t timeStamp;
25 |     char name[21];
26 |     unsigned int replayNumber;
27 | 
28 |     unsigned short width,height;
29 |     unsigned short mines;     
30 |     unsigned int time;
31 |     unsigned short val3BV;
32 |     bool flagging;
33 |     unsigned int effectiveClicks;
34 |     unsigned int ineffectiveClicks;
35 |     unsigned short squareSize;
36 |     bool gameWon;
37 | 
38 |     Score();
39 | 
40 | 
41 |     float getIOE();
42 | 
43 |     float get3BVs();
44 | 
45 |     void readFromFile(ifstream *f);
46 |     
47 |     void writeToFile(ofstream *f);
48 | };
49 | 
50 | // XXX
51 | 
52 | int compareByTime(const void *a,const void *b);
53 | 
54 | int compareBy3BVs(const void *a,const void *b);
55 | 
56 | int compareByIOE(const void *a,const void *b);
57 | 
58 | int filterScores(Score *scores, int count,Score **filteredScores,int fla, int fin, int w, int h, int m, int ss, char *pname);
59 | 
60 | void displayScores(Score *scores, int count,int limit,bool csv=false);
61 | 
62 | int loadScores(char *fname, Score **scores);
63 | 
64 | void appendScore(char *fname, Score score);
65 | 
66 | bool evalScore2(ostringstream *scoreString, Score s, Score *scoresAll,int countAll,char *stringValueName,int (*compareFunc)(const void *,const void *),int scoreListLength,int *returnCountNF);
67 | 
68 | void evalScore(Score s, Score *scores, int count, int w, int h, int m, bool oldView,int scoreListLength);
69 | 
70 | 
71 | 
72 | 
73 | //bool evalScore2(ostringstream *scoreString, Score s, Score *scoresAll,int countAll,char *stringValueName,int (*compareFunc)(const void *,const void *),int scoreListLength,int *returnCountNF   ) ;
74 | 
75 | #endif
76 | 
77 | 


--------------------------------------------------------------------------------
/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/spacecamper/miny/663d8074b28fa670fc61fa5918a972a1639b0ad9/screenshot.png


--------------------------------------------------------------------------------