src/view/bufferedinputhandler.cpp

   1 #include "bufferedinputhandler.h"
   2
   3 #include "animationmanager.h"
   4 #include "animationfactory.h"
   5 #include "movementanimation.h"
   6 #include "promotionanimation.h"
   7 #include "../middleman.h"
   8 #include "view.h"
   9 #include "viewconstants.h"
  10 #include "../logic/chessboard.h"
  11
  12 bool BufferedInputHandler::keyPressed(const OIS::KeyEvent& arg)
  13 {
  14     CEGUI::System* sys = CEGUI::System::getSingletonPtr();
  15     sys->injectKeyDown(arg.key);
  16     sys->injectChar(arg.text);
  17
  18     switch (arg.key)
  19     {
  20     case OIS::KC_1:
  21         mCamera->setPosition(ViewConstants::WHITE_CAMERA_POSITION);
  22         mCamera->lookAt(Vector3::ZERO);
  23         break;
  24     case OIS::KC_2:
  25         mCamera->setPosition(ViewConstants::BLACK_CAMERA_POSITION);
  26         mCamera->lookAt(Vector3::ZERO);
  27         break;
  28     case OIS::KC_UP:
  29     case OIS::KC_W:
  30         mDirection.z -= CAMERA_MOVEMENT_SPEED;
  31         break;
  32
  33     case OIS::KC_DOWN:
  34     case OIS::KC_S:
  35         mDirection.z += CAMERA_MOVEMENT_SPEED;
  36         break;
  37
  38     case OIS::KC_LEFT:
  39     case OIS::KC_A:
  40         mDirection.x -= CAMERA_MOVEMENT_SPEED;
  41         break;
  42
  43     case OIS::KC_RIGHT:
  44     case OIS::KC_D:
  45         mDirection.x += CAMERA_MOVEMENT_SPEED;
  46         break;
  47
  48     case OIS::KC_PGDOWN:
  49     case OIS::KC_F:
  50         mDirection.y -= CAMERA_MOVEMENT_SPEED;
  51         break;
  52
  53     case OIS::KC_PGUP:
  54     case OIS::KC_R:
  55         mDirection.y += CAMERA_MOVEMENT_SPEED;
  56         break;
  57     default:
  58         ; // No handling
  59     }
  60     return true;
  61 }
  62
  63 bool BufferedInputHandler::keyReleased(const OIS::KeyEvent& arg)
  64 {
  65     CEGUI::System::getSingleton().injectKeyUp(arg.key);
  66
  67     switch (arg.key)
  68     {
  69     case OIS::KC_UP:
  70     case OIS::KC_W:
  71         mDirection.z += CAMERA_MOVEMENT_SPEED;
  72         break;
  73
  74     case OIS::KC_DOWN:
  75     case OIS::KC_S:
  76         mDirection.z -= CAMERA_MOVEMENT_SPEED;
  77         break;
  78
  79     case OIS::KC_LEFT:
  80     case OIS::KC_A:
  81         mDirection.x += CAMERA_MOVEMENT_SPEED;
  82         break;
  83
  84     case OIS::KC_RIGHT:
  85     case OIS::KC_D:
  86         mDirection.x -= CAMERA_MOVEMENT_SPEED;
  87         break;
  88
  89     case OIS::KC_PGDOWN:
  90     case OIS::KC_F:
  91         mDirection.y += CAMERA_MOVEMENT_SPEED;
  92         break;
  93
  94     case OIS::KC_PGUP:
  95     case OIS::KC_R:
  96         mDirection.y -= CAMERA_MOVEMENT_SPEED;
  97         break;
  98     default:
  99         ; // No handling
 100     }
 101     return true;
 102 }
 103
 104 // MouseListener
 105
 106 CEGUI::MouseButton BufferedInputHandler::convertButton(OIS::MouseButtonID buttonID) const
 107 {
 108     switch (buttonID)
 109     {
 110     case OIS::MB_Left:
 111         return CEGUI::LeftButton;
 112
 113     case OIS::MB_Right:
 114         return CEGUI::RightButton;
 115
 116     case OIS::MB_Middle:
 117         return CEGUI::MiddleButton;
 118
 119     default:
 120         return CEGUI::LeftButton;
 121     }
 122 }
 123 bool BufferedInputHandler::mouseMoved(const OIS::MouseEvent& arg)
 124 {
 125     if (!mRMouseDown) {
 126         CEGUI::System::getSingleton().injectMousePosition(arg.state.X.abs, arg.state.Y.abs);
 127         //CEGUI::System::getSingleton().injectMouseMove(arg.state.X.rel, arg.state.Y.rel);
 128     }
 129
 130     // If we are dragging the left mouse button.
 131     if (mLMouseDown)
 132     {
 133
 134     }
 135
 136     // If we are dragging the right mouse button.
 137     else if (mRMouseDown)
 138     {
 139         const double rotationSpeed = 0.2;
 140         mCamera->yaw(Degree(-arg.state.X.rel) * rotationSpeed);
 141         mCamera->pitch(Degree(-arg.state.Y.rel) * rotationSpeed);
 142     }
 143
 144     return true;
 145 }
 146 bool BufferedInputHandler::mousePressed(const OIS::MouseEvent& arg, OIS::MouseButtonID id)
 147 {
 148     CEGUI::System::getSingleton().injectMouseButtonDown(convertButton(id));
 149
 150     // Left mouse button down
 151     if (id == OIS::MB_Left)
 152     {
 153         onLeftPressed(arg);
 154         mLMouseDown = true;
 155     }
 156
 157     // Right mouse button down
 158     else if (id == OIS::MB_Right)
 159     {
 160         onRightPressed(arg);
 161         mRMouseDown = true;
 162     }
 163     return true;
 164 }
 165 bool BufferedInputHandler::mouseReleased(const OIS::MouseEvent& arg, OIS::MouseButtonID id)
 166 {
 167     CEGUI::System::getSingleton().injectMouseButtonUp(convertButton(id));
 168
 169     // Left mouse button up
 170     if (id == OIS::MB_Left)
 171     {
 172         onLeftReleased(arg);
 173         mLMouseDown = false;
 174     }
 175
 176     // Right mouse button up
 177     else if (id == OIS::MB_Right)
 178     {
 179         onRightReleased(arg);
 180         mRMouseDown = false;
 181     }
 182     return true;
 183 }
 184
 185 void BufferedInputHandler::moveCamera(const Real& timeSinceLastFrame)
 186 {
 187     mCamera->setPosition(mCamera->getPosition() +
 188         mCamera->getOrientation() * mDirection * timeSinceLastFrame);
 189
 190     if (mCamera->getPosition().y < 10)
 191     {
 192         Vector3 newPosition = mCamera->getPosition();
 193         newPosition.y = 10;
 194         mCamera->setPosition(newPosition);
 195     }
 196 }
 197
 198 void BufferedInputHandler::onLeftPressed(const OIS::MouseEvent& arg)
 199 {
 200     CEGUI::Point mousePos = CEGUI::MouseCursor::getSingleton().getPosition();
 201
 202     Ray mouseRay = mCamera->getCameraToViewportRay(mousePos.d_x/arg.state.width, mousePos.d_y/arg.state.height);
 203
 204     mRaySceneQuery->setRay(mouseRay);
 205     mRaySceneQuery->setSortByDistance(true);
 206     mRaySceneQuery->setQueryMask(1 << 0);
 207
 208     RaySceneQueryResult& result = mRaySceneQuery->execute();
 209     RaySceneQueryResult::iterator itr;
 210
 211     for (itr = result.begin(); itr != result.end(); itr++)
 212     {
 213         if (itr->movable)
 214         {
 215             if (mSafeMode)
 216             {
 217                 mAnimationManager->finishAnimations();
 218             }
 219
 220             if (mSelectedObject)
 221             {
 222                 toggleMovementPossibilities();
 223                 SceneNode* targetNode = itr->movable->getParentSceneNode();
 224                 SceneNode* pieceNode = findPieceAbove(mSelectedObject);
 225                 if (mSelectedObject != targetNode)
 226                 {
 227                     std::stringstream name;
 228                     name << mSelectedObject->getName() << " " << targetNode->getName();
 229                     std::size_t fromX, fromY, toX, toY;
 230                     name >> fromX;
 231                     name >> fromY;
 232                     name >> toX;
 233                     name >> toY;
 234
 235                     Middleman* middleman = mView->getMiddleman();
 236                     if (middleman)
 237                     {
 238                         unsigned int returnValue = mView->getMiddleman()->move(
 239                             fromX, fromY, toX, toY);
 240
 241                         if (!(returnValue & Board::MOVE_OK))
 242                         {
 243                             if (returnValue & Board::INVALID_MOVE)
 244                             {
 245                                 // TODO: handle
 246                             }
 247                             if (returnValue & Board::INVALID_TURN)
 248                             {
 249                                 // TODO: handle
 250                             }
 251                             if (returnValue & Board::PROMOTION_REQUEST)
 252                             {
 253                                 mView->getMiddleman()->move(fromX, fromY,
 254                                     toX, toY, ChessBoard::PROMOTE_TO_QUEEN);
 255                             }
 256                         }
 257                     }
 258                     else
 259                     {
 260                         move(fromX, fromY, toX, toY);
 261                     }
 262                 }
 263                 mSelectedObject->showBoundingBox(false);
 264                 pieceNode->showBoundingBox(false);
 265                 Entity* ent = mSceneMgr->getEntity(mSelectedObject->getName() + " s");
 266                 ent->setMaterialName("board/square/move");
 267                 ent->setVisible(false);
 268                 mSelectedObject = 0;
 269             }
 270             else
 271             {
 272                 SceneNode* squareNode = itr->movable->getParentSceneNode();
 273                 SceneNode* pieceNode = findPieceAbove(squareNode);
 274                 if (pieceNode)
 275                 {
 276                     mSelectedObject = squareNode;
 277                     mSelectedObject->showBoundingBox(true);
 278                     Entity* ent = mSceneMgr->getEntity(mSelectedObject->getName() + " s");
 279                     ent->setVisible(true);
 280                     ent->setMaterialName("board/square/selected");
 281                     pieceNode->showBoundingBox(true);
 282                     toggleMovementPossibilities();
 283                 }
 284             }
 285             break;
 286         }
 287     }
 288 }
 289
 290 void BufferedInputHandler::move(int fromX, int fromY, int toX, int toY,
 291                                 bool continuous, unsigned int promoteTo)
 292 {
 293     if (mQueueAnimations && mAnimationManager->animationsRunning())
 294     {
 295         std::vector<int> moveOrder;
 296         moveOrder.push_back(fromX);
 297         moveOrder.push_back(fromY);
 298         moveOrder.push_back(toX);
 299         moveOrder.push_back(toY);
 300         moveOrder.push_back(continuous);
 301         moveOrder.push_back(promoteTo);
 302
 303         mAnimationQueue.push_back(moveOrder);
 304     }
 305     else
 306     {
 307         std::ostringstream sourceName;
 308         sourceName << fromX << " " << fromY;
 309         SceneNode* pieceNode = findPieceAbove(mSceneMgr->getSceneNode(sourceName.str()));
 310
 311         std::ostringstream targetName;
 312         targetName << toX << " " << toY;
 313         SceneNode* targetNode = mSceneMgr->getSceneNode(targetName.str());
 314
 315         SceneNode* targetPiece = findPieceAbove(targetNode);
 316
 317         GenericAnimation* animation;
 318         if (promoteTo)
 319         {
 320             animation = AnimationFactory::createPromotionAnimation(
 321                 promoteTo, pieceNode, mSceneMgr, mView);
 322         }
 323         else
 324         {
 325             animation = AnimationFactory::createMovementAnimation(
 326                 *pieceNode->getName().begin(), targetNode->getPosition(),
 327                 pieceNode, targetPiece, mSceneMgr, mAnimationManager);
 328         }
 329
 330         mAnimationManager->addAnimation(animation);
 331
 332         if (continuous)
 333         {
 334             animation->enableCallback(this);
 335             mQueueAnimations = true;
 336         }
 337         else
 338         {
 339             mQueueAnimations = false;
 340         }
 341     }
 342 }
 343
 344 void BufferedInputHandler::animationFinished()
 345 {
 346     std::vector<int> moveOrder = mAnimationQueue.back();
 347     mAnimationQueue.pop_back();
 348
 349     // fromX, fromY, toX, toY, continuous, promote
 350     // TODO: a struct or class for this so it won't seem so magical
 351     move(moveOrder.at(0), moveOrder.at(1),
 352         moveOrder.at(2), moveOrder.at(3),
 353         moveOrder.at(4) != 0, moveOrder.at(5));
 354 }
 355
 356 bool BufferedInputHandler::toggleMovementPossibilities()
 357 {
 358     Middleman* middleman = mView->getMiddleman();
 359     if (!middleman)
 360     {
 361         return false;
 362     }
 363
 364     int x = -1;
 365     int y = -1;
 366     mView->convertPosition(mSelectedObject->getPosition(), &x, &y);
 367
 368     std::vector<std::size_t> validMoves = middleman->getValidMovesAt(x, y);
 369     for (std::size_t i = 0; i < validMoves.size(); i++)
 370     {
 371         std::size_t column = 0;
 372         std::size_t row = 0;
 373         Board::getCoordinates(validMoves.at(i), column, row,
 374             mView->getBoardWidth(), mView->getBoardHeight());
 375
 376         std::ostringstream name;
 377         name << column << " " << row << " s";
 378         Entity* ent = mSceneMgr->getEntity(name.str());
 379         ent->setVisible(!ent->isVisible());
 380         if (ent->isVisible() && ent->getParentNode())
 381         {
 382             if (findPieceAbove(ent->getParentNode()->getParent()))
 383             {
 384                 ent->setMaterialName("board/square/attack");
 385             }
 386         }
 387
 388     }
 389     return true;
 390 }
 391
 392
 393 SceneNode* BufferedInputHandler::findPieceAbove(Node* squareNode) const
 394 {
 395     // TODO: When everything is done, we should do a null check here
 396     // for the squareNode in case query mask for some env is not correctly set
 397
 398     const Vector3& squarePosition = squareNode->getPosition();
 399     Node::ChildNodeIterator it = mSceneMgr->getRootSceneNode()->getChildIterator();
 400     while (it.hasMoreElements())
 401     {
 402         Node* next = it.getNext();
 403         if (squareNode != next && next->getPosition() == squarePosition)
 404         {
 405             return dynamic_cast<SceneNode*>(next);
 406         }
 407     }
 408     return 0;
 409 }
 410
 411 void BufferedInputHandler::onLeftReleased(const OIS::MouseEvent& arg)
 412 {
 413 }
 414
 415 void BufferedInputHandler::onRightPressed(const OIS::MouseEvent& arg)
 416 {
 417 }
 418
 419 void BufferedInputHandler::onRightReleased(const OIS::MouseEvent& arg)
 420 {
 421 }
 422