src/piecepool.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   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
  12 #include "board.h"
  13 #include "piecepool.h"
  14
  15
  16 PiecePool::PiecePool(int num, Board* b, const AnimationSettings& animSettings, KGameCanvasAbstract* parent)
  17 : ClickableCanvas(parent)
  18 , m_pool_num(num)
  19 , m_board(b)
  20 , m_flipped(false)
  21 , m_square_size(0)
  22 , m_width(1)
  23 , m_dragged_index(-1)
  24 , m_anim_settings(animSettings) {
  25   m_main_animation = new MainAnimation( 1.0 );
  26   setGridWidth(1);
  27 }
  28
  29
  30 PiecePool::~PiecePool() {
  31   delete m_main_animation;
  32 }
  33
  34
  35 QPoint PiecePool::toReal(int i) const {
  36   int x = i % m_width;
  37   int y = i / m_width;
  38
  39   if (y & 1)
  40     x = m_width - 1 - x;
  41
  42   if (m_flipped)
  43     y = -1 - y;
  44
  45   return QPoint(x, y) * m_square_size;
  46 }
  47
  48
  49 int PiecePool::toLogical(const QPoint& p) const {
  50   int x = p.x() / m_square_size;
  51   int y = p.y() / m_square_size;
  52
  53   if (x<0 || x >= m_width)
  54     return -1;
  55
  56   if (m_flipped)
  57     y = -y;
  58
  59   if (y & 1)
  60     x = m_width - 1 - x;
  61
  62   int retv = y * m_width + x;
  63   if (retv < 0 || static_cast<unsigned int>(retv) >= m_sprites.size())
  64     return -1;
  65
  66   return retv;
  67 }
  68
  69
  70 void PiecePool::settingsChanged() {
  71
  72 }
  73
  74
  75 void PiecePool::setGridWidth(int w) {
  76   m_width = w > 0 ? w : 1;
  77 }
  78
  79 QRect PiecePool::boardRect() {
  80   Q_ASSERT(m_width > 0);
  81   int height = (m_sprites.size() + m_width - 1) / m_width;
  82   QSize sz(m_width, m_flipped ? -height : height);
  83   return QRect(pos(), sz * m_square_size);
  84 }
  85
  86
  87 int PiecePool::fill() {
  88   return m_sprites.size();
  89 }
  90
  91
  92 void PiecePool::clear() {
  93   m_sprites.clear();
  94 }
  95
  96 void PiecePool::animate(const Animate::Pool::Scheme& scheme, Animate::AnimationType type) {
  97   m_main_animation->addAnimation(scheme.run(m_anim_settings, this, type));
  98 }
  99
 100 void PiecePool::insertSprite(int index, const NamedSprite& nsprite) {
 101   if(m_dragged && index > m_dragged_index)
 102     index--;
 103
 104   if(index < 0 || index > fill() ) {
 105     ERROR("invalid index " << index);
 106     return;
 107   }
 108
 109   m_sprites.resize(m_sprites.size()+1);
 110
 111   for(int i = m_sprites.size()-1; i > index; i--) {
 112 //     double speed = (1.0 + 1.0 / (i - index + 1)) * 0.4;
 113     m_sprites[i] = m_sprites[i-1];
 114     animate(Animate::Pool::move(m_sprites[i], i));
 115   }
 116
 117   m_sprites[index] = nsprite;
 118   animate(Animate::Pool::move(m_sprites[index], index), Animate::Instant);
 119   animate(Animate::Pool::appear(m_sprites[index]));
 120 }
 121
 122
 123 NamedSprite PiecePool::getSprite(int index) {
 124   if(m_dragged && index == m_dragged_index)
 125     return m_dragged;
 126
 127   if(m_dragged && index > m_dragged_index)
 128     index--;
 129
 130   if(index < 0 || index >= (int)m_sprites.size() ) {
 131     ERROR("invalid index " << index);
 132     return NamedSprite();
 133   }
 134
 135   return m_sprites[index];
 136 }
 137
 138
 139 void PiecePool::removeSprite(int index) {
 140   if(m_dragged && index == m_dragged_index) {
 141     m_dragged = NamedSprite();
 142     m_dragged_index = -1;
 143     return;
 144   }
 145
 146   if(m_dragged && index > m_dragged_index)
 147     index--;
 148
 149   if(index < 0 || index >= (int)m_sprites.size() ) {
 150     ERROR("invalid index " << index);
 151     return;
 152   }
 153
 154   takeSpriteAt(index);
 155 }
 156
 157
 158 NamedSprite PiecePool::takeSprite(int index) {
 159   if(m_dragged && index == m_dragged_index) {
 160     NamedSprite retv = m_dragged;
 161     m_dragged = NamedSprite();
 162     m_dragged_index = -1;
 163
 164     return retv;
 165   }
 166
 167   ERROR("Only the sprite being dropped can be taken from the pool.");
 168   return NamedSprite();
 169 #if 0
 170   if(m_dragged && index > m_dragged_index)
 171     index--;
 172
 173   if(index < 0 || index >= (int)m_sprites.size() ) {
 174     ERROR("invalid index " << index);
 175     return NamedSprite();
 176   }
 177
 178   return takeSpriteAt(index);
 179 #endif
 180 }
 181
 182
 183 NamedSprite PiecePool::takeSpriteAt(int index) {
 184   if(index < 0 || index >= (int)m_sprites.size() ) {
 185     ERROR("invalid index " << index);
 186     return NamedSprite();
 187   }
 188
 189   NamedSprite retv = m_sprites[index];
 190   if (!retv)
 191     return NamedSprite();
 192   animate(Animate::Pool::disappear(retv));
 193
 194   for(int i = index; i < (int)m_sprites.size()-1; i++) {
 195 //     double speed = (1.0 + 1.0 / (i - index + 1)) * 0.4;
 196     m_sprites[i] = m_sprites[i+1];
 197     animate(Animate::Pool::move(m_sprites[i], i));
 198   }
 199   m_sprites.resize(m_sprites.size()-1);
 200
 201   return retv;
 202 }
 203
 204
 205 void PiecePool::cancelDragging(bool fadeOff) {
 206   if(!m_dragged)
 207     return;
 208
 209   if (fadeOff) {
 210     NamedSprite phantom = m_dragged.duplicate();
 211     animate(Animate::Pool::disappear(phantom));
 212   }
 213
 214   m_dragged.sprite()->putInCanvas(this);
 215   m_dragged.sprite()->setPixmap( m_loader( m_dragged.name() ) );
 216   insertSprite(m_dragged_index, m_dragged);
 217
 218   m_dragged = NamedSprite();
 219   m_dragged_index = -1;
 220 }
 221
 222
 223 void PiecePool::flipAndMoveBy(QPoint p) {
 224   QPoint deltapos = m_flipped ? -p : p;
 225   moveTo(pos() + deltapos);
 226   m_flipped = !m_flipped;
 227
 228   for(int i=0;i<(int)m_sprites.size(); i++)
 229   animate(Animate::Pool::move(m_sprites[i], i));
 230 }
 231
 232
 233 void PiecePool::onResize(int new_size, bool force_reload) {
 234   if (m_square_size == new_size && !force_reload)
 235     return;
 236
 237   m_square_size = new_size;
 238   m_loader.setSize(m_square_size);
 239
 240   // update the sprites
 241   for (int i=0;i<(int)m_sprites.size(); i++) {
 242     m_sprites[i].sprite()->setPixmap( m_loader( m_sprites[i].name() ) );
 243     m_main_animation->addAnimation(AnimationPtr(new InstantAnimation(m_sprites[i].sprite(), toReal(i))));
 244   }
 245 }
 246
 247
 248 void PiecePool::onMouseRelease(const QPoint& pos, int button) {
 249   if (button != Qt::LeftButton || !m_dragged)
 250     return;
 251
 252   m_board->m_dropped_pool = m_pool_num;
 253   m_board->m_dropped_index = m_dragged_index;
 254
 255   /* did the board take this sprite? */
 256   m_board->dropOn( m_pool_num, m_dragged_index, pos + this->pos() - m_board->pos() );
 257
 258   m_board->m_dropped_pool = -1;
 259   m_board->m_dropped_index = -1;
 260
 261   cancelDragging(true);
 262 }
 263
 264
 265 void PiecePool::onMousePress(const QPoint& pos, int button) {
 266   if (button != Qt::LeftButton)
 267     return;
 268
 269   if(m_dragged) {
 270     ERROR("Eh? We are already dragging?");
 271     cancelDragging(); //never remove implicitly a piece from the pool
 272   }
 273
 274   int index = toLogical(pos);
 275   if(index == -1)
 276     return;
 277   NamedSprite got = takeSpriteAt(index);
 278   if(!got)
 279     return;
 280
 281   got.sprite()->hide();
 282
 283   /* recreate the sprite, as "got" may be being animated */
 284   QPixmap px = m_board->m_loader( got.name() );
 285   QPoint at = pos + this->pos() - m_board->pos() - QPoint(px.width(), px.height())/2;
 286   m_dragged = NamedSprite(  got.name(), SpritePtr(new Sprite(px, m_board->piecesGroup(),  at) ) );
 287   m_dragged.sprite()->raise();
 288   m_dragged.sprite()->show();
 289   m_dragged_index = index;
 290 }
 291
 292
 293 void PiecePool::onMouseMove(const QPoint& pos, int /*button*/) {
 294   if(m_dragged) {
 295     m_dragged.sprite()->moveTo(pos + this->pos() - m_board->pos()
 296                 - QPoint(m_dragged.sprite()->pixmap().width(),
 297                          m_dragged.sprite()->pixmap().height() ) / 2 );
 298     m_board->draggingOn( m_pool_num, m_dragged_index, pos + this->pos() - m_board->pos() );
 299   }
 300 }