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