src/graphicalsystem.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   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 "graphicalsystem.h"
  12 #include "chesstable.h"
  13 #include "board.h"
  14 #include "piecepool.h"
  15 #include "pointconverter.h"
  16 #include "sprite.h"
  17 #include "animation.h"
  18 #include "pref_theme.h"
  19 #include "movelist_table.h"
  20 #include "global.h"
  21
  22 using namespace boost;
  23
  24 //BEGIN GraphicalSystem
  25
  26 GraphicalSystem::GraphicalSystem(ChessTable* view,
  27                              AbstractPosition::Ptr startingPosition,
  28                              VariantInfo* variant)
  29 : m_view(view)
  30 , m_variant(variant) {
  31
  32   m_pos = startingPosition->clone();
  33   Point s = m_pos->size();
  34   for(int i=0;i<s.x;i++)
  35   for(int j=0;j<s.y;j++)
  36     m_pos->set(Point(i,j), AbstractPiece::Ptr());
  37
  38   m_board = view->board();
  39
  40   m_board->createGrid(m_pos->size(), m_pos->borderCoords());
  41   m_board->reset();
  42
  43   m_view->pool(0)->clear();
  44   m_view->pool(1)->clear();
  45
  46   m_animator = m_variant->createAnimator(this);
  47
  48   settings.onChange( this, SLOT(settingsChanged()));
  49   settingsChanged();
  50
  51   if (startingPosition)
  52     warp(AbstractMove::Ptr(), startingPosition);
  53 }
  54
  55 GraphicalSystem::~GraphicalSystem() {
  56 }
  57
  58 const PointConverter* GraphicalSystem::converter() const {
  59   return m_board->converter();
  60 }
  61
  62 AbstractPosition::Ptr GraphicalSystem::position() const {
  63   return m_pos;
  64 }
  65
  66 void GraphicalSystem::settingsChanged() {
  67
  68   /* recreate the animator to reload its settings */
  69   m_animator = m_variant->createAnimator(this);
  70
  71   QString theme = PrefTheme::getBestTheme(m_variant);
  72   QString sqtheme = PrefTheme::getBestTheme(m_variant, PrefTheme::Squares);
  73   QString figtheme = PrefTheme::getBestTheme(m_variant, PrefTheme::Figurines);
  74
  75   m_board->loader()->setBasePath( theme );
  76   m_board->tagsLoader()->setBasePath( sqtheme );
  77
  78   m_view->pool(0)->loader()->setBasePath( theme );
  79   m_view->pool(1)->loader()->setBasePath( theme );
  80
  81   m_view->moveListTable()->setLoaderBasePath( figtheme );
  82   m_view->moveListTable()->settingsChanged();
  83
  84   //clear board and pool, forcing reload
  85   m_view->settingsChanged();
  86 }
  87
  88 void GraphicalSystem::setup(const shared_ptr<UserEntity>& entity) {
  89   m_view->setEntity(entity);
  90 }
  91
  92 NamedSprite GraphicalSystem::getSprite(const Point& p) {
  93   if (!m_board->m_sprites.valid(p))
  94     return NamedSprite();
  95
  96   return m_board->m_sprites[p];
  97 }
  98
  99 NamedSprite GraphicalSystem::takeSprite(const Point& p) {
 100   if (!m_board->m_sprites.valid(p))
 101     return NamedSprite();
 102
 103   NamedSprite retv = m_board->m_sprites[p];
 104   m_board->m_sprites[p] = NamedSprite();
 105   return retv;
 106 }
 107
 108 NamedSprite GraphicalSystem::setPiece(const Point& p, const AbstractPiece* piece, bool show) {
 109   return m_board->m_sprites[p] = createPiece(p, piece, show);
 110 }
 111
 112 NamedSprite GraphicalSystem::createPiece(const Point& p, const AbstractPiece* piece, bool show) {
 113   Q_ASSERT(piece);
 114   if (!m_board->m_sprites.valid(p))
 115     return NamedSprite();
 116
 117   NamedSprite s(piece->name(), SpritePtr(new Sprite(m_board->m_loader(piece->name()),
 118                                  m_board->piecesGroup(), m_board->converter()->toReal(p))) );
 119   if (show)
 120     s.sprite()->show();
 121   return s;
 122 }
 123
 124 void GraphicalSystem::setSprite(const Point& p, const NamedSprite& sprite) {
 125   if (!m_board->m_sprites.valid(p))
 126     return;
 127
 128   m_board->m_sprites[p] = sprite;
 129 }
 130
 131 int GraphicalSystem::poolSize(int pool) {
 132   return m_view->pool(pool)->fill();
 133 }
 134
 135 // NamedSprite GraphicalSystem::getPoolSprite(int pool, int index) {
 136 //   return m_view->pool(pool)->getSprite(index);
 137 // }
 138
 139 void GraphicalSystem::removePoolSprite(int pool, int index) {
 140   m_view->pool(pool)->removeSprite(index);
 141 }
 142
 143 NamedSprite GraphicalSystem::takePoolSprite(int pool, int index) {
 144   return m_view->pool(pool)->takeSprite(index);
 145 }
 146
 147 NamedSprite GraphicalSystem::insertPoolPiece(int pool, int index, const AbstractPiece* piece) {
 148   PiecePool *pl = m_view->pool(pool);
 149   QPixmap px = pl->m_loader(piece->name());
 150
 151   NamedSprite s( piece->name(), SpritePtr( new Sprite( px, pl, QPoint() ) ) );
 152   pl->insertSprite(index, s);
 153   return s;
 154 }
 155
 156 std::pair<int, int> GraphicalSystem::droppedPoolPiece() {
 157   return std::pair<int, int>(m_board->m_dropped_pool, m_board->m_dropped_index);
 158 }
 159
 160 AnimationPtr GraphicalSystem::animate(const Animate::Scheme& scheme, Animate::AnimationType type) {
 161   return scheme.run(converter(), type);
 162 }
 163
 164
 165 #if 0
 166 void GraphicalSystem::updatePool(AbstractPosition::PoolPtr pool) {
 167
 168   AbstractPosition::PoolPtr curr = m_pos->pool();
 169
 170   AbstractPosition::AbstractPool::iterator oldit = curr->begin();
 171   AbstractPosition::AbstractPool::iterator newit = pool->begin();
 172
 173   while(oldit != curr->end() || newit != pool->end()) {
 174     if(newit == pool->end() || (oldit != curr->end()
 175             && oldit->first->less(newit->first) )) {
 176       removeFromPool(oldit->first, oldit->second);
 177       ++oldit;
 178     }
 179     else if (oldit == curr->end() || (newit != pool->end()
 180             && newit->first->less(oldit->first) )) {
 181       addToPool(newit->first, newit->second);
 182       ++newit;
 183     }
 184     else {
 185       Q_ASSERT(newit->first->equals(oldit->first));
 186       if(oldit->second < newit->second)
 187         addToPool(newit->first, newit->second - oldit->second);
 188       else if(oldit->second > newit->second)
 189         removeFromPool(newit->first, oldit->second - newit->second);
 190       ++newit;
 191       ++oldit;
 192     }
 193   }
 194 }
 195
 196 void GraphicalSystem::addToPool(AbstractPiece::Ptr piece, int n) {
 197   PiecePool *pool = m_view->pool(!piece->color());
 198   QPixmap px = pool->m_loader(piece->name());
 199
 200   for(int i=0;i<n;i++) {
 201     SpritePtr s = SpritePtr( new Sprite( px, pool->piecesGroup(), QPoint() ) );
 202     pool->addPiece(Element(piece, s));
 203   }
 204
 205   m_pos->addToPool(piece, n);
 206 }
 207
 208 void GraphicalSystem::removeFromPool(AbstractPiece::Ptr piece, int n) {
 209   PiecePool *pool = m_view->pool(!piece->color());
 210
 211   for(int i=0;i<n;i++)
 212     pool->takePiece(piece);
 213   m_pos->removeFromPool(piece, n);
 214 }
 215 #endif
 216
 217 #if 0
 218 void GraphicalSystem::addTag(const QString& name, Point pt, bool over) {
 219   m_board->addTag(name, pt, over);
 220 }
 221
 222 void GraphicalSystem::clearTags(const QString& name) {
 223   m_board->clearTags(name);
 224 }
 225
 226 void GraphicalSystem::setTags(const QString& name, Point p1, Point p2,
 227                         Point p3, Point p4, Point p5, Point p6 ) {
 228   m_board->setTags(name, p1, p2, p3, p4, p5, p6);
 229 }
 230 #endif
 231
 232 #if 0
 233 bool GraphicalSystem::consistent() const {
 234   for (Point i = first(); i <= last(); i = next(i)) {
 235     Element e = getElement(i);
 236     if (static_cast<bool>(e.piece()) ^
 237         static_cast<bool>(e.sprite())) return false;
 238   }
 239   return true;
 240 }
 241 #endif
 242
 243 #if 0
 244 Point GraphicalSystem::first() const { return m_board->m_sprites.first(); }
 245 Point GraphicalSystem::last() const { return m_board->m_sprites.last(); }
 246 Point GraphicalSystem::next(const Point& p) const { return m_board->m_sprites.next(p); }
 247 bool GraphicalSystem::valid(const Point& p) const { return m_board->m_sprites.valid(p); }
 248 #endif
 249
 250 void GraphicalSystem::forward(const AbstractMove::Ptr& move,
 251                               const AbstractPosition::Ptr& pos,
 252   const SpritePtr& /*movingSprite*/) {
 253   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 254
 255   if (move) {
 256     AnimationPtr animation = m_animator->forward(pos, move);
 257     //??? animation->setChainAbortions(false);
 258     m_board->enqueue(animation);
 259     m_board->setTags("highlighting", move->toUserMove().from, move->toUserMove().to);
 260
 261     m_pos->copyFrom(pos);
 262   }
 263   else
 264     warp(AbstractMove::Ptr(), pos);
 265
 266   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 267   if(!(sel1 && sel2 && sel1->equals(sel2)))
 268     m_board->cancelSelection();
 269
 270   m_board->cancelPremove();
 271   m_view->updateTurn(pos->turn());
 272   m_board->onPositionChanged();
 273 }
 274
 275 void GraphicalSystem::back(const AbstractMove::Ptr& lastMove,
 276                            const AbstractMove::Ptr& move,
 277                            const AbstractPosition::Ptr& pos) {
 278   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 279
 280   if (move) {
 281     AnimationPtr animation = m_animator->back(pos, move);
 282     //??? animation->setChainAbortions(false);
 283     m_board->enqueue(animation);
 284
 285     m_pos->copyFrom(pos);
 286   }
 287   else
 288     warp(lastMove, pos);
 289
 290   if (lastMove)
 291     m_board->setTags("highlighting", lastMove->toUserMove().from, lastMove->toUserMove().to);
 292   else
 293     m_board->clearTags("highlighting");
 294
 295   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 296   if(!(sel1 && sel2 && sel1->equals(sel2)))
 297     m_board->cancelSelection();
 298   m_board->cancelPremove();
 299   m_view->updateTurn(pos->turn());
 300   m_board->onPositionChanged();
 301 }
 302
 303 void GraphicalSystem::warp(const AbstractMove::Ptr& lastMove,
 304                            const AbstractPosition::Ptr& pos) {
 305
 306   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 307
 308   AnimationPtr animation = m_animator->warp(pos);
 309   //??? animation->setChainAbortions(false);
 310   m_board->enqueue(animation);
 311
 312   m_pos->copyFrom(pos);
 313
 314   if (lastMove)
 315     m_board->setTags("highlighting", lastMove->toUserMove().from, lastMove->toUserMove().to);
 316   else
 317     m_board->clearTags("highlighting");
 318
 319   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 320   if(!(sel1 && sel2 && sel1->equals(sel2)))
 321     m_board->cancelSelection();
 322   m_view->updateTurn(pos->turn());
 323   m_board->onPositionChanged();
 324 }
 325
 326 void GraphicalSystem::adjustSprite(const Point& p) {
 327   SpritePtr sprite = m_board->m_sprites[p].sprite();
 328   Q_ASSERT(sprite);
 329   QPoint destination = m_board->converter()->toReal(p);
 330   shared_ptr<Animation> animation(new MovementAnimation(sprite, destination));
 331   m_board->enqueue(animation);
 332 }
 333
 334 void GraphicalSystem::setTurn(int turn) {
 335   m_pos->setTurn(turn);
 336   m_view->updateTurn(m_pos->turn());
 337 }
 338
 339
 340
 341
 342