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/component.h>
  19 #include <core/namer.h>
  20 #include <core/state.h>
  21 #include <core/variant.h>
  22
  23 #include "chesstable.h"
  24 #include "chessboard.h"
  25 #include "clock.h"
  26 #include "piecepool.h"
  27 #include "pointconverter.h"
  28 #include "sprite.h"
  29 #include "animation.h"
  30 #include "pref_theme.h"
  31 #include "movelist_table.h"
  32 #include "mastersettings.h"
  33
  34 using namespace boost;
  35
  36 //BEGIN GraphicalSystem
  37
  38 GraphicalSystem::GraphicalSystem(ChessTable* view,
  39                              const StatePtr& startingPosition,
  40                              Variant* variant)
  41 : m_view(view)
  42 , m_variant(variant) {
  43   m_state = StatePtr(startingPosition->clone());
  44   Point s = m_state->board()->size();
  45   for(int i=0;i<s.x;i++)
  46   for(int j=0;j<s.y;j++)
  47     m_state->board()->set(Point(i,j), Piece());
  48
  49   m_board = view->board();
  50
  51   m_board->createGrid(m_state->board()->size(), m_state->board()->borderCoords());
  52   m_board->reset();
  53
  54   m_view->pool(0)->clear();
  55   m_view->pool(1)->clear();
  56
  57   m_namer = requestComponent<INamer>(variant, "namer");
  58   IAnimatorFactory* fact = requestComponent<IAnimatorFactory>(
  59     variant, "animator_factory");
  60   m_animator = fact->create(this, m_namer);
  61
  62   settings().onChange(this, "settingsChanged", "Loader::Theme");
  63   settingsChanged();
  64
  65   if (startingPosition)
  66     warp(Move(), startingPosition);
  67 }
  68
  69 GraphicalSystem::~GraphicalSystem() {
  70   delete m_animator;
  71 }
  72
  73 const PointConverter* GraphicalSystem::converter() const {
  74   return m_board->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_variant, "pieces");
  83   ThemeInfo sqtheme = PrefTheme::getBestTheme(m_variant, "squares");
  84   ThemeInfo figtheme = PrefTheme::getBestTheme(m_variant, "figurines");
  85   ThemeInfo ctrltheme = PrefTheme::getBestTheme(m_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_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(int pool, int index) {
 153   return m_view->pool(pool)->getSprite(index);
 154 }
 155
 156 void GraphicalSystem::removePoolSprite(int pool, int index) {
 157   m_view->pool(pool)->removeSprite(index);
 158 }
 159
 160 NamedSprite GraphicalSystem::takePoolSprite(int pool, int index) {
 161   return m_view->pool(pool)->takeSprite(index);
 162 }
 163
 164 NamedSprite GraphicalSystem::insertPoolPiece(int pool, int index, const Piece& piece) {
 165   PiecePool *pl = m_view->pool(pool);
 166   QString name = m_namer->name(piece);
 167   QPixmap px = pl->loadSprite(name);
 168
 169   NamedSprite s(name, SpritePtr(new Sprite(px, pl, QPoint())));
 170   pl->insertSprite(index, s);
 171   return s;
 172 }
 173
 174 std::pair<const IColor*, int> GraphicalSystem::droppedPoolPiece() {
 175   return std::pair<const IColor*, int>(m_board->m_dropped_pool, m_board->m_dropped_index);
 176 }
 177
 178 void GraphicalSystem::forward(const Move& move,
 179                               const StatePtr& pos,
 180   const SpritePtr& /*movingSprite*/) {
 181   Piece sel1 = m_state->board()->get(m_board->selection);
 182
 183   if (move != Move()) {
 184     AnimationPtr animation = m_animator->forward(move, pos.get());
 185     m_board->enqueue(animation);
 186     m_board->setTags("highlighting", move.src(), move.dst());
 187
 188     m_state->assign(pos.get());
 189   }
 190   else
 191     warp(Move(), pos);
 192
 193   Piece sel2 = m_state->board()->get(m_board->selection);
 194   if(!(sel1 != Piece() && sel2 != Piece() && sel1 == sel2))
 195     m_board->cancelSelection();
 196
 197   m_board->cancelPremove();
 198   m_view->updateTurn(pos->turn()->index());
 199   m_board->onPositionChanged();
 200 }
 201
 202 void GraphicalSystem::back(const Move& lastMove,
 203                            const Move& move,
 204                            const StatePtr& state) {
 205   Piece sel1 = m_state->board()->get(m_board->selection);
 206
 207   if (move != Move()) {
 208     AnimationPtr animation = m_animator->back(move, state.get());
 209     //??? animation->setChainAbortions(false);
 210     m_board->enqueue(animation);
 211
 212     m_state->assign(state.get());
 213   }
 214   else
 215     warp(lastMove, state);
 216
 217   if (lastMove != Move())
 218     m_board->setTags("highlighting", lastMove.src(), lastMove.dst());
 219   else
 220     m_board->clearTags("highlighting");
 221
 222   Piece sel2 = m_state->board()->get(m_board->selection);
 223   if(!(sel1 != Piece() && sel2 != Piece() && sel1 == sel2))
 224     m_board->cancelSelection();
 225   m_board->cancelPremove();
 226   m_view->updateTurn(state->turn()->index());
 227   m_board->onPositionChanged();
 228 }
 229
 230 void GraphicalSystem::warp(const Move& lastMove,
 231                            const StatePtr& state) {
 232
 233   Piece sel1 = m_state->board()->get(m_board->selection);
 234
 235   AnimationPtr animation = m_animator->warp(state.get());
 236   //??? animation->setChainAbortions(false);
 237   if (animation) {
 238     m_board->enqueue(animation);
 239   }
 240
 241   m_state->assign(state.get());
 242
 243   if (lastMove != Move())
 244     m_board->setTags("highlighting", lastMove.src(), lastMove.dst());
 245   else
 246     m_board->clearTags("highlighting");
 247
 248   Piece sel2 = m_state->board()->get(m_board->selection);
 249   if(!(sel1 != Piece() && sel2 != Piece() && sel1 == sel2))
 250     m_board->cancelSelection();
 251   m_view->updateTurn(state->turn()->index());
 252   m_board->onPositionChanged();
 253 }
 254
 255 void GraphicalSystem::adjustSprite(const Point& p) {
 256   SpritePtr sprite = m_board->m_sprites[p].sprite();
 257   Q_ASSERT(sprite);
 258   QPoint destination = m_board->converter()->toReal(p);
 259   shared_ptr<Animation> animation(new MovementAnimation(sprite, destination));
 260   m_board->enqueue(animation);
 261 }
 262
 263 void GraphicalSystem::setTurn(const IColor* turn) {
 264   m_state->setTurn(turn);
 265   m_view->updateTurn(m_state->turn()->index());
 266 }
 267
 268 AnimationPtr GraphicalSystem::group(const QString&) const {
 269   return AnimationPtr(new AnimationGroup);
 270 }
 271
 272 AnimationPtr GraphicalSystem::appear(const NamedSprite& sprite,
 273                                      const QString& flags) const {
 274   if (m_view->animationSettings().fading &&
 275       flags != "instant")
 276     return AnimationPtr(new FadeAnimation(sprite.sprite(), 0, 255));
 277
 278   return AnimationPtr(new DropAnimation(sprite.sprite()));
 279 }
 280
 281 AnimationPtr GraphicalSystem::disappear(const NamedSprite& sprite,
 282                                         const QString& flags) const {
 283   if (m_view->animationSettings().explode &&
 284       flags == "destroy")
 285     return AnimationPtr(new ExplodeAnimation(sprite.sprite(), Random::instance()));
 286
 287   if (m_view->animationSettings().fading &&
 288       flags != "instant")
 289     return AnimationPtr(new FadeAnimation(sprite.sprite(), 255, 0));
 290
 291   return AnimationPtr(new CaptureAnimation(sprite.sprite()));
 292 }
 293
 294 AnimationPtr GraphicalSystem::move(const NamedSprite& sprite,
 295                                    const Point& destination,
 296                                    const QString& flags) const {
 297   QPoint real = converter()->toReal(destination);
 298   QStringList flagList = flags.split(" ");
 299   bool rotate = m_view->animationSettings().transform && flagList.contains("rotating");
 300
 301   if (m_view->animationSettings().movement &&
 302       !flagList.contains("instant")) {
 303     Point origin = converter()->toLogical(sprite.sprite()->pos() +
 304       Point(converter()->squareSize(), converter()->squareSize()) / 2);
 305     if (flagList.contains("lshaped") && origin != destination) {
 306       return AnimationPtr(new KnightMovementAnimation(sprite.sprite(), real, rotate));
 307     }
 308     else
 309       return AnimationPtr(new MovementAnimation(sprite.sprite(), real, rotate));
 310   }
 311
 312   return AnimationPtr(new InstantAnimation(sprite.sprite(), real));
 313 }
 314
 315 AnimationPtr GraphicalSystem::move(const NamedSprite&,
 316                                    int,
 317                                    const QString&) const {
 318   // TODO: implement this function as soon GraphicalSystem has access
 319   // to an IndexConverter instance
 320   return AnimationPtr();
 321 }
 322
 323 AnimationPtr GraphicalSystem::morph(const NamedSprite& sprite1,
 324                                     const NamedSprite& sprite2,
 325                                     const QString& flags) const {
 326   if (m_view->animationSettings().fading &&
 327       flags != "instant")
 328     return AnimationPtr(new CrossFadingAnimation(sprite1.sprite(), sprite2.sprite()));
 329
 330   return AnimationPtr(new PromotionAnimation(sprite1.sprite(), sprite2.sprite()));
 331 }
 332
 333 Variant* GraphicalSystem::variant() { return m_variant; }