src/controllers/editposition.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 "editposition.h"
  12 #include "graphicalsystem.h"
  13 #include "entities/userentity.h"
  14 #include "piecefunction.h"
  15
  16 #if 0
  17 //BROKEN
  18 using namespace boost;
  19
  20 //BEGIN UndoHistory
  21
  22 UndoHistory::UndoHistory() {
  23   m_index = 0;
  24 }
  25
  26 void UndoHistory::add(const UndoAction& action) {
  27   m_history.erase(m_history.begin() + m_index,
  28                   m_history.end());
  29   m_history.push_back(action);
  30   m_index++;
  31 }
  32
  33 const UndoAction* UndoHistory::undo() {
  34   if (m_index <= 0) return 0;
  35
  36   m_index--;
  37   return &m_history[m_index];
  38 }
  39
  40 const UndoAction* UndoHistory::redo() {
  41   if (m_index >= m_history.size()) return 0;
  42
  43   UndoAction* res = &m_history[m_index];
  44   m_index++;
  45   return res;
  46 }
  47
  48 //END UndoHistory
  49
  50 class EditAction : public AbstractMove {
  51   typedef variant<NormalUserMove, DropUserMove> UserMove;
  52   UserMove m_move;
  53
  54   class ConvertToNormalUserMove : public static_visitor<NormalUserMove> {
  55   public:
  56     NormalUserMove operator()(const NormalUserMove& m) const {
  57       return m;
  58     }
  59
  60     NormalUserMove operator()(const DropUserMove& m) const {
  61       return NormalUserMove(Point::invalid(), m.m_to);
  62     }
  63   };
  64 public:
  65   EditAction(const UserMove& move)
  66   : m_move(move) { }
  67   virtual QString SAN(boost::shared_ptr<AbstractPosition>) const { return QString(); }
  68   virtual DecoratedMove toDecoratedMove(boost::shared_ptr<AbstractPosition>) const {
  69                                                                 return DecoratedMove(); }
  70   virtual QString toString(boost::shared_ptr<AbstractPosition>) const { return QString(); }
  71   virtual NormalUserMove toUserMove() const {
  72     return apply_visitor(ConvertToNormalUserMove(), m_move);
  73   }
  74   virtual AbstractPiece::Ptr pieceHint() const {
  75     if (const DropUserMove* move = get<DropUserMove>(&m_move))
  76       return move->m_piece;
  77     else
  78       return AbstractPiece::Ptr();
  79   }
  80   virtual bool equals(AbstractMove::Ptr /*other*/) const {
  81 //     EditAction* move = dynamic_cast<EditAction*>(other.get());
  82 //     return move && (m_move == move->m_move);
  83     // FIXME: the above does not compile
  84     return false;
  85   }
  86
  87   UserMove& move() { return m_move; }
  88 };
  89
  90 class EditPositionEntity : public UserEntity {
  91   struct EditPositionEntityInternal {
  92     shared_ptr<GraphicalInfo> m_graphical;
  93     VariantInfo* m_variant;
  94     EditPositionEntityInternal(const shared_ptr<GraphicalInfo>& graphical,
  95                                VariantInfo* variant)
  96     : m_graphical(graphical)
  97     , m_variant(variant) { }
  98   };
  99   EditPositionEntityInternal m_data;
 100   UndoHistory& m_undo_history;
 101
 102   class ExecuteMoveVisitor : public static_visitor<UndoAction> {
 103     EditPositionEntityInternal& m_data;
 104   public:
 105     ExecuteMoveVisitor(EditPositionEntityInternal& data)
 106     : m_data(data) { }
 107
 108     UndoAction operator()(const NormalUserMove& move) {
 109       if (move.to.valid()) {
 110         Element removedElement = m_data.m_graphical->getElement(move.to);
 111         m_data.m_graphical->setElement(
 112           move.to,
 113           m_data.m_graphical->getElement(move.from));
 114         m_data.m_graphical->adjustSprite(move.to);
 115         m_data.m_graphical->removeElement(move.from);
 116         return MoveAction(move.from, move.to, removedElement.piece());
 117       }
 118       else {
 119         Element removedElement = m_data.m_graphical->getElement(move.from);
 120         m_data.m_graphical->removeElement(move.from);
 121         return RemoveAction(move.from, removedElement.piece());
 122       }
 123     }
 124
 125     UndoAction operator()(const DropUserMove& move) {
 126       AbstractPiece::Ptr dropped = move.m_piece;
 127       m_data.m_graphical->setPiece(
 128         move.m_to,
 129         dropped,
 130         true);
 131       m_data.m_graphical->adjustSprite(move.m_to);
 132       return DropAction(move.m_to, dropped);
 133     }
 134   };
 135
 136   class UndoActionVisitor : public static_visitor<void> {
 137     EditPositionEntityInternal& m_data;
 138   public:
 139     UndoActionVisitor(EditPositionEntityInternal& data)
 140     : m_data(data) { }
 141
 142     void operator()(const DropAction& action) {
 143       m_data.m_graphical->removeElement(action.m_to);
 144     }
 145
 146     void operator()(const RemoveAction& action) {
 147       if (action.m_piece)
 148         m_data.m_graphical->setPiece(action.m_to, action.m_piece);
 149     }
 150
 151     void operator()(const MoveAction& action) {
 152       m_data.m_graphical->setElement(
 153         action.m_from,
 154         m_data.m_graphical->getElement(action.m_to));
 155       if (action.m_piece)
 156         m_data.m_graphical->setPiece(action.m_to, action.m_piece);
 157       else
 158         m_data.m_graphical->removeElement(action.m_to);
 159       m_data.m_graphical->adjustSprite(action.m_from);
 160     }
 161
 162     void operator()(const WarpAction& action) {
 163       kDebug() << "undo warp from:";
 164       kDebug() << action.m_from->fen(0, 0);
 165       kDebug() << "to";
 166       kDebug() << action.m_to->fen(0, 0);
 167       m_data.m_graphical->warp(AbstractMove::Ptr(), action.m_from);
 168     }
 169   };
 170
 171   class RedoActionVisitor : public static_visitor<void> {
 172     EditPositionEntityInternal& m_data;
 173   public:
 174     RedoActionVisitor(EditPositionEntityInternal& data)
 175     : m_data(data) { }
 176
 177     void operator()(const DropAction& action) {
 178       if (action.m_piece)
 179         m_data.m_graphical->setPiece(action.m_to, action.m_piece);
 180     }
 181
 182     void operator()(const RemoveAction& action) {
 183       m_data.m_graphical->removeElement(action.m_to);
 184     }
 185
 186     void operator()(const MoveAction& action) {
 187       m_data.m_graphical->setElement(
 188         action.m_to,
 189         m_data.m_graphical->getElement(action.m_from));
 190       m_data.m_graphical->removeElement(action.m_from);
 191       m_data.m_graphical->adjustSprite(action.m_to);
 192     }
 193
 194     void operator()(const WarpAction& action) {
 195       m_data.m_graphical->warp(AbstractMove::Ptr(), action.m_to);
 196     }
 197   };
 198 public:
 199   EditPositionEntity(VariantInfo* variant,
 200                      const shared_ptr<GraphicalInfo>& graphical,
 201                      UndoHistory& undo_history)
 202   : UserEntity(0)
 203   , m_data(graphical, variant)
 204   , m_undo_history(undo_history) { }
 205
 206   virtual QString save() const { return ""; }
 207   virtual void loadPGN(const PGN&) { }
 208
 209   virtual AbstractMove::Ptr testMove(const NormalUserMove& m) const {
 210     return AbstractMove::Ptr(new EditAction(m));
 211   }
 212
 213   virtual AbstractMove::Ptr testMove(const DropUserMove& m) const {
 214     return AbstractMove::Ptr(new EditAction(m));
 215   }
 216
 217   virtual bool testPremove(const NormalUserMove&) const { return false; }
 218   virtual bool testPremove(const DropUserMove&) const { return false; }
 219
 220   virtual void executeMove(AbstractMove::Ptr move) {
 221     EditAction* action = dynamic_cast<EditAction*>(move.get());
 222     if (action) {
 223       ExecuteMoveVisitor visitor(m_data);
 224       UndoAction undo_action = apply_visitor(visitor, action->move());
 225       m_undo_history.add(undo_action);
 226     }
 227   }
 228
 229   virtual void handleRightClick(const Point& p) const {
 230     Element removedElement = m_data.m_graphical->getElement(p);
 231     UndoAction action = RemoveAction(p, removedElement.piece());
 232     m_data.m_graphical->removeElement(p);
 233     m_undo_history.add(action);
 234   }
 235
 236   virtual void addPremove(const NormalUserMove&) { }
 237   virtual void addPremove(const DropUserMove&) { }
 238   virtual void cancelPremove() { }
 239
 240   virtual Action validTurn(const Point&) const { return Moving; }
 241   virtual Action validTurn(int) const { return Moving; }
 242   virtual bool movable(const Point&) const { return true; }
 243   virtual bool jump(const Index&) { return false; }
 244   virtual bool goTo(const Index&) { return false; }
 245   virtual bool gotoFirst() { return false; }
 246   virtual bool gotoLast() { return false; }
 247   virtual bool forward() { return false; }
 248   virtual bool back() { return false; }
 249
 250   virtual bool undo() {
 251     if (const UndoAction* action = m_undo_history.undo()) {
 252       UndoActionVisitor visitor(m_data);
 253       apply_visitor(visitor, *action);
 254       return true;
 255     }
 256     else return false;
 257   }
 258
 259   virtual bool redo() {
 260     if (const UndoAction* action = m_undo_history.redo()) {
 261       RedoActionVisitor visitor(m_data);
 262       apply_visitor(visitor, *action);
 263       return true;
 264     }
 265     else return false;
 266   }
 267
 268   virtual bool truncate() { return false; }
 269   virtual bool promoteVariation() { return false; }
 270
 271   virtual void notifyClockUpdate(int, int) { }
 272   virtual void notifyMove(AbstractMove::Ptr, AbstractPosition::Ptr) { }
 273   virtual void notifyBack() { }
 274   virtual void notifyForward() { }
 275   virtual void notifyGotoFirst() { }
 276   virtual void notifyGotoLast() { }
 277 };
 278
 279 class FillPool : public PieceFunction {
 280   shared_ptr<GraphicalInfo> m_graphical;
 281   VariantInfo* m_variant;
 282 public:
 283   FillPool(VariantInfo* variant, const shared_ptr<GraphicalInfo>& graphical)
 284   : m_graphical(graphical)
 285   , m_variant(variant) { }
 286
 287   virtual void operator()(int color, int type) {
 288     m_graphical->addToPool(
 289       m_variant->createPiece(color, type),
 290       1
 291     );
 292   }
 293 };
 294
 295 EditPositionController::EditPositionController(ChessTable* view, VariantInfo* variant)
 296 : Controller(view)
 297 , m_variant(variant) {
 298   m_graphical = shared_ptr<GraphicalInfo>(
 299     new GraphicalInfo(m_view, AbstractPosition::Ptr(), m_variant));
 300   m_entity = shared_ptr<EditPositionEntity>(
 301     new EditPositionEntity(m_variant, m_graphical, m_undo_history));
 302   m_graphical->setup(m_entity);
 303
 304   FillPool fill_pool(m_variant, m_graphical);
 305   m_variant->forallPieces(fill_pool);
 306 }
 307
 308 shared_ptr<UserEntity> EditPositionController::entity() const {
 309   return m_entity;
 310 }
 311
 312 bool EditPositionController::clearBoard() {
 313   AbstractPosition::Ptr position = m_variant->createPosition();
 314   m_undo_history.add(WarpAction(m_graphical->position()->clone(), position));
 315   m_graphical->warp(AbstractMove::Ptr(), position);
 316   return true;
 317 }
 318
 319 bool EditPositionController::setStartingPosition() {
 320   AbstractPosition::Ptr startingPosition = m_variant->createPosition();
 321   startingPosition->setup();
 322   kDebug() << "adding warp to undo history:";
 323   kDebug() << m_graphical->position()->fen(0, 0);
 324   kDebug() << startingPosition->fen(0, 0);
 325   m_undo_history.add(WarpAction(m_graphical->position()->clone(), startingPosition));
 326   m_graphical->warp(AbstractMove::Ptr(), startingPosition);
 327   return true;
 328 }
 329
 330 QString EditPositionController::fen() {
 331   return m_graphical->position()->fen(0,0);
 332 }
 333
 334 bool EditPositionController::setFEN(const QString& fen) {
 335   AbstractPosition::Ptr pos = m_variant->createPositionFromFEN(fen);
 336   if (pos) {
 337     kDebug() << "warping to fen " << fen;
 338     m_undo_history.add(WarpAction(m_graphical->position()->clone(), pos));
 339     m_graphical->warp(AbstractMove::Ptr(), pos);
 340     return true;
 341   }
 342   else {
 343     kDebug() << "invalid fen";
 344     return false;
 345   }
 346 }
 347
 348 void EditPositionController::setTurn(int turn) {
 349   m_graphical->setTurn(turn);
 350 }
 351
 352 AbstractPosition::Ptr EditPositionController::currentPosition() const {
 353   return m_graphical->position();
 354 }
 355 #endif