src/hlvariant/animator.h

   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 #ifndef HLVARIANT__ANIMATOR_H
  12 #define HLVARIANT__ANIMATOR_H
  13
  14 #include <core/namedsprite.h>
  15 #include "animation.h"
  16 #include "variantdata.h"
  17 #include "common.h"
  18
  19 class NamedSprite;
  20 class Point;
  21 class AnimationFactory;
  22
  23 namespace HLVariant {
  24
  25 /**
  26   * A generic animator.
  27   * Can be used as a base class for other specialized animators.
  28   */
  29 template <typename _Variant>
  30 class BaseAnimator {
  31 public:
  32   typedef _Variant Variant;
  33 protected:
  34   typedef typename UnwrappedGraphicalAPIPtr<Variant>::type API;
  35   typedef typename VariantData<Variant>::GameState GameState;
  36   typedef typename VariantData<Variant>::Move Move;
  37   typedef typename VariantData<Variant>::Piece Piece;
  38   API m_cinterface;
  39 public:
  40   BaseAnimator(API cinterface)
  41     : m_cinterface(cinterface) { }
  42   virtual ~BaseAnimator() { }
  43
  44   virtual AnimationGroupPtr warp(const GameState& final);
  45   virtual AnimationGroupPtr forward(const GameState& final, const Move& move);
  46   virtual AnimationGroupPtr back(const GameState& final, const Move& move);
  47 };
  48
  49
  50 template <typename _Variant>
  51 class SimpleAnimator : BaseAnimator<_Variant> {
  52 public:
  53   typedef _Variant Variant;
  54 private:
  55   typedef BaseAnimator<Variant> Base;
  56 protected:
  57   typedef typename Base::API API;
  58   typedef typename Base::GameState GameState;
  59   typedef typename Base::Move Move;
  60   typedef typename Base::Piece Piece;
  61
  62   using Base::m_cinterface;
  63
  64   virtual SchemePtr movement(const NamedSprite& sprite, const Point& from, const Point& to);
  65 public:
  66   SimpleAnimator(API cinterface)
  67   : Base(cinterface) { }
  68
  69   virtual AnimationGroupPtr warp(const GameState& final);
  70   virtual AnimationGroupPtr forward(const GameState& final, const Move& move);
  71   virtual AnimationGroupPtr back(const GameState& final, const Move& move);
  72 };
  73
  74 // IMPLEMENTATION
  75
  76 template <typename Variant>
  77 AnimationGroupPtr BaseAnimator<Variant>::warp(const GameState& final) {
  78   const GameState* current = m_cinterface->position();
  79   AnimationFactory res(m_cinterface->inner());
  80
  81   for (int i = 0; i < current->board().size().x; i++) {
  82     for (int j = 0; j < current->board().size().y; j++) {
  83       Point p(i, j);
  84
  85       NamedSprite sprite = m_cinterface->getSprite(p);
  86       Piece piece = final.board().get(p);
  87
  88       if (!sprite && piece != Piece()) {
  89         res.addPreAnimation(Animate::appear(m_cinterface->setPiece(p, piece, false)),
  90                             Animate::Instant);
  91       }
  92
  93       else if (sprite && piece == Piece()) {
  94         m_cinterface->takeSprite(p);
  95         res.addPreAnimation(Animate::disappear(sprite), Animate::Instant);
  96       }
  97
  98       // sprite and piece differ
  99       else if (sprite && piece != Piece() && piece.name() != sprite.name()) {
 100         m_cinterface->takeSprite(p);
 101         res.addPreAnimation(Animate::morph(sprite, m_cinterface->setPiece(p, piece, false)),
 102           Animate::Instant);
 103       }
 104     }
 105   }
 106
 107   return res;
 108 }
 109
 110 template <typename Variant>
 111 AnimationGroupPtr BaseAnimator<Variant>::forward(const GameState& final, const Move&) {
 112   return warp(final);
 113 }
 114
 115
 116 template <typename Variant>
 117 AnimationGroupPtr BaseAnimator<Variant>::back(const GameState& final, const Move&) {
 118   return warp(final);
 119 }
 120
 121 template <typename Variant>
 122 AnimationGroupPtr SimpleAnimator<Variant>::warp(const GameState& final) {
 123   AnimationFactory res(m_cinterface->inner());
 124
 125   res.setGroup(Base::warp(final));
 126
 127   return res;
 128 }
 129
 130 template <typename Variant>
 131 SchemePtr SimpleAnimator<Variant>::movement(const NamedSprite& sprite, const Point& from, const Point& to) {
 132   bool knight = m_cinterface->position()->board().get(from).type() == Piece::KNIGHT;
 133   int mtype = knight
 134     ? Animate::move::LShaped | Animate::move::Rotating
 135     : Animate::move::Straight;
 136   return SchemePtr(new Animate::move(sprite, to, mtype));
 137 }
 138
 139 template <typename Variant>
 140 AnimationGroupPtr SimpleAnimator<Variant>::forward(const GameState& final, const Move& move) {
 141   AnimationFactory res(m_cinterface->inner());
 142
 143   NamedSprite piece = m_cinterface->takeSprite(move.from());
 144   NamedSprite captured = m_cinterface->takeSprite(move.captureSquare());
 145   m_cinterface->setSprite(move.to(), piece);
 146
 147   if (piece)
 148     res.addPreAnimation(*movement(piece, move.from(), move.to()));
 149   else
 150     ERROR("Bug!!!");
 151
 152   if (captured)
 153     res.addPostAnimation(Animate::destroy(captured));
 154
 155   if (move.promoteTo() != -1) {
 156     Piece promoted = final.board().get(move.to());
 157
 158     if (promoted != Piece()) {
 159       NamedSprite old_sprite = m_cinterface->getSprite(move.to());
 160       NamedSprite new_sprite = m_cinterface->setPiece(move.to(), promoted, /*false,*/ false);
 161
 162       res.addPostAnimation(Animate::morph(old_sprite, new_sprite));
 163     }
 164     else
 165       ERROR("Bug!!!");
 166   }
 167   else if (move.kingSideCastling()) {
 168     Point rookSquare = move.to() + Point(1,0);
 169     Point rookDestination = move.from() + Point(1,0);
 170
 171     NamedSprite rook = m_cinterface->takeSprite(rookSquare);
 172     m_cinterface->setSprite(rookDestination, rook);
 173     res.addPreAnimation(Animate::move(rook, rookDestination));
 174   }
 175   else if (move.queenSideCastling()) {
 176     Point rookSquare = move.to() + Point(-2,0);
 177     Point rookDestination = move.from() + Point(-1,0);
 178
 179     NamedSprite rook = m_cinterface->takeSprite(rookSquare);
 180     m_cinterface->setSprite(rookDestination, rook);
 181     res.addPreAnimation(Animate::move(rook, rookDestination));
 182   }
 183
 184   res.group()->addPostAnimation(warp(final));
 185   return res;
 186 }
 187
 188 template <typename Variant>
 189 AnimationGroupPtr SimpleAnimator<Variant>::back(const GameState& final, const Move& move) {
 190   AnimationFactory res(m_cinterface->inner());
 191
 192   NamedSprite piece = m_cinterface->takeSprite(move.to());
 193   NamedSprite captured;
 194   Piece captured_piece = final.board().get(move.captureSquare());
 195   if (captured_piece != Piece()) {
 196     captured = m_cinterface->setPiece(move.captureSquare(), captured_piece, false);
 197     res.addPreAnimation(Animate::appear(captured));
 198   }
 199
 200   if (!piece) {
 201     piece = m_cinterface->createPiece(move.to(), final.board().get(move.from()), false);
 202     res.addPreAnimation(Animate::appear(piece));
 203   }
 204
 205   m_cinterface->setSprite(move.from(), piece);
 206
 207   if (move.promoteTo() != -1) {
 208     Piece pawn_piece = final.board().get(move.from());
 209     if (pawn_piece != Piece()) {
 210       NamedSprite pawn = m_cinterface->createPiece(move.to(), pawn_piece, false);
 211       res.addPreAnimation(Animate::morph(piece, pawn));
 212
 213       // replace piece with pawn
 214       m_cinterface->setSprite(move.from(), pawn);
 215       piece = pawn;
 216     }
 217   }
 218   else if (move.kingSideCastling()) {
 219     Point rookSquare = move.to() + Point(1,0);
 220     Point rookDestination = move.from() + Point(1,0);
 221
 222     NamedSprite rook = m_cinterface->takeSprite(rookDestination);
 223     m_cinterface->setSprite(rookSquare, rook);
 224
 225     res.addPreAnimation(Animate::move(rook, rookSquare));
 226   }
 227   else if (move.queenSideCastling()) {
 228     Point rookSquare = move.to() + Point(-2,0);
 229     Point rookDestination = move.from() + Point(-1,0);
 230
 231     NamedSprite rook = m_cinterface->takeSprite(rookDestination);
 232     m_cinterface->setSprite(rookSquare, rook);
 233
 234     res.addPreAnimation(Animate::move(rook, rookSquare));
 235   }
 236
 237   res.addPreAnimation(*movement(piece, move.to(), move.from()));
 238   res.group()->addPostAnimation(warp(final));
 239
 240   return res;
 241
 242 }
 243
 244 }
 245
 246 #endif // HLVARIANT__ANIMATOR_H