src/game.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@gmail.com>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #include <iostream>
  12 #include <map>
  13 #ifdef Q_CC_MSVC
  14   #pragma warning( push )
  15   #pragma warning( disable : 4100 )
  16   #include <boost/variant.hpp>
  17   #pragma warning( pop )
  18 #else
  19   #include <boost/variant.hpp>
  20 #endif
  21 #ifndef NO_PGN
  22 #include "variants.h"
  23 #include "pgnparser.h"
  24 #include "tagua.h"
  25 #endif //NO_PGN
  26 #include "game.h"
  27 #include "game_p.h"
  28
  29
  30 using namespace GamePrivate;
  31
  32
  33 Game::Game()
  34 : current(-1)
  35 , undo_pos(0) {
  36 }
  37
  38 Game::~Game() {
  39 }
  40
  41 void Game::onAdded(const Index&) {
  42 }
  43
  44 void Game::onRemoved(const Index&) {
  45 }
  46
  47 void Game::onEntryChanged(const Index&, int) {
  48 }
  49
  50 void Game::onPromoteVariation(const Index&, int) {
  51 }
  52
  53 void Game::onSetComment(const Index&, const QString&) {
  54 }
  55
  56 void Game::onSetVComment(const Index&, int, const QString&) {
  57 }
  58
  59 void Game::onCurrentIndexChanged(const Index&) {
  60 }
  61
  62 void Game::onAvailableUndo(bool) {
  63 }
  64
  65 void Game::onAvailableRedo(bool) {
  66 }
  67
  68 Entry* Game::fetch(const Index& ix) {
  69   int at;
  70   History *vec = fetchRef(ix, &at);
  71   return vec ? &(*vec)[at] : NULL;
  72 }
  73
  74 const Entry* Game::fetch(const Index& ix) const {
  75   int at;
  76   const History *vec = fetchRef(ix, &at);
  77   return vec ? &(*vec)[at] : NULL;
  78 }
  79
  80 History* Game::fetchRef(const Index& ix, int* idx) {
  81   if(ix.num_moves >= (int)history.size() || ix.num_moves < 0 )
  82     return NULL;
  83
  84   History* aretv = &history;
  85   Entry* retv = &history[ix.num_moves];
  86   if(idx) *idx = ix.num_moves;
  87
  88   for(int i=0; i<(int)ix.nested.size();i++) {
  89     Variations::iterator it = retv->variations.find(ix.nested[i].variation);
  90     if(it == retv->variations.end() || ix.nested[i].num_moves >= (int)it->second.size()
  91                                 || ix.nested[i].num_moves < 0 )
  92       return NULL;
  93
  94     aretv = &it->second;
  95     retv = &it->second[ix.nested[i].num_moves];
  96     if(idx) *idx = ix.nested[i].num_moves;
  97   }
  98   return aretv;
  99 }
 100
 101 const History* Game::fetchRef(const Index& ix, int* idx) const {
 102   return const_cast<const History*>(const_cast<Game*>(this)->fetchRef(ix, idx));
 103 }
 104
 105 void Game::testMove(const Index& ix) {
 106   if (ix != Index(0)) {
 107     Entry *e1 = fetch(ix.prev());
 108     Entry *e2 = fetch(ix);
 109     if(!e1 || !e2 || !e1->position || !e2->move)
 110       return;
 111
 112     if (!e1->position->testMove(e2->move))
 113       ERROR("invalid move added to game history!");
 114   }
 115 }
 116
 117 void Game::testMove() {
 118   testMove(current);
 119 }
 120
 121 void Game::saveUndo(const UndoOp& op) {
 122   bool redo = undo_pos < (int)undo_history.size();
 123
 124   while(undo_pos < (int)undo_history.size())
 125     undo_history.pop_back();
 126   undo_history.push_back(op);
 127   undo_pos++;
 128
 129   if(undo_pos == 1)
 130     onAvailableUndo(true);
 131   if(redo)
 132     onAvailableRedo(false);
 133 }
 134
 135
 136 Index Game::index() const {
 137   return current;
 138 }
 139
 140 Index Game::lastMainlineIndex() const {
 141   return Index(history.size()-1);
 142 }
 143
 144 bool Game::containsIndex(const Index& index) const {
 145   return !!fetch(index);
 146 }
 147
 148 MovePtr Game::move() const {
 149   return move(current);
 150 }
 151
 152 MovePtr Game::move(const Index& index) const {
 153   Entry *e = (Entry*)fetch(index);
 154   if(!e) {
 155     ERROR("Index out of range!");
 156     return MovePtr();
 157   }
 158   return e->move;
 159 }
 160
 161 PositionPtr Game::position() const {
 162   return position(current);
 163 }
 164
 165 PositionPtr Game::position(const Index& index) const {
 166   Entry *e = (Entry*)fetch(index);
 167   if(!e) {
 168     ERROR("Index " << index << " out of range!");
 169     return PositionPtr();
 170   }
 171   return e->position;
 172 }
 173
 174 QString Game::comment() const {
 175   return comment(current);
 176 }
 177
 178 QString Game::comment(const Index& index) const {
 179   const Entry *e = fetch(index);
 180   if(!e) {
 181     ERROR("Index out of range!");
 182     return QString();
 183   }
 184   return e->comment;
 185 }
 186
 187 void Game::reset(PositionPtr pos) {
 188   Q_ASSERT(pos);
 189
 190   undo_pos = 0;
 191   undo_history.clear();
 192   history.clear();
 193   history.push_back( Entry(MovePtr(), pos) );
 194   current = Index(0);
 195   onCurrentIndexChanged();
 196 }
 197
 198 void Game::undo() {
 199   if(undo_pos <= 0) {
 200     ERROR("Cannot undo at the beginning of the undo history!");
 201     return;
 202   }
 203
 204   bool last_undo = undo_pos == 1;
 205   bool now_redo = undo_pos == (int)undo_history.size();
 206
 207   undo_pos--;
 208   UndoOp* op = &(undo_history[undo_pos]);
 209
 210   if(boost::get<UndoAdd>(op)) {
 211     UndoAdd *a = boost::get<UndoAdd>(op);
 212
 213     if(a->index.atVariationStart() ) {
 214       Entry* e = fetch(a->index.prev());
 215       Q_ASSERT(e);
 216
 217       int v = a->index.nested[a->index.nested.size()-1].variation;
 218       Q_ASSERT(e->variations.count(v) == 1);
 219       Q_ASSERT(e->variations[v].size() == 1);
 220
 221       e->variations.erase(v);
 222     }
 223     else {
 224       int at;
 225       std::vector<Entry>* vec = fetchRef(a->index, &at);
 226       Q_ASSERT(vec);
 227       Q_ASSERT((int)vec->size() == at+1);
 228
 229       vec->pop_back();
 230     }
 231
 232     if(current == a->index) {
 233       current = current.prev();
 234       onCurrentIndexChanged();
 235     }
 236
 237     onRemoved(a->index);
 238   }
 239   else if(boost::get<UndoPromote>(op)) {
 240     UndoPromote *p = boost::get<UndoPromote>(op);
 241
 242     int at;
 243     std::vector<Entry>* vec = fetchRef(p->index, &at);
 244     Q_ASSERT(vec);
 245     Q_ASSERT((*vec)[at].variations.count(p->variation)==1);
 246
 247     History vold = (*vec)[at].variations[p->variation];
 248     History vnew;
 249     for(int i=at+1; i<(int)vec->size(); i++)
 250       vnew.push_back((*vec)[i]);
 251     while((int)vec->size()>at+1)
 252       vec->pop_back();
 253     for(int i=0; i<(int)vold.size(); i++)
 254       vec->push_back(vold[i]);
 255     (*vec)[at].variations[p->variation] = vnew;
 256
 257     current = current.flipVariation(p->index, p->variation);
 258     onPromoteVariation(p->index, p->variation);
 259     //onCurrentIndexChanged();
 260   }
 261   else if(boost::get<UndoTruncate>(op)) {
 262     UndoTruncate *t = boost::get<UndoTruncate>(op);
 263
 264     int at;
 265     std::vector<Entry>* vec = fetchRef(t->index, &at);
 266     Q_ASSERT(vec);
 267     Q_ASSERT((int)vec->size() == at+1);
 268     Q_ASSERT((*vec)[at].variations.empty());
 269
 270     for(int i=0;i<(int)t->history.size();i++)
 271       vec->push_back(t->history[i]);
 272     (*vec)[at].variations = t->variations;
 273     (*vec)[at].vcomments = t->vcomments;
 274
 275     if(t->history.size())
 276       onAdded(t->index.next());
 277     for(Variations::iterator it = t->variations.begin(); it != t->variations.end(); ++it)
 278       onAdded(t->index.next(it->first));
 279     for(VComments::iterator it = t->vcomments.begin(); it != t->vcomments.end(); ++it)
 280       onSetVComment(t->index, it->first, it->second);
 281   }
 282   else if(boost::get<UndoRemove>(op)) {
 283     UndoRemove *r = boost::get<UndoRemove>(op);
 284
 285     Entry *e = fetch(r->index);
 286     e->variations[r->variation] = r->history;
 287     onAdded(r->index.next(r->variation));
 288     if(!r->vcomment.isEmpty()) {
 289       e->vcomments[r->variation] = r->vcomment;
 290       onSetVComment(r->index, r->variation, r->vcomment);
 291     }
 292   }
 293   else if(boost::get<UndoClear>(op)) {
 294     UndoClear *c = boost::get<UndoClear>(op);
 295
 296     Entry *e = fetch(c->index);
 297     e->variations = c->variations;
 298     e->vcomments = c->vcomments;
 299     for(Variations::iterator it = c->variations.begin(); it != c->variations.end(); ++it)
 300       onAdded(c->index.next(it->first));
 301     for(VComments::iterator it = c->vcomments.begin(); it != c->vcomments.end(); ++it)
 302       onSetVComment(c->index, it->first, it->second);
 303   }
 304   else if(boost::get<UndoSetComment>(op)) {
 305     UndoSetComment *sc = boost::get<UndoSetComment>(op);
 306     Entry *e = fetch(sc->index);
 307     Q_ASSERT(e);
 308
 309     if(sc->variation == -1) {
 310       e->comment = sc->old_comment;
 311       onSetComment(sc->index, sc->old_comment);
 312     }
 313     else {
 314       if(sc->old_comment.isEmpty())
 315         e->vcomments.erase(sc->variation);
 316       else
 317         e->vcomments[sc->variation] = sc->old_comment;
 318       onSetVComment(sc->index, sc->variation, sc->old_comment);
 319     }
 320   }
 321
 322   if(last_undo)
 323     onAvailableUndo(false);
 324   if(now_redo)
 325     onAvailableRedo(true);
 326 }
 327
 328 void Game::redo() {
 329   if(undo_pos >= (int)undo_history.size()) {
 330     ERROR("Cannot redo at the end of the undo history!");
 331     return;
 332   }
 333
 334   bool now_undo = undo_pos == 0;
 335   bool last_redo = undo_pos == (int)undo_history.size()-1;
 336
 337   UndoOp* op = &(undo_history[undo_pos]);
 338   undo_pos++;
 339
 340   if(boost::get<UndoAdd>(op)) {
 341     UndoAdd *a = boost::get<UndoAdd>(op);
 342
 343     if(a->index.atVariationStart() ) {
 344       Entry* e = fetch(a->index.prev());
 345       Q_ASSERT(e);
 346
 347       int v = a->index.nested[a->index.nested.size()-1].variation;
 348       Q_ASSERT(e->variations.count(v) == 0);
 349
 350       History h;
 351       h.push_back(a->entry);
 352       e->variations[v] = h;
 353     }
 354     else {
 355       int at;
 356       std::vector<Entry>* vec = fetchRef(a->index.prev(), &at);
 357       Q_ASSERT(vec);
 358       Q_ASSERT((int)vec->size() == at+1);
 359
 360       vec->push_back(a->entry);
 361     }
 362
 363     onAdded(a->index);
 364   }
 365   else if(boost::get<UndoPromote>(op)) {
 366     UndoPromote *p = boost::get<UndoPromote>(op);
 367
 368     int at;
 369     std::vector<Entry>* vec = fetchRef(p->index, &at);
 370
 371     Q_ASSERT(vec);
 372     Q_ASSERT((*vec)[at].variations.count(p->variation)==1);
 373     History vold = (*vec)[at].variations[p->variation];
 374     History vnew;
 375     for(int i=at+1; i<(int)vec->size(); i++)
 376       vnew.push_back((*vec)[i]);
 377     while((int)vec->size()>at+1)
 378       vec->pop_back();
 379     for(int i=0; i<(int)vold.size(); i++)
 380       vec->push_back(vold[i]);
 381     (*vec)[at].variations[p->variation] = vnew;
 382
 383     current = current.flipVariation(p->index, p->variation);
 384     onPromoteVariation(p->index, p->variation);
 385     //onCurrentIndexChanged();
 386   }
 387   else if(boost::get<UndoTruncate>(op)) {
 388     UndoTruncate *t = boost::get<UndoTruncate>(op);
 389
 390     int at;
 391     std::vector<Entry>* vec = fetchRef(t->index, &at);
 392     Q_ASSERT(vec);
 393     Q_ASSERT((int)vec->size() == at+1+(int)t->history.size());
 394
 395     while((int)vec->size() > at+1)
 396       vec->pop_back();
 397     (*vec)[at].variations.clear();
 398     (*vec)[at].vcomments.clear();
 399
 400     if(current > t->index) {
 401       current = t->index;
 402       onCurrentIndexChanged();
 403     }
 404
 405     if(t->history.size())
 406       onRemoved(t->index.next());
 407     for(Variations::iterator it = t->variations.begin(); it != t->variations.end(); ++it)
 408       onRemoved(t->index.next(it->first));
 409   }
 410   else if(boost::get<UndoRemove>(op)) {
 411     UndoRemove *r = boost::get<UndoRemove>(op);
 412
 413     Entry *e = fetch(r->index);
 414     e->variations.erase(r->variation);
 415     e->vcomments.erase(r->variation);
 416     onRemoved(r->index.next(r->variation));
 417   }
 418   else if(boost::get<UndoClear>(op)) {
 419     UndoClear *c = boost::get<UndoClear>(op);
 420
 421     Entry *e = fetch(c->index);
 422     e->variations.clear();
 423     e->vcomments.clear();
 424     for(Variations::iterator it = c->variations.begin(); it != c->variations.end(); ++it)
 425       onRemoved(c->index.next(it->first));
 426   }
 427   else if(boost::get<UndoSetComment>(op)) {
 428     UndoSetComment *sc = boost::get<UndoSetComment>(op);
 429     Entry *e = fetch(sc->index);
 430     Q_ASSERT(e);
 431
 432     if(sc->variation == -1) {
 433       e->comment = sc->new_comment;
 434       onSetComment(sc->index, sc->new_comment);
 435     }
 436     else {
 437       if(sc->new_comment.isEmpty())
 438         e->vcomments.erase(sc->variation);
 439       else
 440         e->vcomments[sc->variation] = sc->new_comment;
 441       onSetVComment(sc->index, sc->variation, sc->new_comment);
 442     }
 443   }
 444
 445   if(now_undo)
 446     onAvailableUndo(true);
 447   if(last_redo)
 448     onAvailableRedo(false);
 449 }
 450
 451 void Game::setComment(const QString& c) {
 452   setComment(current, c);
 453 }
 454
 455 void Game::setComment(const Index& ix, const QString& c) {
 456   Entry* e = fetch(ix);
 457   if(!e) {
 458     ERROR("Invalid index!");
 459     return;
 460   }
 461   if(e->comment == c)
 462     return;
 463
 464   saveUndo(UndoSetComment(ix, -1, e->comment, c));
 465   e->comment = c;
 466   onSetComment(ix, c);
 467 }
 468
 469 void Game::setVComment(const Index& ix, int v, const QString& c) {
 470   Entry* e = fetch(ix);
 471   if(!e) {
 472     ERROR("Invalid index!");
 473     return;
 474   }
 475   QString oc = e->vcomments.count(v) ? e->vcomments[v] : QString();
 476   if(oc == c)
 477     return;
 478
 479   saveUndo(UndoSetComment(ix, v, oc, c));
 480   if(c.isEmpty())
 481     e->vcomments.erase(v);
 482   else
 483     e->vcomments[v] = c;
 484   onSetVComment(ix, v, c);
 485 }
 486
 487 void Game::promoteVariation() {
 488   promoteVariation(current);
 489 }
 490
 491 void Game::promoteVariation(const Index& _ix) {
 492   if(_ix.nested.size()==0) {
 493     ERROR("Cannot promote main line!");
 494     return;
 495   }
 496   Index ix = _ix;
 497   int v = ix.nested[ix.nested.size()-1].variation;
 498   ix.nested.pop_back();
 499
 500   promoteVariation(ix, v);
 501 }
 502
 503 void Game::promoteVariation(const Index& ix, int v) {
 504   int at;
 505   std::vector<Entry>* vec = fetchRef(ix, &at);
 506   Q_ASSERT(vec);
 507   Q_ASSERT((*vec)[at].variations.count(v)==1);
 508
 509   History vold = (*vec)[at].variations[v];
 510   History vnew;
 511   for(int i=at+1; i<(int)vec->size(); i++)
 512     vnew.push_back((*vec)[i]);
 513   while((int)vec->size()>at+1)
 514     vec->pop_back();
 515   for(int i=0; i<(int)vold.size(); i++)
 516     vec->push_back(vold[i]);
 517   (*vec)[at].variations[v] = vnew;
 518
 519   saveUndo(UndoPromote(ix, v));
 520   current = current.flipVariation(ix, v);
 521   onPromoteVariation(ix, v);
 522   //don't call onCurrentIndexChanged(), as the position did not change actually
 523 }
 524
 525 void Game::removeVariation(int v) {
 526   removeVariation(current, v);
 527 }
 528
 529 void Game::removeVariation(const Index& _ix) {
 530   if(_ix.nested.size()==0) {
 531     ERROR("Cannot remove main line!");
 532     return;
 533   }
 534   Index ix = _ix;
 535   int v = ix.nested[ix.nested.size()-1].variation;
 536   ix.nested.pop_back();
 537
 538   removeVariation(ix, v);
 539 }
 540
 541 void Game::removeVariation(const Index& ix, int v) {
 542   Entry* e = fetch(ix);
 543
 544   saveUndo(UndoRemove(ix, v, e->variations[v],
 545                 e->vcomments.count(v) ? e->vcomments[v] : QString() ));
 546   e->variations.erase(v);
 547   e->vcomments.erase(v);
 548
 549   onRemoved(ix.next(v));
 550   if(current >= ix.next(v)) {
 551     current = ix;
 552     onCurrentIndexChanged();
 553   }
 554 }
 555
 556 void Game::clearVariations() {
 557   clearVariations(current);
 558 }
 559
 560 void Game::clearVariations(const Index& ix) {
 561   Entry* e = fetch(ix);
 562
 563   UndoClear uc(ix, e->variations, e->vcomments);
 564   saveUndo(uc);
 565   e->variations.clear();
 566   e->vcomments.clear();
 567
 568   for(Variations::iterator it = uc.variations.begin(); it != uc.variations.end(); ++it)
 569     onRemoved(ix.next(it->first));
 570   if(current > ix && !(current >= ix.next())) {
 571     current = ix;
 572     onCurrentIndexChanged();
 573   }
 574 }
 575
 576 void Game::truncate() {
 577   truncate(current);
 578 }
 579
 580 void Game::truncate(const Index& ix) {
 581   int at;
 582   History* vec = fetchRef(ix, &at);
 583   if(!vec) {
 584     ERROR("Truncating at an unexisting index!");
 585     return;
 586   }
 587
 588   Entry *e = &(*vec)[at];
 589   UndoTruncate undo(ix);
 590   for(int i=at+1; i<(int)vec->size();i++)
 591     undo.history.push_back((*vec)[i]);
 592   while((int)vec->size()>at+1)
 593     vec->pop_back();
 594
 595   undo.variations = e->variations;
 596   undo.vcomments = e->vcomments;
 597   saveUndo(undo);
 598   e->variations.clear();
 599   e->vcomments.clear();
 600
 601   if(undo.history.size())
 602     onRemoved(undo.index.next());
 603   for(Variations::iterator it = undo.variations.begin(); it != undo.variations.end(); ++it)
 604     onRemoved(undo.index.next(it->first));
 605
 606   if(current > ix) {
 607     current = ix;
 608     onCurrentIndexChanged();
 609   }
 610 }
 611
 612 void Game::add(MovePtr m, PositionPtr pos) {
 613   Q_ASSERT(pos);
 614
 615   Index old_c = current;
 616   int at;
 617   std::vector<Entry>* vec = fetchRef(current, &at);
 618   Q_ASSERT(vec);
 619
 620   /* add the move on the mainline */
 621   if((int)vec->size() <= at+1 ) {
 622     Q_ASSERT((int)vec->size() == at+1);
 623     vec->push_back(Entry(m, pos));
 624     current = current.next();
 625     testMove();
 626     saveUndo(UndoAdd(current, Entry(m, pos)));
 627     onAdded(current);
 628     onCurrentIndexChanged(old_c);
 629   }
 630   /* we are playing the move that is already next in the mainline */
 631   else if( (*vec)[at+1].position && (*vec)[at+1].position->equals(pos)) {
 632     current = current.next();
 633     onCurrentIndexChanged(old_c);
 634     /* no need to test the move */
 635   }
 636   else {
 637     Entry *e = fetch(current);
 638     Q_ASSERT(e);
 639
 640     /* check if a variations with this move already exists. */
 641     for(Variations::iterator it = e->variations.begin(); it != e->variations.end(); ++it)
 642     if(it->second.size() > 0 && it->second[0].position
 643         && it->second[0].position->equals(pos) ) {
 644       current = current.next(it->first);
 645       onCurrentIndexChanged(old_c);
 646
 647       return;
 648     }
 649
 650     int var_id = e->last_var_id++;
 651     e->variations[var_id].push_back(Entry(m, pos));
 652     current = current.next(var_id);
 653     testMove();
 654     saveUndo(UndoAdd(current, Entry(m, pos)));
 655     onAdded(current);
 656     onCurrentIndexChanged(old_c);
 657   }
 658 }
 659
 660 bool Game::insert(MovePtr m, PositionPtr pos, const Index& at) {
 661   Entry *e = fetch(at);
 662
 663   if(!e) {
 664     if(at.nested.size() == 0) {
 665       if(undo_history.size()) {
 666         undo_pos = 0;
 667         undo_history.clear();
 668       }
 669       int hs = history.size();
 670       history.resize(at.num_moves + 1);
 671       history[at.num_moves] = Entry(m, pos);
 672       testMove(at);
 673       onAdded(Index(hs));
 674       return true;
 675     }
 676     else {
 677       ERROR("Index out if range!");
 678       return false;
 679     }
 680   }
 681
 682   if(undo_history.size()) {
 683     undo_pos = 0;
 684     undo_history.clear();
 685   }
 686   bool res = e->position && e->position->equals(pos);
 687   e->move = m;
 688   e->position = pos;
 689   testMove(at);
 690   testMove(at.next());
 691   for (Variations::const_iterator it = e->variations.begin();
 692           it != e->variations.end(); ++it)
 693     testMove(at.next(it->first));
 694   onEntryChanged(at);
 695   return res;
 696 }
 697
 698 bool Game::lastPosition() const {
 699   return !fetch(current.next());
 700 }
 701
 702 bool Game::back() {
 703   if (current <= 0) return false; // first entry or uninitialized
 704   Index old_c = current;
 705   Index new_c = current.prev();
 706
 707   Entry *e = fetch(new_c);
 708   if(!e || e->position == 0) return false; // gap immediately before current
 709   current = new_c;
 710   onCurrentIndexChanged(old_c);
 711
 712   return true;
 713 }
 714
 715 bool Game::forward() {
 716   Index old_c = current;
 717   Index new_c = current.next();
 718
 719   Entry *e = fetch(new_c);
 720   if(!e || e->position == 0) {
 721      return false; // gap immediately before current
 722   }
 723   current = new_c;
 724   onCurrentIndexChanged(old_c);
 725
 726   return true;
 727 }
 728
 729 void Game::gotoFirst() {
 730   Index old_c = current;
 731   current = Index(0);
 732   onCurrentIndexChanged(old_c);
 733 }
 734
 735 void Game::gotoLast() {
 736   int at;
 737   std::vector<Entry>* vec = fetchRef(current, &at);
 738   Q_ASSERT(vec);
 739   Q_ASSERT((int)vec->size() > at);
 740
 741   if((int)vec->size() > at+1) {
 742     Index old_c = current;
 743     current = current.next(-1, vec->size()-1-at);
 744     onCurrentIndexChanged(old_c);
 745   }
 746 }
 747
 748 bool Game::goTo(const Index& index) {
 749   if (fetch(index)) {
 750     Index old_c = current;
 751     current = index;
 752     onCurrentIndexChanged(old_c);
 753     return true;
 754   }
 755   return false;
 756 }
 757
 758 QString Game::variationPgn(const History& vec, const Entry& e,
 759                         int start, const Index& _ix) const {
 760   Index ix = _ix;
 761   QString res;
 762
 763   for (int i = start; i < static_cast<int>(vec.size()); i++) {
 764     const Entry& preve = (i > start) ? vec[i-1] : e;
 765
 766     QString mv = (vec[i].move && preve.position) ?
 767               vec[i].move->toString("compact", preve.position ) : "???";
 768 #if 0
 769     if (ix == current)
 770       mv = "[[" + mv + "]]";
 771 #endif
 772
 773     int n = ix.totalNumMoves()+1;
 774     if(i==start || n%2==0)
 775       mv = QString::number(n/2)+(n%2==1 ? ". ... " : ". ") + mv;
 776     if (i > start)
 777       mv = " " + mv;
 778
 779     res += mv;
 780
 781     if(!vec[i].comment.isEmpty())
 782       res += " {" + vec[i].comment + "}";
 783
 784     if(i > 0) {
 785       for(Variations::const_iterator it = vec[i-1].variations.begin();
 786              it != vec[i-1].variations.end(); ++it) {
 787         res += " (";
 788         if(vec[i-1].vcomments.count(it->first))
 789           res += "{" + vec[i-1].vcomments.find(it->first)->second + "} ";
 790         res += variationPgn(it->second, vec[i - 1], 0,
 791                     ix.prev().next(it->first)) + ")";
 792       }
 793     }
 794
 795     ix = ix.next();
 796   }
 797   return res;
 798 }
 799
 800 QString Game::pgn() const {
 801   return variationPgn(history, history[0], 1, Index(1));
 802 }
 803
 804 #ifndef NO_PGN
 805 void Game::load(const PGN& pgn) {
 806   std::map<QString, QString>::const_iterator var = pgn.m_tags.find("Variant");
 807   VariantPtr vi;
 808
 809   if (var == pgn.m_tags.end()) {
 810     vi = Variants::instance().get("chess");
 811   }
 812   else if (!(vi = Variants::instance().get(var->second))) {
 813     ERROR("No such variant " << var->second);
 814     return;
 815   }
 816
 817   std::map<QString, QString>::const_iterator fen = pgn.m_tags.find("FEN");
 818   PositionPtr pos;
 819
 820   if(var == pgn.m_tags.end()) {
 821     pos = vi->createPosition();
 822     pos->setup();
 823   }
 824 #if 0 // BROKEN
 825   else if( !(pos = vi->createPositionFromFEN(fen->second))) {
 826     ERROR("Wrong fen " << fen->second);
 827     return;
 828   }
 829 #endif
 830
 831   //TODO: what about options? FEN rules?
 832
 833   load(pos, pgn);
 834 }
 835
 836 void Game::load(PositionPtr pos, const PGN& pgn) {
 837   current = Index(0);
 838   undo_history.clear();
 839   undo_pos = 0;
 840
 841   if(history.size()) {
 842     Entry* fe = &history[0];
 843     int old_history_size = history.size();
 844     std::vector<int> v_ids;
 845
 846     while(history.size()>1)
 847       history.pop_back();
 848     for(Variations::const_iterator it = fe->variations.begin();
 849             it != fe->variations.end(); ++it)
 850       v_ids.push_back(it->first);
 851     fe->variations.clear();
 852     fe->vcomments.clear();
 853
 854     for(int i=0;i<(int)v_ids.size();i++)
 855       onRemoved(Index(0).next(v_ids[i]));
 856     if(old_history_size>1)
 857       onRemoved(Index(1));
 858     v_ids.clear();
 859     history[0].position = pos;
 860   }
 861   else
 862     history.push_back( Entry(MovePtr(), pos) );
 863
 864   QString vcomment;
 865   std::vector<Index> var_stack;
 866   bool var_start = false;
 867
 868   for (uint i = 0; i < pgn.m_entries.size(); i++) {
 869     if(boost::get<QString>(pgn[i])) {
 870       if(var_start)
 871         vcomment += *boost::get<QString>(pgn[i]);
 872       else {
 873         Entry *e = fetch(current);
 874         Q_ASSERT(e);
 875
 876         e->comment += *boost::get<QString>(pgn[i]);
 877       }
 878     }
 879     else if(boost::get<PGN::BeginVariation>(pgn[i])) {
 880       var_stack.push_back(current);
 881       var_start = true;
 882     }
 883     else if(boost::get<PGN::EndVariation>(pgn[i])) {
 884       if(var_stack.size() == 0) {
 885         ERROR("Unexpected end variation!");
 886         break;
 887       }
 888       current = var_stack[var_stack.size()-1];
 889       var_stack.pop_back();
 890     }
 891     else if(boost::get<PGN::Move>(pgn[i])) {
 892       const PGN::Move *pm = boost::get<PGN::Move>(pgn[i]);
 893
 894       int n = current.totalNumMoves()+1;
 895       if(var_start) {
 896         if(!pm->m_number)
 897           current = current.prev();
 898         else if(pm->m_number>n+1)
 899           ERROR("Too far variation!");
 900         else {
 901           if(pm->m_number<n)
 902             ERROR("Too near variation!");
 903           current = current.prev(n + 1 - pm->m_number);
 904         }
 905       }
 906       else if(pm->m_number && pm->m_number!=n+1)
 907         ERROR("Move number mismatch!");
 908
 909       PositionPtr pos = position();
 910       MovePtr m = pos->getMove(pm->m_move);
 911
 912       if(!m || !pos->testMove(m))
 913         break;
 914
 915       PositionPtr newPos = pos->clone();
 916       newPos->move(m);
 917
 918       int at;
 919       History *vec = fetchRef(current, &at);
 920       Q_ASSERT(vec);
 921
 922       if(var_start) {
 923         Entry *e = &(*vec)[at];
 924         int var_id = e->last_var_id++;
 925         e->variations[var_id].push_back(Entry(m, newPos));
 926         if(!vcomment.isEmpty()) {
 927           e->vcomments[var_id] = vcomment;
 928           vcomment = QString();
 929         }
 930         /* this is a hack, but the mainline should NEVER
 931             be empty if there is a variation*/
 932         if((int)vec->size() - 1 == at)
 933           vec->push_back(Entry(m, newPos));
 934
 935         current = current.next(var_id);
 936       }
 937       else {
 938         if((int)vec->size() - 1 == at)
 939           vec->push_back(Entry(m, newPos));
 940         else
 941           (*vec)[at] = Entry(m, newPos);
 942
 943         current = current.next();
 944       }
 945
 946       var_start = false;
 947     }
 948   }
 949
 950   if(history.size()>1)
 951     onAdded(Index(1));
 952   Entry* e = fetch(Index(0));
 953   for(Variations::const_iterator it = e->variations.begin();
 954           it != e->variations.end(); ++it)
 955     onAdded(Index(0).next(it->first));
 956   for(VComments::const_iterator it = e->vcomments.begin();
 957           it != e->vcomments.end(); ++it)
 958     onSetVComment(Index(0), it->first, it->second);
 959
 960   current = Index(0);
 961   onCurrentIndexChanged();
 962 }
 963 #endif //NO_PGN
 964