/*
 *  Copyright 2006-2009  Parker Coates <coates@kde.org>
 *
 *  This file is part of Killbots.
 *
 *  Killbots is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Killbots is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Killbots. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef KILLBOTS_ENGINE_H
#define KILLBOTS_ENGINE_H

#include "actions.h"
#include "ruleset.h"

#include <QObject>
#include <QHash>
class QPoint;

namespace Killbots
{
class Coordinator;
class Sprite;

class Engine : public QObject
{
    Q_OBJECT

public: // functions
    explicit Engine(Coordinator *scene, QObject *parent = 0);
    virtual ~Engine();

    void setRuleset(const Ruleset *ruleset);
    const Ruleset *ruleset() const;

    bool gameHasStarted() const;
    bool isRoundComplete() const;
    bool isHeroDead() const;
    bool isBoardFull() const;
    bool canSafeTeleport() const;
    bool canUseVaporizer() const;

    void startNewGame();
    void startNewRound(bool incrementRound = true, const QString &layout = QString());

    bool moveHero(Killbots::HeroAction direction);
    bool teleportHero();
    bool teleportHeroSafely();
    bool useVaporizer();
    bool waitOutRound();

    void moveRobots(bool justFastbots = false);
    void assessDamage();
    void resetBotCounts();
    void endGame();

signals:
    void roundChanged(int round);
    void scoreChanged(int score);
    void enemyCountChanged(int enemyCount);
    void energyChanged(int energy);
    void gameOver(int score, int round);

    void showNewGameMessage();
    void showRoundCompleteMessage();
    void showBoardFullMessage();
    void showGameOverMessage();

    void teleportAllowed(bool allowed);
    void teleportSafelyAllowed(bool allowed);
    void vaporizerAllowed(bool allowed);
    void waitOutRoundAllowed(bool allowed);

private: // functions
    void refreshSpriteMap();
    int spriteTypeAt(const QPoint &cell) const;
    QPoint offsetFromDirection(int direction) const;
    QPoint randomEmptyCell() const;

    bool cellIsValid(const QPoint &cell) const;
    bool moveIsValid(const QPoint &cell, HeroAction direction) const;
    bool moveIsSafe(const QPoint   &cell, HeroAction direction) const;
    bool canPushJunkheap(const Sprite *junkheap, HeroAction direction) const;

    void pushJunkheap(Sprite *junkheap, HeroAction direction);
    void cleanUpRound();
    void destroySprite(Sprite *sprite, bool calculatePoints = true);
    bool destroyAllCollidingBots(const Sprite *sprite, bool calculatePoints = true);
    void updateScore(int changeInScore);
    void updateEnergy(int changeInEnergy);

    QString gridToString() const;

private: // data members
    Coordinator *m_coordinator;

    Sprite *m_hero;
    QList<Sprite *> m_bots;
    QList<Sprite *> m_junkheaps;

    const Ruleset *m_rules;
    int m_round;
    int m_score;
    int m_energy;
    qreal m_maxEnergy;
    qreal m_robotCount;
    qreal m_fastbotCount;
    qreal m_junkheapCount;

    bool m_heroIsDead;
    bool m_waitingOutRound;

    QMultiHash<QPoint, Sprite *> m_spriteMap;

    friend class EngineTest;
};
}

#endif
