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