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   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   Piece sel2 = m_state->board()->get(m_board->selection);
 196   if(!(sel1 != Piece() && sel2 != Piece() && sel1 == sel2))
 197     m_board->cancelSelection();
 198
 199   m_board->cancelPremove();
 200   m_view->updateTurn(pos->turn()->index());
 201   m_board->onPositionChanged();
 202 }
 203
 204 void GraphicalSystem::back(const Move& lastMove,
 205                            const Move& move,
 206                            const StatePtr& state) {
 207   Piece sel1 = m_state->board()->get(m_board->selection);
 208
 209   if (move != Move()) {
 210     AnimationPtr animation = m_animator->back(move, state.get());
 211     //??? animation->setChainAbortions(false);
 212     m_view->animationManager()->enqueue(animation);
 213
 214     m_state->assign(state.get());
 215   }
 216   else
 217     warp(lastMove, state);
 218
 219   if (lastMove != Move())
 220     m_board->setTags("highlighting", lastMove.src(), lastMove.dst());
 221   else
 222     m_board->clearTags("highlighting");
 223
 224   Piece sel2 = m_state->board()->get(m_board->selection);
 225   if(!(sel1 != Piece() && sel2 != Piece() && sel1 == sel2))
 226     m_board->cancelSelection();
 227   m_board->cancelPremove();
 228   m_view->updateTurn(state->turn()->index());
 229   m_board->onPositionChanged();
 230 }
 231
 232 void GraphicalSystem::warp(const Move& lastMove,
 233                            const StatePtr& state) {
 234
 235   Piece sel1 = m_state->board()->get(m_board->selection);
 236
 237   AnimationPtr animation = m_animator->warp(state.get());
 238   //??? animation->setChainAbortions(false);
 239   if (animation) {
 240     m_view->animationManager()->enqueue(animation);
 241   }
 242
 243   m_state->assign(state.get());
 244
 245   if (lastMove != Move())
 246     m_board->setTags("highlighting", lastMove.src(), lastMove.dst());
 247   else
 248     m_board->clearTags("highlighting");
 249
 250   Piece sel2 = m_state->board()->get(m_board->selection);
 251   if(!(sel1 != Piece() && sel2 != Piece() && sel1 == sel2))
 252     m_board->cancelSelection();
 253   m_view->updateTurn(state->turn()->index());
 254   m_board->onPositionChanged();
 255 }
 256
 257 void GraphicalSystem::adjustSprite(const Point& p) {
 258   SpritePtr sprite = m_board->m_sprites[p].sprite();
 259   Q_ASSERT(sprite);
 260   QPoint destination = m_board->converter()->toReal(p);
 261   shared_ptr<Animation> animation(new MovementAnimation(sprite, destination));
 262   m_view->animationManager()->enqueue(animation);
 263 }
 264
 265 void GraphicalSystem::setTurn(const IColor* turn) {
 266   m_state->setTurn(turn);
 267   m_view->updateTurn(m_state->turn()->index());
 268 }
 269
 270 AnimationPtr GraphicalSystem::group(const QString&) const {
 271   return AnimationPtr(new AnimationGroup);
 272 }
 273
 274 AnimationPtr GraphicalSystem::appear(const NamedSprite& sprite,
 275                                      const QString& flags) const {
 276   return m_view->animationManager()->appear(sprite, flags);
 277 }
 278
 279 AnimationPtr GraphicalSystem::disappear(const NamedSprite& sprite,
 280                                         const QString& flags) const {
 281   return m_view->animationManager()->disappear(sprite, flags);
 282 }
 283
 284 AnimationPtr GraphicalSystem::move(const NamedSprite& sprite,
 285                                    const Point& destination,
 286                                    const QString& flags) const {
 287   QPoint real = converter()->toReal(destination);
 288   Point origin = converter()->toLogical(sprite.sprite()->pos() +
 289     Point(converter()->squareSize(), converter()->squareSize()) / 2);
 290   return m_view->animationManager()->move(sprite, real, origin != destination, flags);
 291 }
 292
 293 AnimationPtr GraphicalSystem::move(const NamedSprite& sprite,
 294                                    int pool, int destination,
 295                                    const QString& flags) const {
 296   QPoint real = indexConverter(pool)->toReal(destination);
 297   return m_view->animationManager()->move(sprite, real, true, flags);
 298 }
 299
 300 AnimationPtr GraphicalSystem::morph(const NamedSprite& sprite1,
 301                                     const NamedSprite& sprite2,
 302                                     const QString& flags) const {
 303   return m_view->animationManager()->morph(sprite1, sprite2, flags);
 304 }
 305
 306 Components* GraphicalSystem::components() const { return m_components; }