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