// This file is generated by kconfig_compiler_kf6 from rulesetbase.kcfg.
// All changes you do to this file will be lost.
#ifndef KILLBOTS_RULESETBASE_H
#define KILLBOTS_RULESETBASE_H

#include <qglobal.h>
#include <kconfigskeleton.h>
#include <QCoreApplication>
#include <QDebug>

namespace Killbots {

class RulesetBase : public KConfigSkeleton
{
  public:
    enum JunkheapsThatCanBePushed { None, One, Many };

    RulesetBase( KSharedConfig::Ptr config = KSharedConfig::openConfig() );
    ~RulesetBase() override;

    /**
      Get Name
    */
    QString name() const
    {
      return mName;
    }

    /**
      Is Name Immutable
    */
    bool isNameImmutable() const
    {
      return isImmutable( QStringLiteral( "Name" ) );
    }

    /**
      Get Author
    */
    QString author() const
    {
      return mAuthor;
    }

    /**
      Is Author Immutable
    */
    bool isAuthorImmutable() const
    {
      return isImmutable( QStringLiteral( "Author" ) );
    }

    /**
      Get AuthorContact
    */
    QString authorContact() const
    {
      return mAuthorContact;
    }

    /**
      Is AuthorContact Immutable
    */
    bool isAuthorContactImmutable() const
    {
      return isImmutable( QStringLiteral( "AuthorContact" ) );
    }

    /**
      Get Description
    */
    QString description() const
    {
      return mDescription;
    }

    /**
      Is Description Immutable
    */
    bool isDescriptionImmutable() const
    {
      return isImmutable( QStringLiteral( "Description" ) );
    }

    /**
      Get Number of rows in game grid
    */
    int rows() const
    {
      return mRows;
    }

    /**
      Is Number of rows in game grid Immutable
    */
    bool isRowsImmutable() const
    {
      return isImmutable( QStringLiteral( "Rows" ) );
    }

    /**
      Get Number of columns in game grid
    */
    int columns() const
    {
      return mColumns;
    }

    /**
      Is Number of columns in game grid Immutable
    */
    bool isColumnsImmutable() const
    {
      return isImmutable( QStringLiteral( "Columns" ) );
    }

    /**
      Get Number of regular enemies in first round
    */
    double enemiesAtGameStart() const
    {
      return mEnemiesAtGameStart;
    }

    /**
      Is Number of regular enemies in first round Immutable
    */
    bool isEnemiesAtGameStartImmutable() const
    {
      return isImmutable( QStringLiteral( "EnemiesAtGameStart" ) );
    }

    /**
      Get Number of regular enemies added in each new round
    */
    double enemiesAddedEachRound() const
    {
      return mEnemiesAddedEachRound;
    }

    /**
      Is Number of regular enemies added in each new round Immutable
    */
    bool isEnemiesAddedEachRoundImmutable() const
    {
      return isImmutable( QStringLiteral( "EnemiesAddedEachRound" ) );
    }

    /**
      Get Number of fast enemies in first round
    */
    double fastEnemiesAtGameStart() const
    {
      return mFastEnemiesAtGameStart;
    }

    /**
      Is Number of fast enemies in first round Immutable
    */
    bool isFastEnemiesAtGameStartImmutable() const
    {
      return isImmutable( QStringLiteral( "FastEnemiesAtGameStart" ) );
    }

    /**
      Get Number of fast enemies added in each new round
    */
    double fastEnemiesAddedEachRound() const
    {
      return mFastEnemiesAddedEachRound;
    }

    /**
      Is Number of fast enemies added in each new round Immutable
    */
    bool isFastEnemiesAddedEachRoundImmutable() const
    {
      return isImmutable( QStringLiteral( "FastEnemiesAddedEachRound" ) );
    }

    /**
      Get Fast enemies will skip their extra turn to avoid collisions with other robots
    */
    bool fastEnemiesArePatient() const
    {
      return mFastEnemiesArePatient;
    }

    /**
      Is Fast enemies will skip their extra turn to avoid collisions with other robots Immutable
    */
    bool isFastEnemiesArePatientImmutable() const
    {
      return isImmutable( QStringLiteral( "FastEnemiesArePatient" ) );
    }

    /**
      Get Player can accumulate energy
    */
    bool energyEnabled() const
    {
      return mEnergyEnabled;
    }

