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(m_proxy, SLOT(settingsChanged()));
  49   //settingsChanged();
  50
  51   if (startingPosition)
  52     warp(AbstractMove::Ptr(), startingPosition);
  53 }
  54
  55 GraphicalSystem::~GraphicalSystem() {
  56 }
  57
  58 void GraphicalSystem::settingsChanged() {
  59
  60   /* recreate the animator to reload its settings */
  61   m_animator = m_variant->createAnimator(this);
  62
  63   QString theme = PrefTheme::getBestTheme(m_variant);
  64   QString sqtheme = PrefTheme::getBestTheme(m_variant, PrefTheme::Squares);
  65   QString figtheme = PrefTheme::getBestTheme(m_variant, PrefTheme::Figurines);
  66
  67   m_board->loader()->setBasePath( theme );
  68   m_board->tagsLoader()->setBasePath( sqtheme );
  69
  70   m_view->pool(0)->loader()->setBasePath( theme );
  71   m_view->pool(1)->loader()->setBasePath( theme );
  72
  73   m_view->moveListTable()->setLoaderBasePath( figtheme );
  74   m_view->moveListTable()->settingsChanged();
  75
  76   //clear board and pool, forcing reload
  77   m_view->settingsChanged();
  78 }
  79
  80 void GraphicalSystem::setup(const shared_ptr<UserEntity>& entity) {
  81   m_view->setEntity(entity);
  82 }
  83
  84 SpritePtr GraphicalSystem::getSprite(const Point& p) {
  85   if (!m_board->m_sprites.valid(p))
  86     return shared_ptr<Sprite>();
  87
  88   return m_board->m_sprites[p].sprite();
  89 }
  90
  91 SpritePtr GraphicalSystem::takeSprite(const Point& p) {
  92   if (!m_board->m_sprites.valid(p))
  93     return shared_ptr<Sprite>();
  94
  95   SpritePtr retv = m_board->m_sprites[p].sprite();
  96   m_board->m_sprites[p] = NamedSprite();
  97   return retv;
  98 }
  99
 100 SpritePtr GraphicalSystem::setSprite(const Point& p, const AbstractPiece* piece, bool usedrop, bool show) {
 101   Q_ASSERT(piece);
 102   if(!m_board->m_sprites.valid(p))
 103     return SpritePtr();
 104
 105   QPixmap px = m_board->m_loader(piece->name());
 106
 107   SpritePtr s;
 108   if(usedrop && m_board->m_drop_sprite) {
 109     s = m_board->m_drop_sprite.sprite();
 110     m_board->m_drop_sprite = NamedSprite();
 111   }
 112   else {
 113     s = m_board->createSprite(px, p);
 114     if (show) s->show();
 115   }
 116   m_board->m_sprites[p] = NamedSprite(piece->name(), s);
 117   return s;
 118 }
 119
 120
 121 int GraphicalSystem::poolSize(int pool) {
 122   return m_view->pool(pool)->fill();
 123 }
 124
 125 SpritePtr GraphicalSystem::getPoolSprite(int pool, int index) {
 126   return m_view->pool(pool)->getSprite(index);
 127 }
 128
 129 SpritePtr GraphicalSystem::takePoolSprite(int pool, int index) {
 130   return m_view->pool(pool)->takeSprite(index);
 131 }
 132
 133 SpritePtr GraphicalSystem::insertPoolSprite(int pool, int index, const AbstractPiece* piece) {
 134   PiecePool *pl = m_view->pool(pool);
 135   QPixmap px = pl->m_loader(piece->name());
 136
 137   SpritePtr s = SpritePtr( new Sprite( px, pl->piecesGroup(), QPoint() ) );
 138   pl->insertSprite(index, NamedSprite(piece->name(), s) );
 139   return s;
 140 }
 141
 142 #if 0
 143 void GraphicalSystem::updatePool(AbstractPosition::PoolPtr pool) {
 144
 145   AbstractPosition::PoolPtr curr = m_pos->pool();
 146
 147   AbstractPosition::AbstractPool::iterator oldit = curr->begin();
 148   AbstractPosition::AbstractPool::iterator newit = pool->begin();
 149
 150   while(oldit != curr->end() || newit != pool->end()) {
 151     if(newit == pool->end() || (oldit != curr->end()
 152             && oldit->first->less(newit->first) )) {
 153       removeFromPool(oldit->first, oldit->second);
 154       ++oldit;
 155     }
 156     else if (oldit == curr->end() || (newit != pool->end()
 157             && newit->first->less(oldit->first) )) {
 158       addToPool(newit->first, newit->second);
 159       ++newit;
 160     }
 161     else {
 162       Q_ASSERT(newit->first->equals(oldit->first));
 163       if(oldit->second < newit->second)
 164         addToPool(newit->first, newit->second - oldit->second);
 165       else if(oldit->second > newit->second)
 166         removeFromPool(newit->first, oldit->second - newit->second);
 167       ++newit;
 168       ++oldit;
 169     }
 170   }
 171 }
 172
 173 void GraphicalSystem::addToPool(AbstractPiece::Ptr piece, int n) {
 174   PiecePool *pool = m_view->pool(!piece->color());
 175   QPixmap px = pool->m_loader(piece->name());
 176
 177   for(int i=0;i<n;i++) {
 178     SpritePtr s = SpritePtr( new Sprite( px, pool->piecesGroup(), QPoint() ) );
 179     pool->addPiece(Element(piece, s));
 180   }
 181
 182   m_pos->addToPool(piece, n);
 183 }
 184
 185 void GraphicalSystem::removeFromPool(AbstractPiece::Ptr piece, int n) {
 186   PiecePool *pool = m_view->pool(!piece->color());
 187
 188   for(int i=0;i<n;i++)
 189     pool->takePiece(piece);
 190   m_pos->removeFromPool(piece, n);
 191 }
 192 #endif
 193
 194 #if 0
 195 void GraphicalSystem::addTag(const QString& name, Point pt, bool over) {
 196   m_board->addTag(name, pt, over);
 197 }
 198
 199 void GraphicalSystem::clearTags(const QString& name) {
 200   m_board->clearTags(name);
 201 }
 202
 203 void GraphicalSystem::setTags(const QString& name, Point p1, Point p2,
 204                         Point p3, Point p4, Point p5, Point p6 ) {
 205   m_board->setTags(name, p1, p2, p3, p4, p5, p6);
 206 }
 207 #endif
 208
 209 #if 0
 210 bool GraphicalSystem::consistent() const {
 211   for (Point i = first(); i <= last(); i = next(i)) {
 212     Element e = getElement(i);
 213     if (static_cast<bool>(e.piece()) ^
 214         static_cast<bool>(e.sprite())) return false;
 215   }
 216   return true;
 217 }
 218 #endif
 219
 220 #if 0
 221 Point GraphicalSystem::first() const { return m_board->m_sprites.first(); }
 222 Point GraphicalSystem::last() const { return m_board->m_sprites.last(); }
 223 Point GraphicalSystem::next(const Point& p) const { return m_board->m_sprites.next(p); }
 224 bool GraphicalSystem::valid(const Point& p) const { return m_board->m_sprites.valid(p); }
 225 #endif
 226
 227 void GraphicalSystem::forward(const AbstractMove::Ptr& move,
 228                               const AbstractPosition::Ptr& pos,
 229   const SpritePtr& /*movingSprite*/) {
 230   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 231
 232   if (move) {
 233     shared_ptr<AnimationGroup> animation = m_animator->forward(pos, move);
 234     animation->setChainAbortions(false);
 235     m_board->enqueue(animation);
 236     m_board->setTags("highlighting", move->toUserMove().from, move->toUserMove().to);
 237   }
 238   else
 239     warp(AbstractMove::Ptr(), pos);
 240
 241   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 242   if(!(sel1 && sel2 && sel1->equals(sel2)))
 243     m_board->cancelSelection();
 244
 245   m_board->cancelPremove();
 246   m_view->updateTurn(pos->turn());
 247   m_board->onPositionChanged();
 248 }
 249
 250 void GraphicalSystem::back(const AbstractMove::Ptr& lastMove,
 251                            const AbstractMove::Ptr& move,
 252                            const AbstractPosition::Ptr& pos) {
 253   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 254
 255   if (move) {
 256     shared_ptr<AnimationGroup> animation = m_animator->back(pos, move);
 257     animation->setChainAbortions(false);
 258     m_board->enqueue(animation);
 259   }
 260   else
 261     warp(lastMove, pos);
 262
 263   if (lastMove)
 264     m_board->setTags("highlighting", lastMove->toUserMove().from, lastMove->toUserMove().to);
 265   else
 266     m_board->clearTags("highlighting");
 267
 268   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 269   if(!(sel1 && sel2 && sel1->equals(sel2)))
 270     m_board->cancelSelection();
 271   m_board->cancelPremove();
 272   m_view->updateTurn(pos->turn());
 273   m_board->onPositionChanged();
 274 }
 275
 276 void GraphicalSystem::warp(const AbstractMove::Ptr& lastMove,
 277                            const AbstractPosition::Ptr& pos) {
 278
 279   AbstractPiece::Ptr sel1 = m_pos->get(m_board->selection);
 280   shared_ptr<AnimationGroup> animation = m_animator->warp(pos);
 281   animation->setChainAbortions(false);
 282
 283   m_board->enqueue(animation);
 284
 285   if (lastMove)
 286     m_board->setTags("highlighting", lastMove->toUserMove().from, lastMove->toUserMove().to);
 287   else
 288     m_board->clearTags("highlighting");
 289
 290   AbstractPiece::Ptr sel2 = m_pos->get(m_board->selection);
 291   if(!(sel1 && sel2 && sel1->equals(sel2)))
 292     m_board->cancelSelection();
 293   m_view->updateTurn(pos->turn());
 294   m_board->onPositionChanged();
 295 }
 296
 297 void GraphicalSystem::adjustSprite(const Point& p) {
 298   SpritePtr sprite = m_board->m_sprites[p].sprite();
 299   Q_ASSERT(sprite);
 300   QPoint destination = m_board->converter()->toReal(p);
 301   shared_ptr<Animation> animation(new MovementAnimation(sprite, destination));
 302   m_board->enqueue(animation);
 303 }
 304
 305 void GraphicalSystem::setTurn(int turn) {
 306   m_pos->setTurn(turn);
 307   m_view->updateTurn(m_pos->turn());
 308 }
 309
 310 #include "graphicalsystem.moc"
 311
 312
 313
 314