src/graphicalsystem.cpp

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