core.cxx

   1 /*
   2 ** $Id$
   3 **
   4 ** the core routines for the program
   5 ** compile it with C++ but most of it will probably be C
   6 */
   7 /*
   8 **    Copyright (C) 1998-1999 Kurt Van den Branden
   9 **
  10 ** This program is free software; you can redistribute it and/or modify
  11 ** it under the terms of the GNU General Public License as published by
  12 ** the Free Software Foundation; either version 2 of the License, or
  13 ** (at your option) any later version.
  14 **
  15 ** This program is distributed in the hope that it will be useful,
  16 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ** GNU General Public License for more details.
  19 **
  20 ** You should have received a copy of the GNU General Public License
  21 ** along with this program; if not, write to the Free Software
  22 ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 char versiontext[] = "Gipf for one  v 1.03 (28/02/2000)";
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #include <FL/Fl_Menu_Button.H>
  31
  32 #include "fl_board.h"
  33 #include "gipf_ui.H"
  34 #include "callbacks.h"
  35 #include "setup_win.h"
  36 #include "thegame.h"
  37 #include "configfile.h"
  38
  39 //#define GIPF_ICON 1
  40 #ifdef GIPF_ICON
  41 #include <FL/x.H>
  42 #include "i_blauw.xpm"
  43 #endif
  44
  45 #ifdef MSWIN // for the icon
  46 #define GF1_ICON 345
  47 #include <FL/x.H>
  48 #endif
  49
  50 int stop_program = 0; /* set by the callback from the main window */
  51
  52 board * loadboard (void);
  53 void saveboard (board * boardptr);
  54 void savelog (gamelog * logptr);
  55
  56
  57 int main (int argc, char ** argv)
  58 {
  59     int theend = 0,
  60         newval;
  61     Fl_Window * mainwin,
  62         * helpwin;
  63     configvalues gf1_config;
  64     gamestruct * currentgame = NULL,
  65         * newgame = NULL;
  66 #ifdef GIPF_ICON
  67     Pixmap p;
  68 #endif
  69
  70     // new random seed
  71     srand (time (NULL));
  72
  73     /* read configuration */
  74     retrieveconfig (& gf1_config);
  75
  76     /* create the main window */
  77     mainwin = create_mainwindow();
  78
  79 #ifdef GIPF_ICON
  80     /* set the icon */
  81     p = XCreateBitmapFromData(fl_display, DefaultRootWindow(fl_display),
  82                               (char *) i_blauw_xpm, 64, 64);
  83     mainwin->icon((char *)p);
  84 #endif
  85
  86 #ifdef MSWIN
  87     if (fl_display == 0)
  88         fl_display = GetModuleHandle (NULL);
  89
  90     mainwin->icon((char *)LoadIcon(fl_display, MAKEINTRESOURCE(GF1_ICON)));
  91 #endif
  92
  93     /* setup the gameboard */
  94     gameboard->setoutputwidgets(whitepieces, lostwhite, drawwhite,
  95                                 blackpieces, lostblack, drawblack,
  96                                 text_from, text_to);
  97     gameboard->setexecbutton (button_execute);
  98     gameboard->setshowposname (gf1_config.showposname);
  99
 100     /* create helpwindow but don't show it */
 101     helpwin = gf1_help ();
 102
 103     /* set interface-items */
 104     changeinterface (INTERFACE_PLAY, NULL);
 105
 106     /* show the main window */
 107     Fl::visual (FL_DOUBLE|FL_INDEX);
 108     Fl::background (0xb0, 0xb0, 0xb0);
 109     mainwin->show();
 110 //    mainwin->show(argc, argv);   // don't do this, uses default user
 111                                    // colors on windows
 112
 113     /*
 114     ** on windows95 the window doesn't stay on for 5 seconds
 115     ** if I don't add the following line
 116     */
 117     Fl::wait();
 118     /* show the about-window, it will go away after 5 seconds */
 119     show_about (1);
 120
 121     while (!theend)
 122     {
 123         /* The program must be stopped when wait() returns 0 */
 124         if (Fl::wait() == 0)
 125         {
 126             break;
 127         }
 128
 129         Fl_Widget *x;
 130         while ((x = Fl::readqueue()))
 131         {
 132             if (x == gf1_window)
 133             {
 134 //              printf ("mainwin event\n");
 135             }
 136             else if (x == menubar)
 137             {
 138                 const Fl_Menu * z;
 139                 Fl_Menu_Bar * y = (Fl_Menu_Bar *) x;
 140
 141                 z = y->mvalue ();
 142                 if (z == menu_new)
 143                 {
 144                     newgame = show_new (currentgame);
 145                     if (newgame != NULL)
 146                     {
 147                         stoptimer (currentgame);
 148                         delete_game (currentgame);
 149                         currentgame = newgame;
 150                         currentgame->config = & gf1_config;
 151
 152                         gameboard->setboard (currentgame->boards[0]);
 153
 154                         setupmove (currentgame);
 155                     }
 156                 }
 157                 else if (z == menu_loadgame)
 158                 {
 159                     newgame = loadgame ();
 160                     if (newgame != NULL)
 161                     {
 162                         stoptimer (currentgame);
 163                         delete_game (currentgame);
 164                         currentgame = newgame;
 165                         currentgame->config = & gf1_config;
 166
 167                         gameboard->setboard (newgame->boards[0]);
 168
 169                         setupmove (currentgame);
 170                     }
 171                 }
 172                 else if (z == menu_savegame)
 173                 {
 174                     savegame (currentgame);
 175                 }
 176                 else if (z == menu_savelog)
 177                 {
 178                     if (currentgame != NULL)
 179                         savelog (currentgame->movelog);
 180                     else
 181                         savelog (NULL);
 182                 }
 183                 else if (z == menu_setup)
 184                 {
 185                     if (show_setup (&gf1_config))
 186                     {
 187                         writeconfig (&gf1_config);
 188                         gameboard->setshowposname (gf1_config.showposname);
 189                     }
 190                 }
 191                 else if (z == menu_exit)
 192                 {
 193                     theend = 1;
 194                 }
 195                 else if (z == menu_edit)
 196                 {
 197                     board * tempboard;
 198
 199                     stoptimer (currentgame);
 200                     if (currentgame == NULL)
 201                     {
 202                         tempboard = b_new (T_TOURNAMENT);
 203                         gameboard->setboard (tempboard);
 204                         b_del (tempboard);
 205                     }
 206                     else
 207                     {   /* convert board to tournament configuration */
 208                         tempboard = b_copy (gameboard->getboard ());
 209                         if (b_white_gipf (gameboard->getboard ()) == -1)
 210                         {
 211                             tempboard->gipfwhite = 0;
 212                             tempboard->gipfblack = 0;
 213                             tempboard->white += 3;
 214                             tempboard->black += 3;
 215                         }
 216                         tempboard->movecounter = 0;
 217                         gameboard->setboard (tempboard);
 218                         b_del (tempboard);
 219                     }
 220                     changeinterface (INTERFACE_EDIT, currentgame);
 221
 222                     setlostcounters ();
 223                 }
 224                 else if (z == menu_start)
 225                 {
 226                     newgame = show_start (gameboard->getboard ());
 227                     if (newgame != NULL)
 228                     {
 229                         delete_game (currentgame);
 230                         currentgame = newgame;
 231                         currentgame->config = & gf1_config;
 232
 233                         gameboard->setboard (currentgame->boards[0]);
 234
 235                         setupmove (currentgame);
 236                     }
 237                 }
 238                 else if (z == menu_compumove)
 239                 {
 240                     newgame = show_onemove (gameboard->getboard (),
 241                                             & gf1_config);
 242                     if (newgame != NULL)
 243                     {
 244                         delete_game (currentgame);
 245                         currentgame = newgame;
 246                     }
 247                 }
 248                 else if (z == menu_clear)
 249                 {
 250                     board * tempboard;
 251
 252                     tempboard = b_new (T_TOURNAMENT);
 253                     gameboard->setboard (tempboard);
 254                     b_del (tempboard);
 255                     setlostcounters ();
 256                 }
 257                 else if (z == menu_restore)
 258                 {
 259                     changeinterface (INTERFACE_PLAY, currentgame);
 260                     if (currentgame == NULL)
 261                     {
 262                         gameboard->setboard (NULL);
 263                     }
 264                     else
 265                     {
 266                         gameboard->setboard (currentgame->boards[0]);
 267
 268                         setupmove (currentgame);
 269                     }
 270                 }
 271                 else if (z == menu_loadboard)
 272                 {
 273                     board * tempboard = NULL;
 274
 275                     if ((tempboard = loadboard ()) != NULL)
 276                     {
 277                         gameboard->setboard (tempboard);
 278                         b_del (tempboard);
 279
 280                         setlostcounters ();
 281                     }
 282                 }
 283                 else if (z == menu_saveboard)
 284                 {
 285                     saveboard (gameboard->getboard());
 286                 }
 287                 else if (z == menu_makedrawing)
 288                 {
 289                     show_makegif (gameboard->getboard ());
 290                 }
 291                 else if (z == menu_undo)
 292                 {
 293                     if ((currentgame != NULL) &&
 294                         (currentgame->boards[2] != NULL))
 295                     {
 296                         b_del (currentgame->boards[0]);
 297                         b_del (currentgame->boards[1]);
 298                         currentgame->boards[0] = currentgame->boards[2];
 299                         currentgame->boards[1] = NULL;
 300                         currentgame->boards[2] = NULL;
 301                         currentgame->movecounter -=
 302                             remlastmove (currentgame->movelog);
 303                         currentgame->movecounter -=
 304                             remlastmove (currentgame->movelog);
 305
 306                         setupmove (currentgame);
 307                         gameboard->setboard (currentgame->boards[0]);
 308                     }
 309                 }
 310                 else if (z == menu_help)
 311                 {
 312                     helpwin->show();
 313                 }
 314                 else if (z == menu_about)
 315                 {
 316                     show_about (0);
 317                 }
 318             }
 319             else if (x == choice_piecetype)
 320             {
 321                 const Fl_Menu * z;
 322                 Fl_Choice * y = (Fl_Choice *) x;
 323
 324                 z = y->mvalue ();
 325                 if (z == choice_white)
 326                 {
 327                     gameboard->seteditpiece ('o');
 328                 }
 329                 else if (z == choice_whitegipf)
 330                 {
 331                     gameboard->seteditpiece ('O');
 332                 }
 333                 else if (z == choice_black)
 334                 {
 335                     gameboard->seteditpiece ('x');
 336                 }
 337                 else if (z == choice_blackgipf)
 338                 {
 339                     gameboard->seteditpiece ('X');
 340                 }
 341             }
 342             else if (x == menu_piecetype)
 343             {
 344                 const Fl_Menu * z;
 345                 Fl_Menu_Button * y = (Fl_Menu_Button *) x;
 346
 347                 z = y->mvalue ();
 348                 if (z == menu_white)
 349                 {
 350                     choice_piecetype->value (0);
 351                     gameboard->seteditpiece ('o');
 352                 }
 353                 else if (z == menu_whitegipf)
 354                 {
 355                     choice_piecetype->value (1);
 356                     gameboard->seteditpiece ('O');
 357                 }
 358                 else if (z == menu_black)
 359                 {
 360                     choice_piecetype->value (2);
 361                     gameboard->seteditpiece ('x');
 362                 }
 363                 else if (z == menu_blackgipf)
 364                 {
 365                     choice_piecetype->value (3);
 366                     gameboard->seteditpiece ('X');
 367                 }
 368             }
 369             else if (x == count_lostwhite)
 370             {
 371                 newval = gameboard->setlostwhite
 372                     ((int) count_lostwhite->value());
 373                 /* just in case the new value is not valid */
 374                 count_lostwhite->value ((double) newval);
 375             }
 376             else if (x == count_lostblack)
 377             {
 378                 newval = gameboard->setlostblack
 379                     ((int) count_lostblack->value());
 380                 /* just in case the new value is not valid */
 381                 count_lostblack->value ((double) newval);
 382             }
 383             else if (x == button_execute)
 384             {
 385                 if (currentgame != NULL)
 386                 {
 387                     if (humanmove (currentgame) != 0)
 388                         gf1_alert (
 389                             "invalid move, check the from- and to-position !");
 390
 391                     setupmove (currentgame);
 392                 }
 393             }
 394         }
 395
 396         if (stop_program)
 397         {
 398             theend = 1;
 399         }
 400     }
 401
 402     stoptimer (currentgame);
 403     delete_game (currentgame);
 404     delete helpwin;
 405     delete mainwin;
 406     clearconfiglist (gf1_config.configlist);
 407
 408     return (0);
 409 }
 410
 411
 412 /*
 413 ** load a board from a file
 414 **
 415 ** return NULL if nothing loaded
 416 */
 417 board * loadboard (void)
 418 {
 419     const char * filename;
 420     board * newboard;
 421     xmlite_entity * root;
 422     xmlite_parser * theparser;
 423
 424     // ask for filename
 425     if ((filename = file_chooser ("load board", "*.brd", NULL)) == NULL)
 426     {
 427         return (NULL);
 428     }
 429
 430     theparser = new xmlite_parser (filename);
 431     root = theparser->parse();
 432     delete (theparser);
 433     if (root == NULL)
 434     {
 435         gf1_alert (" ERROR: wrong inputfile format");
 436         return (NULL);
 437     }
 438
 439     newboard = b_from_xml (root);
 440     delete (root);
 441
 442     return (newboard);
 443 }
 444
 445
 446 /*
 447 ** save a board to a file
 448 */
 449 void saveboard (board * boardptr)
 450 {
 451     const char * filename;
 452     xmlite_entity * root;
 453
 454     if (boardptr == NULL)
 455     {
 456         gf1_alert (" no current board to be saved");
 457         return;
 458     }
 459
 460     // ask for filename
 461     if ((filename = file_chooser ("save board", "*.brd", "./board.brd"))
 462         == NULL)
 463     {
 464         return;
 465     }
 466
 467     root = b_to_xml (boardptr);
 468     root->writetofile (filename);
 469     delete (root);
 470
 471     return;
 472 }
 473
 474
 475 /*
 476 ** save a gamelog to a file
 477 */
 478 void savelog (gamelog * logptr)
 479 {
 480     const char * filename;
 481     FILE * fp;
 482
 483     if (logptr == NULL)
 484     {
 485         gf1_alert (" no gamelog to be saved");
 486         return;
 487     }
 488
 489     // ask for filename
 490     if ((filename = file_chooser ("save board", "*.log", "./gamelog.log"))
 491         == NULL)
 492     {
 493         return;
 494     }
 495
 496     if ((fp = fopen (filename, "w")) == NULL)
 497     {
 498         gf1_alert (" ERROR: Can't create the file");
 499         return;
 500     }
 501
 502     logtofile (logptr, fp);
 503
 504     fclose (fp);
 505
 506     return;
 507 }
 508
 509 extern "C" void checkwindowevents (void);
 510
 511 void checkwindowevents (void)
 512 {
 513     Fl::check ();
 514
 515     return;
 516 }
 517