    /**
      Is Player can accumulate energy Immutable
    */
    bool isEnergyEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "EnergyEnabled" ) );
    }

    /**
      Get Energy at start of first round
    */
    int energyAtGameStart() const
    {
      return mEnergyAtGameStart;
    }

    /**
      Is Energy at start of first round Immutable
    */
    bool isEnergyAtGameStartImmutable() const
    {
      return isImmutable( QStringLiteral( "EnergyAtGameStart" ) );
    }

    /**
      Get Energy awarded for completing a round
    */
    int energyAddedEachRound() const
    {
      return mEnergyAddedEachRound;
    }

    /**
      Is Energy awarded for completing a round Immutable
    */
    bool isEnergyAddedEachRoundImmutable() const
    {
      return isImmutable( QStringLiteral( "EnergyAddedEachRound" ) );
    }

    /**
      Get Maximum energy cap in first round
    */
    double maxEnergyAtGameStart() const
    {
      return mMaxEnergyAtGameStart;
    }

    /**
      Is Maximum energy cap in first round Immutable
    */
    bool isMaxEnergyAtGameStartImmutable() const
    {
      return isImmutable( QStringLiteral( "MaxEnergyAtGameStart" ) );
    }

    /**
      Get Increase in maximum energy cap for each new round
    */
    double maxEnergyAddedEachRound() const
    {
      return mMaxEnergyAddedEachRound;
    }

    /**
      Is Increase in maximum energy cap for each new round Immutable
    */
    bool isMaxEnergyAddedEachRoundImmutable() const
    {
      return isImmutable( QStringLiteral( "MaxEnergyAddedEachRound" ) );
    }

    /**
      Get Player can perform safe teleports
    */
    bool safeTeleportEnabled() const
    {
      return mSafeTeleportEnabled;
    }

    /**
      Is Player can perform safe teleports Immutable
    */
    bool isSafeTeleportEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "SafeTeleportEnabled" ) );
    }

    /**
      Get The cost of performing a safe teleport
    */
    int costOfSafeTeleport() const
    {
      return mCostOfSafeTeleport;
    }

    /**
      Is The cost of performing a safe teleport Immutable
    */
    bool isCostOfSafeTeleportImmutable() const
    {
      return isImmutable( QStringLiteral( "CostOfSafeTeleport" ) );
    }

    /**
      Get Player can use vaporizer
    */
    bool vaporizerEnabled() const
    {
      return mVaporizerEnabled;
    }

    /**
      Is Player can use vaporizer Immutable
    */
    bool isVaporizerEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "VaporizerEnabled" ) );
    }

    /**
      Get Cost of using vaporizer
    */
    int costOfVaporizer() const
    {
      return mCostOfVaporizer;
    }

    /**
      Is Cost of using vaporizer Immutable
    */
    bool isCostOfVaporizerImmutable() const
    {
      return isImmutable( QStringLiteral( "CostOfVaporizer" ) );
    }

    /**
      Get Number of junkheaps that can be pushed at once
    */
    JunkheapsThatCanBePushed pushableJunkheaps() const
    {
      return static_cast<JunkheapsThatCanBePushed>(mPushableJunkheaps);
    }

    /**
      Is Number of junkheaps that can be pushed at once Immutable
    */
    bool isPushableJunkheapsImmutable() const
    {
      return isImmutable( QStringLiteral( "PushableJunkheaps" ) );
    }

    /**
      Get Player can destroy enemies with a pushed junkheap
    */
    bool squaskKillsEnabled() const
    {
      return mSquaskKillsEnabled;
    }

    /**
      Is Player can destroy enemies with a pushed junkheap Immutable
    */
    bool isSquaskKillsEnabledImmutable() const
    {
      return isImmutable( QStringLiteral( "SquaskKillsEnabled" ) );
    }

    /**
      Get Junkheaps placed on grid at start of first round
    */
    double junkheapsAtGameStart() const
    {
      return mJunkheapsAtGameStart;
    }

    /**
      Is Junkheaps placed on grid at start of first round Immutable
    */
    bool isJunkheapsAtGameStartImmutable() const
    {
      return isImmutable( QStringLiteral( "JunkheapsAtGameStart" ) );
    }

    /**
      Get Junkheaps added to the grid for each new round
    */
    double junkheapsAddedEachRound() const
    {
      return mJunkheapsAddedEachRound;
    }

    /**
      Is Junkheaps added to the grid for each new round Immutable
    */
    bool isJunkheapsAddedEachRoundImmutable() const
    {
      return isImmutable( QStringLiteral( "JunkheapsAddedEachRound" ) );
    }

    /**
      Get Points awarded for each regular enemy destroyed
    */
    int pointsPerEnemyKilled() const
    {
      return mPointsPerEnemyKilled;
    }

    /**
      Is Points awarded for each regular enemy destroyed Immutable
    */
    bool isPointsPerEnemyKilledImmutable() const
    {
      return isImmutable( QStringLiteral( "PointsPerEnemyKilled" ) );
    }

    /**
      Get Points awarded for each fast enemy destroyed
    */
    int pointsPerFastEnemyKilled() const
    {
      return mPointsPerFastEnemyKilled;
    }

    /**
      Is Points awarded for each fast enemy destroyed Immutable
    */
    bool isPointsPerFastEnemyKilledImmutable() const
    {
      return isImmutable( QStringLiteral( "PointsPerFastEnemyKilled" ) );
    }

    /**
      Get Points awarded for each enemy destroyed while waiting out the round
    */
    int waitKillPointBonus() const
    {
      return mWaitKillPointBonus;
    }

    /**
      Is Points awarded for each enemy destroyed while waiting out the round Immutable
    */
    bool isWaitKillPointBonusImmutable() const
    {
      return isImmutable( QStringLiteral( "WaitKillPointBonus" ) );
    }

    /**
      Get Energy awarded for each enemy destroyed while waiting out the round
    */
    int waitKillEnergyBonus() const
    {
      return mWaitKillEnergyBonus;
    }

    /**
      Is Energy awarded for each enemy destroyed while waiting out the round Immutable
    */
    bool isWaitKillEnergyBonusImmutable() const
    {
      return isImmutable( QStringLiteral( "WaitKillEnergyBonus" ) );
    }

    /**
      Get Points awarded for each enemy destroyed with a pushed junkheap
    */
    int squashKillPointBonus() const
    {
      return mSquashKillPointBonus;
    }

    /**
      Is Points awarded for each enemy destroyed with a pushed junkheap Immutable
    */
    bool isSquashKillPointBonusImmutable() const
    {
      return isImmutable( QStringLiteral( "SquashKillPointBonus" ) );
    }

    /**
      Get Energy awarded for each enemy destroyed with a pushed junkheap
    */
    int squashKillEnergyBonus() const
    {
      return mSquashKillEnergyBonus;
    }

    /**
      Is Energy awarded for each enemy destroyed with a pushed junkheap Immutable
    */
    bool isSquashKillEnergyBonusImmutable() const
    {
      return isImmutable( QStringLiteral( "SquashKillEnergyBonus" ) );
    }

    /**
      Get Points awarded for each energy awarded above maximum energy cap
    */
    int pointsPerEnergyAboveMax() const
    {
      return mPointsPerEnergyAboveMax;
    }

    /**
      Is Points awarded for each energy awarded above maximum energy cap Immutable
    */
    bool isPointsPerEnergyAboveMaxImmutable() const
    {
      return isImmutable( QStringLiteral( "PointsPerEnergyAboveMax" ) );
    }

  protected:

    // KillbotsRuleset
    QString mName;
    QString mAuthor;
    QString mAuthorContact;
    QString mDescription;
    int mRows;
    int mColumns;
    double mEnemiesAtGameStart;
    double mEnemiesAddedEachRound;
    double mFastEnemiesAtGameStart;
    double mFastEnemiesAddedEachRound;
    bool mFastEnemiesArePatient;
    bool mEnergyEnabled;
    int mEnergyAtGameStart;
    int mEnergyAddedEachRound;
    double mMaxEnergyAtGameStart;
    double mMaxEnergyAddedEachRound;
    bool mSafeTeleportEnabled;
    int mCostOfSafeTeleport;
    bool mVaporizerEnabled;
    int mCostOfVaporizer;
    int mPushableJunkheaps;
    bool mSquaskKillsEnabled;
    double mJunkheapsAtGameStart;
    double mJunkheapsAddedEachRound;
    int mPointsPerEnemyKilled;
    int mPointsPerFastEnemyKilled;
    int mWaitKillPointBonus;
    int mWaitKillEnergyBonus;
    int mSquashKillPointBonus;
    int mSquashKillEnergyBonus;
    int mPointsPerEnergyAboveMax;
};

}

#endif

