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
  13 #include <KDebug>
  14
  15 #include <core/animator.h>
  16 #include <core/board.h>
  17 #include <core/color.h>
  18 #include <core/namer.h>
  19 #include <core/state.h>
  20
  21 #include "chesstable.h"
  22 #include "chessboard.h"
  23 #include "clock.h"
  24 #include "components.h"
  25 #include "piecepool.h"
  26 #include "pointconverter.h"
  27 #include "sprite.h"
  28 #include "animation.h"
  29 #include "pref_theme.h"
  30 #include "movelist_table.h"
  31 #include "mastersettings.h"
  32
  33 using namespace boost;
  34
  35 //BEGIN GraphicalSystem
  36
  37 GraphicalSystem::GraphicalSystem(ChessTable* view,
  38                              const StatePtr& startingPosition,
  39                              Components* components)
  40 : m_view(view)
  41 , m_components(components) {
  42   m_state = StatePtr(startingPosition->clone());
  43   Point s = m_state->board()->size();
  44   for(int i=0;i<s.x;i++)
  45   for(int j=0;j<s.y;j++)
  46     m_state->board()->set(Point(i,j), Piece());
  47
  48   m_board = view->board();
  49
  50   m_board->createGrid(m_state->board()->size(), m_state->board()->borderCoords());
  51   m_board->reset();
  52
  53   m_view->pool(0)->clear();
  54   m_view->pool(1)->clear();
  55
  56   m_animator = m_components->createAnimator(this);
  57
  58   settings().onChange(this, "settingsChanged", "Loader::Theme");
  59   settingsChanged();
  60
  61   if (startingPosition)
  62     warp(Move(), startingPosition);
  63 }
  64
  65 GraphicalSystem::~GraphicalSystem() {
  66   delete m_animator;
  67 }
  68
  69 const PointConverter* GraphicalSystem::converter() const {
  70   return m_board->converter();
  71 }
  72
  73 const IndexConverter* GraphicalSystem::indexConverter(int pool) const {
  74   return m_view->pool(pool)->converter();
  75 }
  76
  77 const IState* GraphicalSystem::state() const {
  78   return m_state.get();
  79 }
  80
  81 void GraphicalSystem::settingsChanged() {
  82   ThemeInfo theme = PrefTheme::getBestTheme(m_components->variant(), "pieces");
  83   ThemeInfo sqtheme = PrefTheme::getBestTheme(m_components->variant(), "squares");
  84   ThemeInfo figtheme = PrefTheme::getBestTheme(m_components->variant(), "figurines");
  85   ThemeInfo ctrltheme = PrefTheme::getBestTheme(m_components->variant(), "controls");
  86
  87   m_board->loader()->setTheme(theme);
  88   m_board->tagsLoader()->setTheme(sqtheme);
  89   m_board->controlsLoader()->setTheme(ctrltheme);
  90
  91   for(int i=0;i<2;i++)
  92     m_view->pool(i)->loader()->setTheme(theme);
  93
  94   for(int i=0;i<2;i++)
  95     m_view->clock(i)->controlsLoader()->setTheme(ctrltheme);
  96
  97   m_view->moveListTable()->setLoaderTheme(figtheme);
  98   m_view->moveListTable()->settingsChanged();
  99
 100   //clear board and pool, forcing reload
 101   m_view->settingsChanged();
 102 }
 103
 104 void GraphicalSystem::setup(const shared_ptr<UserEntity>& entity) {
 105   m_view->setEntity(entity);
 106 }
 107
 108 NamedSprite GraphicalSystem::getSprite(const Point& p) {
 109   if (!m_board->m_sprites.valid(p))
 110     return NamedSprite();
 111
 112   return m_board->m_sprites[p];
 113 }
 114
 115 NamedSprite GraphicalSystem::takeSprite(const Point& p) {
 116   if (!m_board->m_sprites.valid(p))
 117     return NamedSprite();
 118
 119   NamedSprite retv = m_board->m_sprites[p];
 120   m_board->m_sprites[p] = NamedSprite();
 121   return retv;
 122 }
 123
 124 NamedSprite GraphicalSystem::setPiece(const Point& p, const Piece& piece, bool show) {
 125   return m_board->m_sprites[p] = createPiece(p, piece, show);
 126 }
 127
 128 NamedSprite GraphicalSystem::createPiece(const Point& p, const Piece& piece, bool show) {
 129   Q_ASSERT(piece != Piece());
 130   if (!m_board->m_sprites.valid(p))
 131     return NamedSprite();
 132
 133   QString name = m_components->namer()->name(piece);
 134   NamedSprite s(name, SpritePtr(new Sprite(m_board->loadSprite(name),
 135                                 m_board->piecesGroup(), m_board->converter()->toReal(p))));
 136   if (show)
 137     s.sprite()->show();
 138   return s;
 139 }
 140
 141 void GraphicalSystem::setSprite(const Point& p, const NamedSprite& sprite) {
 142   if (!m_board->m_sprites.valid(p))
 143     return;
 144
 145   m_board->m_sprites[p] = sprite;
 146 }
 147
 148 int GraphicalSystem::poolSize(int pool) {
 149   return m_view->pool(pool)->fill();
 150 }
 151
 152 NamedSprite GraphicalSystem::getPoolSprite(const IColor* pool, int index) {
 153   return m_view->pool(pool->index())->getSprite(index);
 154 }
 155
 156 void GraphicalSystem::removePoolSprite(const IColor* pool, int index) {
 157   m_view->pool(pool->index())->removeSprite(index);
 158 }
 159
 160 NamedSprite GraphicalSystem::takePoolSprite(const IColor* pool, int index) {
 161   return m_view->pool(pool->index())->takeSprite(index);
 162 }
 163
 164 NamedSprite GraphicalSystem::insertPoolPiece(const IColor* pool,
 165                                              int index,
 166                                              const Piece& piece) {
 167   PiecePool *pl = m_view->pool(pool->index());
 168   QString name = m_components->namer()->name(piece);
 169   QPixmap px = pl->loadSprite(name);
 170
 171   NamedSprite s(name, SpritePtr(new Sprite(px, pl, QPoint())));
 172   pl->insertSprite(index, s);
 173   return s;
 174 }
 175
 176 std::pair<const IColor*, int> GraphicalSystem::droppedPoolPiece() {
 177   return std::pair<const IColor*, int>(m_board->m_dropped_pool, m_board->m_dropped_index);
 178 }
 179
 180 void GraphicalSystem::forward(const Move& move,
 181                               const StatePtr& pos,
 182   const SpritePtr& /*movingSprite*/) {
 183   const Piece* sel1 = m_state->board()->get(m_board->selection);
 184
 185   if (move != Move()) {
 186     AnimationPtr animation = m_animator->forward(move, pos.get());
 187     m_view->animationManager()->enqueue(animation);
 188     m_board->setTags("highlighting", move.src(), move.dst());
 189
 190     m_state->assign(pos.get());
 191   }
 192   else
 193     warp(Move(), pos);
 194
 195   const Piece* sel2 = m_state->board()->get(m_board->selection);
 196   if(!(sel1 != NULL && sel2 != NULL &&
 197        *sel1 != Piece() && *sel2 != Piece() && *sel1 == *sel2))
 198     m_board->cancelSelection();
 199
 200   m_board->cancelPremove();
 201   m_view->updateTurn(pos->turn()->index());
 202   m_board->onPositionChanged();
 203 }
 204
 205 void GraphicalSystem::back(const Move& lastMove,
 206                            const Move& move,
 207                            const StatePtr& state) {
 208   const Piece* sel1 = m_state->board()->get(m_board->selection);
 209
 210   if (move != Move()) {
 211     AnimationPtr animation = m_animator->back(move, state.get());
 212     //??? animation->setChainAbortions(false);
 213     m_view->animationManager()->enqueue(animation);
 214
 215     m_state->assign(state.get());
 216   }
 217   else
 218     warp(lastMove, state);
 219
 220   if (lastMove != Move())
 221     m_board->setTags("highlighting", lastMove.src(), lastMove.dst());
 222   else
 223     m_board->clearTags("highlighting");
 224
 225   const Piece* sel2 = m_state->board()->get(m_board->selection);
 226   if(!(sel1 != NULL && sel2 != NULL &&
 227        *sel1 != Piece() && *sel2 != Piece() && *sel1 == *sel2))
 228     m_board->cancelSelection();
 229   m_board->cancelPremove();
 230   m_view->updateTurn(state->turn()->index());
 231   m_board->onPositionChanged();
 232 }
 233
 234 void GraphicalSystem::warp(const Move& lastMove,
 235                            const StatePtr& state) {
 236
 237   const Piece* sel1 = m_state->board()->get(m_board->selection);
 238
 239   AnimationPtr animation = m_animator->warp(state.get());
 240   //??? animation->setChainAbortions(false);
 241   if (animation) {
 242     m_view->animationManager()->enqueue(animation);
 243   }
 244
 245   m_state->assign(state.get());
 246
 247   if (lastMove != Move())
 248     m_board->setTags("highlighting", lastMove.src(), lastMove.dst());
 249   else
 250     m_board->clearTags("highlighting");
 251
 252   const Piece* sel2 = m_state->board()->get(m_board->selection);
 253   if(!(sel1 != NULL && sel2 != NULL &&
 254        *sel1 != Piece() && *sel2 != Piece() && *sel1 == *sel2))
 255     m_board->cancelSelection();
 256   m_view->updateTurn(state->turn()->index());
 257   m_board->onPositionChanged();
 258 }
 259
 260 void GraphicalSystem::adjustSprite(const Point& p) {
 261   SpritePtr sprite = m_board->m_sprites[p].sprite();
 262   Q_ASSERT(sprite);
 263   QPoint destination = m_board->converter()->toReal(p);
 264   shared_ptr<Animation> animation(new MovementAnimation(sprite, destination));
 265   m_view->animationManager()->enqueue(animation);
 266 }
 267
 268 void GraphicalSystem::setTurn(const IColor* turn) {
 269   m_state->setTurn(turn);
 270   m_view->updateTurn(m_state->turn()->index());
 271 }
 272
 273 AnimationPtr GraphicalSystem::group(const QString&) const {
 274   return AnimationPtr(new AnimationGroup);
 275 }
 276
 277 AnimationPtr GraphicalSystem::appear(const NamedSprite& sprite,
 278                                      const QString& flags) const {
 279   return m_view->animationManager()->appear(sprite, flags);
 280 }
 281
 282 AnimationPtr GraphicalSystem::disappear(const NamedSprite& sprite,
 283                                         const QString& flags) const {
 284   return m_view->animationManager()->disappear(sprite, flags);
 285 }
 286
 287 AnimationPtr GraphicalSystem::move(const NamedSprite& sprite,
 288                                    const Point& destination,
 289                                    const QString& flags) const {
 290   QPoint real = converter()->toReal(destination);
 291   Point origin = converter()->toLogical(sprite.sprite()->pos() +
 292     Point(converter()->squareSize(), converter()->squareSize()) / 2);
 293   return m_view->animationManager()->move(sprite, real, origin != destination, flags);
 294 }
 295
 296 AnimationPtr GraphicalSystem::move(const NamedSprite& sprite,
 297                                    int pool, int destination,
 298                                    const QString& flags) const {
 299   QPoint real = indexConverter(pool)->toReal(destination);
 300   return m_view->animationManager()->move(sprite, real, true, flags);
 301 }
 302
 303 AnimationPtr GraphicalSystem::morph(const NamedSprite& sprite1,
 304                                     const NamedSprite& sprite2,
 305                                     const QString& flags) const {
 306   return m_view->animationManager()->morph(sprite1, sprite2, flags);
 307 }
 308
 309 Components* GraphicalSystem::components() const { return m_components; }