src/board.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 #include <iostream>
  12 #include <QPainter>
  13 #include <QApplication>
  14 #include <QMouseEvent>
  15
  16 #include "global.h"
  17 #include "board.h"
  18 #include "sprite.h"
  19 #include "animation.h"
  20 #include "pointconverter.h"
  21 #include "entities/userentity.h"
  22 #include "mainanimation.h"
  23 #include "premove.h"
  24
  25 using namespace boost;
  26
  27 /** inherit instead of typedef to ease forward declaration :) */
  28 class BoardTags : public std::map<QString, std::map<Point, boost::shared_ptr<Canvas::Pixmap> > > {
  29 };
  30
  31 Board::Board(Canvas::Abstract* parent)
  32 : PieceGroup(parent)
  33 , m_sprites(0,0)
  34 , m_hinting_pos(Point::invalid())
  35 , selection(Point::invalid())
  36 , lastSelection(Point::invalid()) {
  37
  38   m_tags = BoardTagsPtr(new BoardTags);
  39
  40   m_canvas_background = new Canvas::Group(this);
  41   m_canvas_background->lower();
  42   m_canvas_background->show();
  43
  44   m_pieces_group = new Canvas::Group(this);
  45   m_pieces_group->show();
  46
  47   mySettingsChanged();
  48 }
  49
  50 Board::~Board() {
  51   delete m_pieces_group;
  52
  53   while(!m_canvas_background->items()->isEmpty())
  54     delete m_canvas_background->items()->first();
  55   delete m_canvas_background;
  56 }
  57
  58 void Board::mySettingsChanged() {
  59   Settings s_border = settings.group("board-border");
  60   m_show_border = s_border.flag("visible", true);
  61   m_border_color = (s_border["color"] |= QColor(Qt::white));
  62   m_border_text_color = (s_border["text-color"] |= QColor(Qt::black));
  63   m_border_font = (s_border["font"] |= QApplication::font());
  64
  65   recreateBorder();
  66 }
  67
  68 void Board::settingsChanged() {
  69   PieceGroup::settingsChanged();
  70   mySettingsChanged();
  71 }
  72
  73 void Board::updateBackground() {
  74   while(!m_canvas_background->items()->isEmpty())
  75     delete m_canvas_background->items()->first();
  76
  77   Loader::PixmapOrMap bg = m_tags_loader.getPixmapMap("background");
  78   if(const QPixmap* p = boost::get<QPixmap>(&bg)) {
  79     Canvas::TiledPixmap *t = new Canvas::TiledPixmap(*p, boardRect().size(), QPoint(),
  80                                     true, m_canvas_background);
  81     t->show();
  82   }
  83   else if(const Loader::PixmapMap* p = boost::get<Loader::PixmapMap>(&bg)) {
  84     for(Loader::PixmapMap::const_iterator it = p->begin(); it != p->end(); ++it) {
  85       Canvas::TiledPixmap *t = new Canvas::TiledPixmap(it->second, it->first.size(),
  86                                       QPoint(), true, m_canvas_background);
  87       t->moveTo(it->first.topLeft());
  88       t->show();
  89     }
  90   }
  91 }
  92
  93 boost::shared_ptr<Canvas::Pixmap> Board::addTag(const QString& name, Point pt, bool over) {
  94   if(!m_sprites.valid(pt))
  95     return boost::shared_ptr<Canvas::Pixmap>();
  96
  97   QPixmap p = m_tags_loader(name);
  98   boost::shared_ptr<Canvas::Pixmap> item =
  99       boost::shared_ptr<Canvas::Pixmap>(new Canvas::Pixmap(p, this));
 100   item->moveTo(converter()->toReal(pt));
 101   if(over)
 102     item->stackOver(m_pieces_group);
 103   else
 104     item->stackUnder(m_pieces_group);
 105   item->show();
 106
 107   (*m_tags)[name][pt] = item;
 108   return item;
 109 }
 110
 111 void Board::clearTags(const QString& name) {
 112   m_tags->erase(name);
 113 }
 114
 115 void Board::clearTags() {
 116   m_tags->clear();
 117 }
 118
 119 void Board::setTags(const QString& name, Point p1, Point p2, Point p3,
 120                                           Point p4, Point p5, Point p6 ) {
 121   //TODO: maybe this could be optimized a bit
 122   clearTags(name);
 123   addTag(name, p1);
 124   addTag(name, p2);
 125   addTag(name, p3);
 126   addTag(name, p4);
 127   addTag(name, p5);
 128   addTag(name, p6);
 129 }
 130
 131 void Board::recreateBorder() {
 132   m_border_margins.clear();
 133   m_border_items.clear();
 134
 135   if(!m_show_border || m_border_coords.size() == 0) {
 136     m_border_size = 0;
 137     return;
 138   }
 139
 140   QFontMetrics fm(m_border_font);
 141   m_border_size = std::max( fm.height(), fm.boundingRect("H").width() );
 142   m_border_asc = fm.ascent() + (m_border_size-fm.height())/2;
 143
 144   for(int w = 0; w<2; w++)
 145   for(int i=0;i<4;i++) {
 146     Canvas::Rectangle *item = new Canvas::Rectangle(
 147           w ? m_border_text_color : m_border_color, QSize(), this);
 148     item->show();
 149     m_border_margins.push_back( boost::shared_ptr<Canvas::Rectangle>( item ));
 150   }
 151
 152   Point s = m_sprites.getSize();
 153   for(int w = 0; w<2; w++)
 154   for(int i = 0;i<s.x;i++) {
 155     int c = w ? i : i+s.x+s.y;
 156     QString l = m_border_coords.size()>c ? m_border_coords[c] : QString();
 157     Canvas::Item *item = new Canvas::Text( l, m_border_text_color, m_border_font,
 158                                 Canvas::Text::HCenter, Canvas::Text::VBaseline, this);
 159     item->show();
 160     m_border_items.push_back( boost::shared_ptr<Canvas::Item>( item ));
 161   }
 162
 163   for(int w = 0; w<2; w++)
 164   for(int i = 0;i<s.y;i++) {
 165     int c = w ? i+s.x : i+2*s.x+s.y;
 166     QString n = m_border_coords.size()>c ? m_border_coords[c] : QString();
 167     Canvas::Item *item = new Canvas::Text( n, m_border_text_color, m_border_font,
 168                 Canvas::Text::HCenter, Canvas::Text::VBaseline, this);
 169     item->show();
 170     m_border_items.push_back( boost::shared_ptr<Canvas::Item>( item ));
 171   }
 172
 173   m_pieces_group->raise();
 174
 175   updateBorder();
 176 }
 177
 178 void Board::updateBorder() {
 179   if(!m_show_border)
 180     return;
 181
 182   int at = 0;
 183   for(int w = 0; w<2; w++)
 184   for(int i = 0;i<m_sprites.getSize().x;i++) {
 185     int x = (m_flipped ? (m_sprites.getSize().x-1-i):i)*m_square_size+m_square_size/2;
 186     int y = m_border_asc+(w?0:m_border_size+m_square_size*m_sprites.getSize().y)-m_border_size;
 187     m_border_items[at++]->moveTo(x, y);
 188   }
 189
 190   for(int w = 0; w<2; w++)
 191   for(int i = 0;i<m_sprites.getSize().y;i++) {
 192     int x = -m_border_size/2+(w?0:m_border_size+m_square_size*m_sprites.getSize().x);
 193     int y = (!m_flipped ? (m_sprites.getSize().y-1-i):i)*m_square_size
 194                         +m_square_size/2-m_border_size/2+m_border_asc;
 195     m_border_items[at++]->moveTo(x, y);
 196   }
 197
 198   m_border_margins[0]->moveTo(-m_border_size,-m_border_size);
 199   m_border_margins[0]->setSize(QSize(2*m_border_size+m_square_size*m_sprites.getSize().x,
 200                                                               m_border_size));
 201   m_border_margins[4]->moveTo(-m_border_size-1,-m_border_size-1);
 202   m_border_margins[4]->setSize(QSize(2*m_border_size+m_square_size*m_sprites.getSize().x+2, 1));
 203
 204   m_border_margins[1]->moveTo(-m_border_size,m_square_size*m_sprites.getSize().y);
 205   m_border_margins[1]->setSize(QSize(2*m_border_size+m_square_size*m_sprites.getSize().x,
 206                                                               m_border_size));
 207   m_border_margins[5]->moveTo(-m_border_size-1,m_square_size*m_sprites.getSize().y+m_border_size);
 208   m_border_margins[5]->setSize(QSize(2*m_border_size+m_square_size*m_sprites.getSize().x+2, 1));
 209
 210   m_border_margins[2]->moveTo(-m_border_size,0);
 211   m_border_margins[2]->setSize(QSize(m_border_size, m_square_size*m_sprites.getSize().y));
 212   m_border_margins[6]->moveTo(-m_border_size-1,-m_border_size);
 213   m_border_margins[6]->setSize(QSize(1, m_square_size*m_sprites.getSize().y+2*m_border_size));
 214
 215   m_border_margins[3]->moveTo(m_square_size*m_sprites.getSize().x, 0);
 216   m_border_margins[3]->setSize(QSize(m_border_size, m_square_size*m_sprites.getSize().y));
 217   m_border_margins[7]->moveTo(m_square_size*m_sprites.getSize().x+m_border_size, -m_border_size);
 218   m_border_margins[7]->setSize(QSize(1, m_square_size*m_sprites.getSize().y+2*m_border_size));
 219 }
 220
 221 void Board::createGrid(Point p, const QStringList& border_coords) {
 222   m_border_coords = border_coords;
 223   m_sprites = PieceGrid(p.x,p.y);
 224   recreateBorder();
 225 }
 226
 227 QRect Board::computeRect(Point p) const {
 228   QPoint realPoint = converter()->toReal(p);
 229   return squareRect(realPoint.x(), realPoint.y());
 230 }
 231
 232 QRect Board::squareRect(int x, int y) const {
 233   return QRect(x, y, m_square_size, m_square_size);
 234 }
 235
 236 QRegion Board::computeRegion(Point p) const {
 237   return QRegion(computeRect(p));
 238 }
 239
 240 // selection
 241 void Board::setSelection(const Point& p) {
 242   lastSelection = selection;
 243   selection = p;
 244   setTags("selection", p);
 245 }
 246
 247 void Board::cancelSelection() {
 248   lastSelection = selection;
 249   selection = Point::invalid();
 250   clearTags("selection");
 251 }
 252
 253 // premove
 254
 255 void Board::setPremove(const NormalUserMove& premove) {
 256   m_premove_from = premove.from;
 257   m_premove_to = premove.to;
 258   setTags("premove", m_premove_from, m_premove_to);
 259 }
 260
 261 void Board::setPremove(const DropUserMove& premove) {
 262   m_premove_from = Point::invalid();
 263   m_premove_to = premove.m_to;
 264   setTags("premove", m_premove_to);
 265 }
 266
 267 void Board::setPremove(const Premove& premove) {
 268   setPremove(premove.toUserMove());
 269 }
 270
 271 void Board::cancelPremove() {
 272   m_premove_from = Point::invalid();
 273   m_premove_to = Point::invalid();
 274   clearTags("premove");
 275 }
 276
 277 void Board::updateSprites() {
 278   // adjust piece positions
 279   for (Point i = m_sprites.first(); i <= m_sprites.last(); i = m_sprites.next(i)) {
 280     boost::shared_ptr<Sprite> p = m_sprites[i].sprite();
 281
 282     if (p) {
 283       // drawing sprite
 284       p->setPixmap( m_loader( m_sprites[i].name() ) );
 285       adjustSprite(i);
 286     }
 287   }
 288 }
 289
 290 void Board::updateTags() {
 291   for(BoardTags::iterator tit = m_tags->begin(); tit != m_tags->end(); ++tit)
 292   for(std::map<Point, boost::shared_ptr<Canvas::Pixmap> >::iterator pt =
 293                           tit->second.begin(); pt != tit->second.end(); ++pt) {
 294     pt->second->moveTo(converter()->toReal(pt->first));
 295     pt->second->setPixmap(m_tags_loader(tit->first));
 296   }
 297 }
 298
 299
 300 bool Board::doMove(const NormalUserMove& m) {
 301   if (m_entity.lock()->oneClickMoves() || m_entity.lock()->validTurn(m.from) == Moving) {
 302     AbstractMove::Ptr mv = m_entity.lock()->testMove(m);
 303     if (mv) {
 304       m_entity.lock()->executeMove(mv);
 305       return true;
 306     }
 307   }
 308
 309   std::cout << "invalid move" << std::endl;
 310   emit error(InvalidMove);
 311
 312   return false;
 313 }
 314
 315
 316 void Board::onResize(int new_size, bool force_reload) {
 317   if(m_square_size == new_size && !force_reload)
 318     return;
 319
 320   PieceGroup::onResize(new_size);
 321
 322   // update the size of the tag loader
 323   m_tags_loader.setSize(m_square_size);
 324
 325   // update canvas background
 326   updateBackground();
 327
 328   // update the sprites
 329   updateSprites();
 330
 331   // update piece tags
 332   updateTags();
 333
 334   // update border
 335   updateBorder();
 336 }
 337
 338 void Board::onMousePress(const QPoint& pos, int button) {
 339   Point point = converter()->toLogical(pos);
 340   if (!m_sprites.valid(point))
 341       return;
 342
 343   //BEGIN left click
 344
 345   if (button == Qt::LeftButton) {
 346     if (m_entity.lock()->oneClickMoves()) {
 347       NormalUserMove m(Point::invalid(), point);
 348       m_entity.lock()->setPromotion(m);
 349       doMove(m);
 350     }
 351     else {
 352       shared_ptr<Sprite> piece = m_sprites[point].sprite();
 353
 354       if (piece && m_entity.lock()->movable(point)) {
 355           cancelSelection();
 356           m_drag_info = DragInfoPtr(new DragInfo(point, pos, piece,
 357                             m_entity.lock()->validTurn(point)) );
 358           piece->raise();
 359       }
 360
 361       // if selection is valid, (pre)move to point
 362       else if (selection != Point::invalid()) {
 363           piece = m_sprites[selection].sprite();
 364           Q_ASSERT(piece);
 365           NormalUserMove m(selection, point);
 366           m_entity.lock()->setPromotion(m);
 367
 368           switch(m_entity.lock()->validTurn(selection)) {
 369
 370             case Moving:
 371               doMove(m);
 372               cancelSelection();
 373               break;
 374
 375             case Premoving:
 376               if (m_entity.lock()->testPremove(m)) {
 377                 m_entity.lock()->addPremove(m);
 378                 setPremove(m);
 379                 cancelSelection();
 380               }
 381               break;
 382
 383             default:
 384               break;
 385           }
 386       }
 387     }
 388   }
 389
 390   //END left click
 391
 392   //BEGIN right click
 393
 394   else if (button == Qt::RightButton) {
 395     cancelSelection();
 396     if (point == m_premove_from || point == m_premove_to)
 397       cancelPremove();
 398     m_entity.lock()->handleRightClick(point);
 399   }
 400
 401   //END right click
 402 }
 403
 404 void Board::onMouseRelease(const QPoint& pos, int button) {
 405   Point point = converter()->toLogical(pos);
 406
 407   //BEGIN left click
 408
 409   if (button == Qt::LeftButton) {
 410
 411     if (m_drag_info) {
 412 //      Q_ASSERT(m_drag_info->piece);
 413       Q_ASSERT(m_drag_info->sprite);
 414       bool moved = false;
 415
 416       // remove valid move highlighting
 417       clearTags("validmove");
 418
 419       // toggle selection if the piece didn't move
 420       if (m_drag_info->from == point) {
 421         if (lastSelection == point)
 422           cancelSelection();
 423         else
 424           setSelection(point);
 425       }
 426
 427       else  {
 428         NormalUserMove m(m_drag_info->from, point, true);
 429         if (!m_sprites.valid(point))
 430           m.to = Point::invalid();
 431
 432         m_entity.lock()->setPromotion(m);
 433
 434         switch(m_entity.lock()->validTurn(m_drag_info->from)) {
 435
 436           case Moving:
 437             if (doMove(m))
 438               moved = true;
 439             break;
 440
 441           case Premoving:
 442             if (m_entity.lock()->testPremove(m)) {
 443               m_entity.lock()->addPremove(m);
 444               setPremove(m);
 445             }
 446             break;
 447
 448           default:
 449             break;
 450         }
 451       }
 452
 453       shared_ptr<Sprite> s = m_sprites[m_drag_info->from].sprite();
 454       if (!moved && s && s->pos() != converter()->toReal(m_drag_info->from)) {
 455         Q_ASSERT(s);
 456         QPoint real = converter()->toReal(m_drag_info->from);
 457         if( (point == m_drag_info->from) ? !m_anim_movement : !m_anim_fade)
 458           enqueue(shared_ptr<Animation>(new InstantAnimation(s, real)));
 459         else if (point == m_drag_info->from)
 460           enqueue(shared_ptr<Animation>(new MovementAnimation(s, real)));
 461         else
 462           enqueue(shared_ptr<Animation>(new TeleportAnimation(s, s->pos(), real)));
 463       }
 464
 465       m_drag_info = DragInfoPtr();
 466     }
 467   }
 468
 469   //END left button
 470 }
 471
 472 void Board::onMouseMove(const QPoint& pos, int /*button*/) {
 473   Point point = converter()->toLogical(pos);
 474
 475   if (m_drag_info) {
 476     Q_ASSERT(m_drag_info->sprite);
 477     // check drag threshold
 478     if (!m_drag_info->dragStarted) {
 479       QPoint delta = pos - m_drag_info->real;
 480       if (delta.x() * delta.x() + delta.y() * delta.y() > DragInfo::DRAG_THRESHOLD) {
 481         m_drag_info->dragStarted = true;
 482       }
 483     }
 484     if (m_drag_info->dragStarted)
 485       m_drag_info->sprite->moveTo(pos - QPoint(m_square_size / 2, m_square_size / 2) );
 486
 487     // highlight valid moves
 488     NormalUserMove move(m_drag_info->from,  point);
 489     bool valid = m_sprites.valid(point);
 490     if (valid) {
 491       InteractionType action = m_entity.lock()->validTurn(m_drag_info->from);
 492       if (action == Moving)
 493         valid = m_entity.lock()->testMove(move);
 494     }
 495
 496     if (valid)
 497       setTags("validmove", point);
 498     else
 499       clearTags("validmove");
 500   }
 501   else if (m_entity.lock()->oneClickMoves()) {
 502     if(point == m_hinting_pos)
 503       return;
 504
 505     AbstractPiece::Ptr hint;
 506
 507     if (m_sprites.valid(point)) {
 508       if (AbstractMove::Ptr move = m_entity.lock()->testMove(
 509                               NormalUserMove(Point::invalid(), point))) {
 510         // set move hint
 511         hint = m_entity.lock()->moveHint(move);
 512       }
 513     }
 514
 515     updateHinting(point, hint);
 516   }
 517 }
 518
 519 void Board::onPositionChanged() {
 520   if (m_entity.lock() && m_entity.lock()->oneClickMoves() && m_sprites.valid(m_hinting_pos)) {
 521     AbstractPiece::Ptr hint;
 522
 523     if (AbstractMove::Ptr move = m_entity.lock()->testMove(
 524                             NormalUserMove(Point::invalid(), m_hinting_pos)) ) {
 525       // set move hint
 526       hint = m_entity.lock()->moveHint(move);
 527     }
 528
 529     updateHinting(m_hinting_pos, hint);
 530   }
 531 }
 532
 533 void Board::onMouseLeave() {
 534   updateHinting(Point::invalid(), AbstractPiece::Ptr());
 535 }
 536
 537 void Board::updateHinting(Point pt, AbstractPiece::Ptr piece) {
 538   if(!m_sprites.valid(pt))
 539     piece = AbstractPiece::Ptr();
 540
 541   if(!piece || !m_sprites.valid(pt)) {
 542     if(m_hinting.sprite()) {
 543       if(m_anim_fade)
 544         enqueue( boost::shared_ptr<Animation>(new FadeAnimation(m_hinting.sprite(),
 545                                                         m_hinting.sprite()->pos(), 160, 0)) );
 546       else
 547         enqueue( boost::shared_ptr<Animation>(new CaptureAnimation(m_hinting.sprite())) );
 548     }
 549
 550     m_hinting_pos = Point::invalid();
 551     m_hinting = NamedSprite();
 552   }
 553   else {
 554     if(pt == m_hinting_pos) {
 555       if(!(piece->name() == m_hinting.name())) {
 556         m_hinting = NamedSprite(piece->name(), m_hinting.sprite());
 557         m_hinting.sprite()->setPixmap(m_loader(piece->name()));
 558       }
 559     }
 560     else {
 561       if(m_hinting.sprite()) {
 562         if(m_anim_fade)
 563           enqueue( boost::shared_ptr<Animation>(new FadeAnimation(m_hinting.sprite(),
 564                                                           m_hinting.sprite()->pos(), 160, 0)) );
 565         else
 566           enqueue( boost::shared_ptr<Animation>(new CaptureAnimation(m_hinting.sprite())) );
 567       }
 568
 569       QPixmap pix = m_loader(piece->name());
 570       boost::shared_ptr<Sprite> sprite = createSprite(pix, pt);
 571       sprite->setOpacity(160);
 572       sprite->raise();
 573       sprite->show();
 574
 575       m_hinting_pos = pt;
 576       m_hinting = NamedSprite(piece->name(), sprite);
 577
 578       /*if(m_anim_fade)
 579         enqueue( boost::shared_ptr<Animation>(new FadeAnimation(m_hinting.sprite(),
 580                                                         m_hinting.sprite()->pos(), 0, 160)) );
 581       else {
 582         m_hinting.sprite()->setOpacity(160);
 583         enqueue(boost::shared_ptr<Animation>(new DropAnimation(m_hinting.sprite())) );
 584       }*/
 585     }
 586   }
 587 }
 588
 589 void Board::reset() {
 590   clearTags();
 591   cancelSelection();
 592   cancelPremove();
 593   m_main_animation->stop();
 594 }
 595
 596 void Board::flip(bool flipped)
 597 {
 598   if (m_flipped != flipped) {
 599     m_flipped = flipped;
 600
 601     // update sprite positions
 602     for (Point i = m_sprites.first(); i <= m_sprites.last(); i = m_sprites.next(i))
 603     if (m_sprites[i].sprite())
 604       animatePiece(m_sprites[i].sprite(), i, 1.0);
 605
 606     updateTags();
 607     updateBorder();
 608   }
 609 }
 610
 611 void Board::draggingOn(int pool, int index, const QPoint& point) {
 612   Point to = converter()->toLogical(point);
 613
 614   #if 0
 615   //BROKEN
 616   if (m_sprites.valid(to))
 617   switch(m_entity.lock()->validTurn(piece->color())) {
 618     case Moving: {
 619       DropUserMove m(piece, to);
 620       AbstractMove::Ptr mv = m_entity.lock()->testMove(m);
 621       if (mv) {
 622         setTags("validmove", to);
 623         return;
 624       }
 625       break;
 626     }
 627
 628     case Premoving:
 629       setTags("validmove", to);
 630       return;
 631
 632     default:
 633       break;
 634   }
 635   #endif
 636
 637   clearTags("validmove");
 638 }
 639
 640 bool Board::dropOn(int pool, int index, const QPoint& point) {
 641
 642   Point to = converter()->toLogical(point);
 643   if (!m_sprites.valid(to))
 644     return false;
 645
 646   clearTags("validmove");
 647
 648   #if 0
 649   //BROKEN
 650   switch(m_entity.lock()->validTurn(piece->color())) {
 651
 652     case Moving: {
 653       DropUserMove m(piece, to);
 654       AbstractMove::Ptr mv = m_entity.lock()->testMove(m);
 655       if (mv)  {
 656           m_entity.lock()->executeMove(mv);
 657           return true;
 658       }
 659       break;
 660     }
 661
 662     case Premoving: {
 663       DropUserMove m(piece, to);
 664       if (m_entity.lock()->testPremove(m)) {
 665         m_entity.lock()->addPremove(m);
 666         setPremove(m);
 667       }
 668       break;
 669     }
 670
 671     default:
 672       break;
 673   }
 674   #endif
 675   std::cout << "invalid move" << std::endl;
 676   emit error(InvalidMove);
 677   return false;
 678 }
 679
 680 #include "board.moc"