src/tagua_legacy.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 "tagua_legacy.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/state.h>
  20 #include <core/statefactory.h>
  21 #include <core/type.h>
  22 #include <core/validator.h>
  23 #include <core/variant.h>
  24 #include "graphicalsystem.h"
  25
  26 VariantAdaptor::VariantAdaptor(Variant* variant)
  27 : m_variant(variant) {
  28   m_state_factory = dynamic_cast<IStateFactory*>(
  29     m_variant->repository()->getComponent("state_factory"));
  30   m_validator = dynamic_cast<IValidator*>(
  31     m_variant->repository()->getComponent("validator"));
  32 }
  33
  34 VariantInfo* VariantAdaptor::createVariant() const {
  35   return const_cast<VariantAdaptor*>(this);
  36 }
  37
  38 QString VariantAdaptor::name() const {
  39   return m_variant->name();
  40 }
  41
  42 QString VariantAdaptor::themeProxy() const {
  43   return m_variant->proxy();
  44 }
  45
  46
  47 bool VariantAdaptor::hidden() const {
  48   return m_variant->hidden();
  49 }
  50
  51 PositionPtr VariantAdaptor::createPosition() {
  52   return PositionPtr(new StateAdaptor(m_state_factory->createState(), m_validator));
  53 }
  54
  55 PositionPtr VariantAdaptor::createCustomPosition(const OptList& l) {
  56   return createPosition();
  57 }
  58
  59 void VariantAdaptor::forallPieces(class PieceFunction& f) {
  60   // this function is never used
  61 }
  62
  63 int VariantAdaptor::moveListLayout() const {
  64   return 0; // FIXME
  65 }
  66
  67 AnimatorPtr VariantAdaptor::createAnimator(GraphicalAPI* api) {
  68   GraphicalSystem* s = dynamic_cast<GraphicalSystem*>(api);
  69   const INamer* namer = s->namer();
  70   IAnimatorFactory* fact = dynamic_cast<IAnimatorFactory*>(
  71     m_variant->repository()->getComponent("animator_factory"));
  72   return AnimatorPtr(new AnimatorAdaptor(fact->create(s, namer)));
  73 }
  74
  75 MovePtr VariantAdaptor::createNormalMove(const NormalUserMove& m) {
  76   return MovePtr(new MoveAdaptor(Move(m.from, m.to, 0))); // FIXME promotion
  77 }
  78
  79 MovePtr VariantAdaptor::createDropMove(const DropUserMove& m) {
  80   return MovePtr(new MoveAdaptor(Move(reinterpret_cast<IColor*>(m.pool),
  81                        m.piece_index,
  82                        m.to)));
  83 }
  84
  85 MovePtr VariantAdaptor::getVerboseMove(int turn, const class VerboseNotation&) const {
  86   return MovePtr(); // FIXME
  87 }
  88
  89 bool VariantAdaptor::simpleMoves() {
  90   return false;
  91 }
  92
  93 OptList VariantAdaptor::positionOptions() const {
  94   return OptList();
  95 }
  96
  97 ICSAPIPtr VariantAdaptor::icsAPI() const {
  98   return ICSAPIPtr(); // FIXME
  99 }
 100
 101 ActionCollection* VariantAdaptor::actions() {
 102   return 0;
 103 }
 104
 105 void VariantAdaptor::setupMove(NormalUserMove& m) const { }
 106
 107 Variant* VariantAdaptor::variant() { return m_variant; }
 108
 109
 110 MoveAdaptor::MoveAdaptor(const Move& move)
 111 : m_move(move) { }
 112
 113 QString MoveAdaptor::toString(const QString& rep, const PositionPtr& ref) const {
 114   return "";
 115 }
 116
 117 NormalUserMove MoveAdaptor::toUserMove() const {
 118   return NormalUserMove(m_move.src(), m_move.dst());
 119 }
 120
 121 bool MoveAdaptor::equals(const MovePtr& other_) const {
 122   MoveAdaptor* other = dynamic_cast<MoveAdaptor*>(other_.get());
 123   if (!other) return false;
 124   return m_move == other->move();
 125 }
 126
 127
 128 StateAdaptor::StateAdaptor(IState* state, IValidator* validator)
 129 : m_state(state)
 130 , m_validator(validator) { }
 131
 132
 133
 134 Point StateAdaptor::size() const {
 135   return m_state->board()->size();
 136 }
 137
 138 QStringList StateAdaptor::borderCoords() const {
 139   QStringList retv;
 140   Point p = size();
 141   for (int i = 0; i < 8; i++)
 142     retv << Point(i, 0).col();
 143   for (int i = 1; i <= 8; i++)
 144     retv << QString::number(i);
 145   return retv + retv;
 146 }
 147
 148 void StateAdaptor::setup() {
 149   m_state->setup();
 150 }
 151
 152 PiecePtr StateAdaptor::get(const Point& p) const {
 153 //   m_state->board()->get(p);
 154   return PiecePtr(); // FIXME
 155 }
 156
 157 void StateAdaptor::set(const Point& p, const PiecePtr& piece) {
 158
 159 //   m_state->board()->set(p, piece);
 160   // FIXME
 161 }
 162
 163 PoolPtr StateAdaptor::pool(int player) {
 164   return PoolPtr(); // FIXME
 165 }
 166
 167 void StateAdaptor::copyPoolFrom(const PositionPtr& pos) {
 168 }
 169
 170 InteractionType StateAdaptor::movable(const TurnPolicy::Collection& test, const Point& p) const {
 171   return Moving; // FIXME
 172 }
 173
 174 InteractionType StateAdaptor::droppable(const TurnPolicy::Collection& test, int) const {
 175   return Moving; // FIXME
 176 }
 177
 178 int StateAdaptor::turn() const {
 179   return reinterpret_cast<int>(m_state->turn());
 180 }
 181
 182 void StateAdaptor::setTurn(int) {
 183   // FIXME
 184 }
 185
 186 int StateAdaptor::previousTurn() const {
 187   return turn(); // FIXME
 188 }
 189
 190 void StateAdaptor::switchTurn() {
 191   m_state->advanceTurn();
 192 }
 193
 194 bool StateAdaptor::testMove(const MovePtr& m) const {
 195   MoveAdaptor* move = dynamic_cast<MoveAdaptor*>(m.get());
 196   if (!move) return false;
 197   return m_validator->legal(m_state, move->move());
 198 }
 199
 200 void StateAdaptor::move(const MovePtr& m) {
 201   MoveAdaptor* move = dynamic_cast<MoveAdaptor*>(m.get());
 202   if (move) {
 203     m_state->move(move->move());
 204   }
 205 }
 206
 207 PositionPtr StateAdaptor::clone() const {
 208   return PositionPtr(new StateAdaptor(m_state->clone(), m_validator));
 209 }
 210
 211 void StateAdaptor::copyFrom(const PositionPtr&) {
 212   // FIXME
 213 }
 214
 215 bool StateAdaptor::equals(const PositionPtr& p) const {
 216   IState* state = dynamic_cast<IState*>(p.get());
 217   if (!state) return false;
 218   return m_state->equals(state);
 219 }
 220
 221 MovePtr StateAdaptor::getMove(const QString&) const {
 222   return MovePtr(); // FIXME
 223 }
 224
 225 QString StateAdaptor::state() const {
 226   return "playing"; // FIXME
 227 }
 228
 229 PiecePtr StateAdaptor::moveHint(const MovePtr&) const {
 230   return PiecePtr(); // FIXME
 231 }
 232
 233 QString StateAdaptor::variant() const {
 234   return ""; // FIXME
 235 }
 236
 237 void StateAdaptor::dump() const {
 238   // FIXME
 239 }
 240
 241 IState* StateAdaptor::state() {
 242   return m_state;
 243 }
 244
 245
 246 PieceAdaptor::PieceAdaptor(const Piece& piece)
 247 : m_piece(piece) { }
 248
 249 bool PieceAdaptor::equals(const PiecePtr& other_) const {
 250   PieceAdaptor* other = dynamic_cast<PieceAdaptor*>(other_.get());
 251   if (!other) return false;
 252   return other->m_piece == m_piece;
 253 }
 254
 255 QString PieceAdaptor::name() const {
 256   return m_piece.color()->name() + "_" + m_piece.type()->name();
 257   // FIXME use the correct component to compose piece name
 258 }
 259
 260 PiecePtr PieceAdaptor::clone() const {
 261   return PiecePtr(new PieceAdaptor(m_piece));
 262 }
 263
 264 AnimatorAdaptor::AnimatorAdaptor(IAnimator* animator)
 265 : m_animator(animator) { }
 266
 267 AnimationPtr AnimatorAdaptor::warp(const PositionPtr& pos) {
 268   StateAdaptor* state = dynamic_cast<StateAdaptor*>(pos.get());
 269   return m_animator->warp(state->state());
 270 }
 271
 272 AnimationPtr AnimatorAdaptor::forward(const PositionPtr& pos, const MovePtr& _move) {
 273   StateAdaptor* state = dynamic_cast<StateAdaptor*>(pos.get());
 274   MoveAdaptor* move = dynamic_cast<MoveAdaptor*>(_move.get());
 275   return m_animator->forward(move->move(), state->state());
 276 }
 277
 278 AnimationPtr AnimatorAdaptor::back(const PositionPtr& pos, const MovePtr& _move) {
 279   StateAdaptor* state = dynamic_cast<StateAdaptor*>(pos.get());
 280   MoveAdaptor* move = dynamic_cast<MoveAdaptor*>(_move.get());
 281   return m_animator->back(move->move(), state->state());
 282 }