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