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