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