src/graphicalgame.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 "graphicalgame.h"
  13 #include "game.h"
  14 #include "game_p.h"
  15 #include "mastersettings.h"
  16 #include "graphicalsystem.h"
  17 #include "movelist_table.h"
  18 #include "decoratedmove.h"
  19 #include "entities/userentity.h"
  20 #include <iostream>
  21
  22 using namespace GamePrivate; // is this ok?
  23
  24 class CtrlAction {
  25   Game* m_game;
  26   bool m_done;
  27   Index m_index;
  28 public:
  29   CtrlAction(Game* game)
  30   : m_game(game)
  31   , m_index(game->index()) {
  32     m_done = m_game->back();
  33   }
  34
  35   void forfait() { m_done = false; }
  36
  37   ~CtrlAction() {
  38     if (m_done) m_game->goTo(m_index);
  39   }
  40 };
  41
  42 GraphicalGame::GraphicalGame(GraphicalSystem* graphical,
  43                              MoveList::Table* m)
  44 : Game()
  45 , m_graphical(graphical)
  46 , m_movelist(m)
  47 , m_anim_sequence(false) {
  48   if(m_movelist) {
  49     m_movelist->reset();
  50     m_movelist->setLayoutStyle(graphical->m_variant->moveListLayout());
  51     m_movelist->setNotifier( static_cast<MoveList::Notifier*>(this) );
  52     m_movelist->show();
  53   }
  54   settings().onChange(this, "settingsChanged", "Loader::Theme");
  55   settingsChanged();
  56 }
  57
  58 GraphicalGame::~GraphicalGame() {
  59   if(m_movelist) {
  60     Q_ASSERT(m_movelist->getNotifier() == static_cast<MoveList::Notifier*>(this));
  61
  62     m_movelist->setNotifier(NULL, false);
  63   }
  64 }
  65
  66 void GraphicalGame::settingsChanged() {
  67   m_anim_sequence = settings().flag("animations", true)
  68                       && settings()("animations").flag("sequence", true);
  69   m_anim_sequence_max = settings()("animations")("sequence")[QString("max")] | 10;
  70 }
  71
  72 void GraphicalGame::onAdded(const Index& ix) {
  73   onAddedInternal(ix);
  74 }
  75
  76 void GraphicalGame::onAddedInternal(const Index& ix, bool confirm_promotion) {
  77   if(!m_movelist)
  78     return;
  79
  80   int at;
  81   History *vec = fetchRef(ix, &at);
  82   if(!vec) {
  83     ERROR("invalid index " << ix);
  84     return;
  85   }
  86
  87   m_movelist->remove(ix, confirm_promotion); //clear existing, if any
  88
  89   Index index = ix;
  90   for(int i=at;i<(int)vec->size();i++) {
  91     Entry* e = &(*vec)[i];
  92     PositionPtr prev = position(index.prev());
  93     DecoratedMove mv(
  94       (e->move && prev) ?
  95       e->move->toString("decorated", prev) :
  96       (e->position ? "(-)" : "???"));
  97
  98     int turn = prev ? prev->turn() : (index.totalNumMoves()+1)%2;
  99     //mv += " " + QString::number(turn);
 100     m_movelist->setMove(index, turn, mv, e->comment, confirm_promotion);
 101
 102     for (Variations::const_iterator it = e->variations.begin();
 103             it != e->variations.end(); ++it)
 104       onAddedInternal(index.next(it->first), confirm_promotion);
 105     for (VComments::const_iterator it = e->vcomments.begin();
 106             it != e->vcomments.end(); ++it)
 107       m_movelist->setVComment(index, it->first, it->second, confirm_promotion);
 108
 109     index = index.next();
 110   }
 111 }
 112
 113 void GraphicalGame::onEntryChanged(const Index& at, int propagate) {
 114   if(at <= Index(0)) {
 115     Entry* e = fetch(at);
 116     if(!e)
 117       return;
 118     if(at == current && e->position)
 119       m_graphical->warp(e->move, e->position);
 120     return;
 121   }
 122
 123   if(m_movelist) {
 124     Entry* e = fetch(at);
 125     if(!e)
 126       return;
 127
 128     Entry* pe = fetch(at.prev());
 129
 130     AbstractPosition::Ptr last_pos;
 131     if (pe) last_pos = pe->position;
 132
 133     DecoratedMove mv(
 134       (e->move && last_pos) ?
 135       e->move->toString("decorated", last_pos) :
 136       (e->position ? "(-)" : "???"));
 137     int turn = last_pos ? last_pos->turn() : (at.totalNumMoves()+1)%2;
 138     m_movelist->setMove(at, turn, mv, e->comment);
 139     if(at == current && e->position)
 140       m_graphical->warp(e->move, e->position);
 141
 142     // when an entry changes, chances are that we get some more information about the
 143     // next ones as well
 144     if(propagate) {
 145       onEntryChanged(at.next(), propagate-1);
 146       for (Variations::const_iterator it = e->variations.begin();
 147               it != e->variations.end(); ++it)
 148         onEntryChanged(at.next(it->first), propagate-1);
 149     }
 150   }
 151 }
 152
 153 void GraphicalGame::onRemoved(const Index& i) {
 154   if(m_movelist)
 155     m_movelist->remove(i);
 156 }
 157
 158 void GraphicalGame::onPromoteVariation(const Index& i, int v) {
 159   if(m_movelist) {
 160     m_movelist->promoteVariation(i,v);
 161     onAddedInternal(i.next(), true);
 162     onAddedInternal(i.next(v), true);
 163     VComments vc = fetch(i)->vcomments;
 164     VComments::const_iterator it = vc.find(v);
 165     if(it != vc.end())
 166       m_movelist->setVComment(i, v, it->second, true);
 167     m_movelist->select(current, true);
 168   }
 169 }
 170
 171 void GraphicalGame::onSetComment(const Index& i, const QString& s) {
 172   if(m_movelist)
 173     m_movelist->setComment(i, s);
 174 }
 175
 176 void GraphicalGame::onSetVComment(const Index& i, int v, const QString& s) {
 177   if(m_movelist)
 178     m_movelist->setVComment(i, v, s);
 179 }
 180
 181 void GraphicalGame::onCurrentIndexChanged(const Index& old_c) {
 182   if (m_ctrl) m_ctrl->forfait();
 183
 184   if(m_movelist)
 185     m_movelist->select(current);
 186
 187   Entry *oe = fetch(old_c);
 188   Entry *e = fetch(current);
 189   std::pair<int, int> steps = old_c.stepsTo(current);
 190
 191   if(!e || !e->position)
 192     return;
 193
 194   if(!oe || !oe->position) {
 195     m_graphical->warp(move(), position());
 196     return;
 197   }
 198
 199   bool can_animate = (steps.first+steps.second <= 1) || (m_anim_sequence
 200                     && (steps.first+steps.second <= m_anim_sequence_max));
 201
 202   if(can_animate)
 203   for(int i=1;i<=steps.first;i++)
 204   if( !move(old_c.prev(i-1)) || !position(old_c.prev(i))) {
 205     can_animate = false;
 206     break;
 207   }
 208
 209   if(can_animate)
 210   for(int i=steps.second-1;i>=0;i--)
 211   if( !move(current.prev(i)) || !position(current.prev(i))) {
 212     can_animate = false;
 213     break;
 214   }
 215
 216   if(can_animate) {
 217     for(int i=1;i<=steps.first;i++)
 218       m_graphical->back( move(old_c.prev(i)), move(old_c.prev(i-1)), position(old_c.prev(i)));
 219     for(int i=steps.second-1;i>=0;i--)
 220       m_graphical->forward( move(current.prev(i)), position(current.prev(i)));
 221   }
 222   else
 223     m_graphical->warp( move(), position());
 224 }
 225
 226 void GraphicalGame::onAvailableUndo(bool e) {
 227   if(m_movelist)
 228     m_movelist->enableUndo(e);
 229 }
 230
 231 void GraphicalGame::onAvailableRedo(bool e) {
 232   if(m_movelist)
 233     m_movelist->enableRedo(e);
 234 }
 235
 236 void GraphicalGame::onUserSelectMove(const Index& i) {
 237   if (boost::shared_ptr<UserEntity> entity = m_listener_entity.lock())
 238     if (entity->goTo(i))
 239       return;
 240
 241   // fallback
 242   goTo(i);
 243 }
 244
 245 void GraphicalGame::onUserSetComment(const Index& i, QString s) {
 246   setComment(i, s);
 247 }
 248
 249 void GraphicalGame::onUserSetVComment(const Index& i, int v, QString s) {
 250   setVComment(i, v, s);
 251 }
 252
 253 void GraphicalGame::onUserClearVariations(const Index& i) {
 254   clearVariations(i);
 255 }
 256
 257 void GraphicalGame::onUserTruncate(const Index& i) {
 258   if (i == index())
 259     if (boost::shared_ptr<UserEntity> entity = m_listener_entity.lock())
 260       if (entity->truncate())
 261         return;
 262
 263   // fallback
 264   truncate(i);
 265 }
 266
 267 void GraphicalGame::onUserPromoteVariation(const Index& i) {
 268   if (i == index())
 269     if (boost::shared_ptr<UserEntity> entity = m_listener_entity.lock())
 270       if (entity->promoteVariation())
 271         return;
 272
 273   // fallback
 274   promoteVariation(i);
 275 }
 276
 277 void GraphicalGame::onUserRemoveVariation(const Index& i) {
 278   removeVariation(i);
 279 }
 280
 281 void GraphicalGame::onUserUndo() {
 282   if (boost::shared_ptr<UserEntity> entity = m_listener_entity.lock())
 283     if (entity->undo())
 284       return;
 285
 286   // fallback
 287   undo();
 288 }
 289
 290 void GraphicalGame::onUserRedo() {
 291   if (boost::shared_ptr<UserEntity> entity = m_listener_entity.lock())
 292     if (entity->redo())
 293       return;
 294
 295   // fallback
 296   redo();
 297 }
 298
 299 void GraphicalGame::onDetachNotifier() {
 300   Q_ASSERT(m_movelist->getNotifier() == static_cast<MoveList::Notifier*>(this));
 301
 302   m_movelist = NULL;
 303 }
 304
 305 void GraphicalGame::createCtrlAction() {
 306   m_ctrl = boost::shared_ptr<CtrlAction>(new CtrlAction(this));
 307 }
 308
 309 void GraphicalGame::destroyCtrlAction() {
 310   m_ctrl.reset();
 311 }
 312