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   QPixmap px = m_board->m_loader(piece->name());
 118
 119 #if 0
 120   SpritePtr s;
 121   if (usedrop && m_board->m_drop_sprite) {
 122     s = m_board->m_drop_sprite.sprite();
 123     m_board->m_drop_sprite = NamedSprite();
 124   }
 125   else {
 126     s = m_board->createSprite(px, p);
 127     if (show) s->show();
 128   }
 129   return m_board->m_sprites[p] = NamedSprite(piece->name(), s);
 130 #else
 131   NamedSprite s(piece->name(), m_board->createSprite(px, p));
 132   if (show)
 133     s.sprite()->show();
 134   return s;
 135 #endif
 136 }
 137
 138 void GraphicalSystem::setSprite(const Point& p, const NamedSprite& sprite) {
 139   if (!m_board->m_sprites.valid(p))
 140     return;
 141
 142   m_board->m_sprites[p] = sprite;
 143 }
 144
 145 int GraphicalSystem::poolSize(int pool) {
 146   return m_view->pool(pool)->fill();
 147 }
 148
 149 NamedSprite GraphicalSystem::getPoolSprite(int pool, int index) {
 150   return m_view->pool(pool)->getSprite(index);
 151 }
 152
 153 NamedSprite GraphicalSystem::takePoolSprite(int pool, int index) {
 154   return m_view->pool(pool)->takeSprite(index);
 155 }
 156
 157 NamedSprite GraphicalSystem::insertPoolPiece(int pool, int index, const AbstractPiece* piece) {
 158   PiecePool *pl = m_view->pool(pool);
 159   QPixmap px = pl->m_loader(piece->name());
 160
 161   NamedSprite s( piece->name(), SpritePtr( new Sprite( px, pl->piecesGroup(), QPoint() ) ) );
 162   pl->insertSprite(index, s);
 163   return s;
 164 }
 165
 166 std::pair<int, int> GraphicalSystem::droppedPoolPiece() {
 167   return std::pair<int, int>(m_board->m_dropped_pool, m_board->m_dropped_index);
 168 }
 169
 170 AnimationPtr GraphicalSystem::animate(const Animate::Scheme& scheme, Animate::AnimationType type) {
 171   return scheme.run(converter(), type);
 172 }
 173
 174
 175 #if 0
 176 void GraphicalSystem::updatePool(AbstractPosition::PoolPtr pool) {
 177
 178   AbstractPosition::PoolPtr curr = m_pos->pool();
 179
 180   AbstractPosition::AbstractPool::iterator oldit = curr->begin();
 181   AbstractPosition::AbstractPool::iterator newit = pool->begin();
 182
 183   while(oldit != curr->end() || newit != pool->end()) {
 184     if(newit == pool->end() || (oldit != curr->end()
 185             && oldit->first->less(newit->first) )) {
 186       removeFromPool(oldit->first, oldit->second);
 187       ++oldit;
 188     }
 189     else if (oldit == curr->end() || (newit != pool->end()
 190             && newit->first->less(oldit->first) )) {
 191       addToPool(newit->first, newit->second);
 192       ++newit;
 193     }
 194     else {
 195       Q_ASSERT(newit->first->equals(oldit->first));
 196       if(oldit->second < newit->second)
 197         addToPool(newit->first, newit->second - oldit->second);
 198       else if(oldit->second > newit->second)
 199         removeFromPool(newit->first, oldit->second - newit->second);
 200       ++newit;
 201       ++oldit;
 202     }
 203   }
 204 }
 205
 206 void GraphicalSystem::addToPool(AbstractPiece::Ptr piece, int n) {
 207   PiecePool *pool = m_view->pool(!piece->color());
 208   QPixmap px = pool->m_loader(piece->name());
 209
 210   for(int i=0;i<n;i++) {
 211     SpritePtr s = SpritePtr( new Sprite( px, pool->piecesGroup(), QPoint() ) );
 212     pool->addPiece(Element(piece, s));
 213   }
 214
 215   m_pos->addToPool(piece, n);
 216 }
 217
 218 void GraphicalSystem::removeFromPool(AbstractPiece::Ptr piece, int n) {
 219   PiecePool *pool = m_view->pool(!piece->color());
 220
 221   for(int i=0;i<n;i++)
 222     pool->takePiece(piece);
 223   m_pos->removeFromPool(piece, n);
 224 }
 225 #endif
 226
 227 #if 0
 228 void GraphicalSystem::addTag(const QString& name, Point pt, bool over) {
 229   m_board->addTag(name, pt, over);
 230 }
 231
 232 void GraphicalSystem::clearTags(const QString& name) {
 233   m_board->clearTags(name);
 234 }
 235
 236 void GraphicalSystem::setTags(const QString& name, Point p1, Point p2,
 237                         Point p3, Point p4, Point p5, Point p6 ) {
 238   m_board->setTags(name, p1, p2, p3, p4, p5, p6);
 239 }
 240 #endif
 241
 242 #if 0
 243 bool GraphicalSystem::consistent() const {
 244   for (Point i = first(); i <= last(); i = next(i)) {
 245     Element e = getElement(i);
 246     if (static_cast<bool>(e.piece()) ^
 247         static_cast<bool>(e.sprite())) return false;
 248   }
 249   return true;
 250 }
 251 #endif
 252
 253 #if 0
 254 Point GraphicalSystem::first() const { return m_board->m_sprites.first(); }
 255 Point GraphicalSystem::last() const { return m_board->m_sprites.last(); }
 256 Point GraphicalSystem::next(const Point& p) const { return m_board->m_sprites.next(p); }
 257 bool GraphicalSystem::valid(const Point& p) const { return m_board->m_sprites.valid(p); }
 258 #endif
 259
 260 void GraphicalSystem::forward(const AbstractMove::Ptr& move,
 261                               const AbstractPosition::Ptr& pos,
 262   const SpritePtr& /*movingSprite*/) {
 263   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 264
 265   if (move) {
 266     AnimationPtr animation = m_animator->forward(pos, move);
 267     //??? animation->setChainAbortions(false);
 268     m_board->enqueue(animation);
 269     m_board->setTags("highlighting", move->toUserMove().from, move->toUserMove().to);
 270
 271     m_pos->copyFrom(pos);
 272   }
 273   else
 274     warp(AbstractMove::Ptr(), pos);
 275
 276   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 277   if(!(sel1 && sel2 && sel1->equals(sel2)))
 278     m_board->cancelSelection();
 279
 280   m_board->cancelPremove();
 281   m_view->updateTurn(pos->turn());
 282   m_board->onPositionChanged();
 283 }
 284
 285 void GraphicalSystem::back(const AbstractMove::Ptr& lastMove,
 286                            const AbstractMove::Ptr& move,
 287                            const AbstractPosition::Ptr& pos) {
 288   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 289
 290   if (move) {
 291     AnimationPtr animation = m_animator->back(pos, move);
 292     //??? animation->setChainAbortions(false);
 293     m_board->enqueue(animation);
 294
 295     m_pos->copyFrom(pos);
 296   }
 297   else
 298     warp(lastMove, pos);
 299
 300   if (lastMove)
 301     m_board->setTags("highlighting", lastMove->toUserMove().from, lastMove->toUserMove().to);
 302   else
 303     m_board->clearTags("highlighting");
 304
 305   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 306   if(!(sel1 && sel2 && sel1->equals(sel2)))
 307     m_board->cancelSelection();
 308   m_board->cancelPremove();
 309   m_view->updateTurn(pos->turn());
 310   m_board->onPositionChanged();
 311 }
 312
 313 void GraphicalSystem::warp(const AbstractMove::Ptr& lastMove,
 314                            const AbstractPosition::Ptr& pos) {
 315
 316   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 317
 318   AnimationPtr animation = m_animator->warp(pos);
 319   //??? animation->setChainAbortions(false);
 320   m_board->enqueue(animation);
 321
 322   m_pos->copyFrom(pos);
 323
 324   if (lastMove)
 325     m_board->setTags("highlighting", lastMove->toUserMove().from, lastMove->toUserMove().to);
 326   else
 327     m_board->clearTags("highlighting");
 328
 329   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 330   if(!(sel1 && sel2 && sel1->equals(sel2)))
 331     m_board->cancelSelection();
 332   m_view->updateTurn(pos->turn());
 333   m_board->onPositionChanged();
 334 }
 335
 336 void GraphicalSystem::adjustSprite(const Point& p) {
 337   SpritePtr sprite = m_board->m_sprites[p].sprite();
 338   Q_ASSERT(sprite);
 339   QPoint destination = m_board->converter()->toReal(p);
 340   shared_ptr<Animation> animation(new MovementAnimation(sprite, destination));
 341   m_board->enqueue(animation);
 342 }
 343
 344 void GraphicalSystem::setTurn(int turn) {
 345   m_pos->setTurn(turn);
 346   m_view->updateTurn(m_pos->turn());
 347 }
 348
 349
 350
 351
 352