Feat/tile 2

.gitignore

@@ -42,3 +42,9 @@ bin/
 
 # debug information files
 *.dwo
+
+
+/html
+/latex
+
+*Doxyfile

include/core/Auction.hpp

@@ -0,0 +1,33 @@
+#ifndef AUCTION_HPP
+#define AUCTION_HPP
+
+#include "../models/PropertyTile.hpp"
+#include "Player.hpp"
+#include <vector>
+
+class Auction {
+  private:
+    PropertyTile *targetProperty;
+    std::vector<Player *> activeBidders;
+    int currentHighestBid;
+    Player *currentHighestBidder;
+    int currentBidderIndex;
+
+  public:
+    Auction(PropertyTile *property,
+            const std::vector<Player *> &initialBidders);
+
+    // Run utama
+    void run();
+
+    // Method memasang bid untuk player pada gilirannya 
+    bool placeBid(Player *bidder, int amount);
+
+    // Method pass untuk player pada gilirannya
+    void passTurn(Player *bidder);
+
+    // Menentukan pemenang bid dan merubah kepemilikan properti
+    void delegateProperty();
+};
+
+#endif

include/core/ConfigLoader.hpp

@@ -0,0 +1,74 @@
+#pragma once
+#include <string>
+#include <fstream>
+#include <vector>
+#include <map>
+#include "Tile.hpp"
+using namespace std;
+
+class ConfigLoader {
+private:
+    static ConfigLoader* instance;
+    ConfigLoader();
+
+    ifstream currentFile;
+    string currentLine;
+    int currentParsedIndex;
+    string configFilePath;
+    bool isConfigValid;
+
+    map<int, int> railroadRentMap;
+    map<int, int> utilityMultiplierMap;
+    int taxPPHFlat;
+    double taxPPHPercent;
+    int taxPBMFlat;
+    int goSalary;
+    int jailFine;
+
+    int maxTurn;
+    int initialMoney;
+
+    class TileDefinition {
+    public:
+        int index;
+        string kode;
+        string nama;
+        string tipeStr;
+
+        TileDefinition(int index, const string& kode,
+                       const string& nama, const string& tipeStr);
+
+        int getIndex() const;
+        string getKode() const;
+        string getNama() const;
+        string getTipeStr() const;
+    };
+    vector<TileDefinition> layoutDefinitions;
+
+    void readRailroadConfig();
+    void readUtilityConfig();
+    void readTaxConfig();
+    void readSpecialConfig();
+    void readMiscConfig();
+
+    void buildLayoutFromHardcode();
+    void buildLayoutFromFile();
+
+    Tile* instantiateTile(const TileDefinition& def);
+    void linkSpecialTiles();
+
+public:
+    static ConfigLoader* getInstance();
+    ~ConfigLoader();
+
+    void loadAllConfigs();
+    void parsePropertyConfig();
+    void parseActionTileConfig();
+    void validateBoardLayout();
+    void setConfigFilePath(const string& path);
+    bool getIsConfigValid() const;
+
+    // Getter untuk GameEngine setelah loadAllConfigs() selesai
+    int getMaxTurn() const;
+    int getInitialMoney() const;
+};

include/core/Enums.hpp

@@ -0,0 +1,78 @@
+#ifndef ENUMS_HPP
+#define ENUMS_HPP
+
+#include <string>
+
+
+const int maxPlayer = 4;
+
+// INI BUAT VARIABELS/ATRIBUT YG SCOPENYA UDAH TAU DAN BIAR BEST PRACTICE. JANGAN DI DEFINE DI HPP MASING2! (pake ini ya enumz)
+enum class PlayerStatus{
+    ACTIVE,
+    JAILED,
+    BANKRUPT
+};
+
+enum class PropertyStatus{
+    BANK,
+    OWNED,
+    MORTGAGED
+};
+
+enum class CardTileType{
+    CHANCE,
+    COMMUNITY_CHEST
+};
+
+enum class TaxType{
+    PPH,
+    PBM
+};
+
+enum class SpecialTileType{
+    GO,
+    JAIL,
+    FREE_PARKING,
+    GO_TO_JAIL
+};
+
+enum class ChanceCardType{
+    NEAREST_STATION,
+    MOVE_BACK_3,
+    GO_TO_JAIL
+};
+
+enum class CommunityChestCardType{
+    BIRTHDAY,
+    DOCTOR,
+    ELECTION
+};
+
+enum class SkillCardType{
+    MOVE,
+    DISCOUNT,
+    SHIELD,
+    TELEPORT,
+    LASSO,
+    DEMOLITION
+};
+
+enum class GameErrorCode {
+    NOT_ENOUGH_MONEY = 1,
+    MAX_CARD_LIMIT = 2,
+    INVALID_COMMAND = 3,
+    INVALID_PROPERTY = 4,
+    GAME_STATE_ERROR = 5
+};
+
+enum class LogActionType { // Plis ini beda sama type" yang di class lain yak, ini khusus event yang sedang terjadi aja bukan semacam state suatu objek
+    ROLL, BUY, RENT, TAX, BUILD, SELL, MORTGAGE, 
+    UNMORTGAGE, CARD, RAILROAD, UTILITY, AUCTION, 
+    FESTIVAL, BANKRUPT, SAVE, LOAD, DOUBLE_ROLL, UNKNOWN
+};
+
+std::string actionTypeToString(LogActionType type);
+LogActionType stringToActionType(const std::string& str);
+
+
+#endif

include/core/Exceptions.hpp

@@ -0,0 +1,54 @@
+#ifndef EXCEPTIONS_HPP
+#define EXCEPTIONS_HPP
+
+#include <exception>
+#include <string>
+#include "Enums.hpp"
+
+class GameException : public std::exception{
+private:
+    GameErrorCode errorCode;
+    std::string errorMessage;
+
+public:
+    GameException(GameErrorCode errorCode, const std::string& errorMessage) : errorCode(errorCode), errorMessage(errorMessage){}
+
+    GameErrorCode getErrorCode() const{
+        return errorCode;
+    }
+
+    std::string getErrorMessage() const{
+        return errorMessage;
+    }
+
+    const char* what() const noexcept override{
+        return errorMessage.c_str();
+    }
+};
+
+class NotEnoughMoneyException : public GameException{
+public:
+    NotEnoughMoneyException(int have, int need, const std::string& context) : GameException( GameErrorCode::NOT_ENOUGH_MONEY, "Uang tidak cukup untuk: " + context + ". Punya: " + std::to_string(have) + ", Butuh: " + std::to_string(need)){}
+};
+
+class MaxCardLimitException : public GameException{
+public:
+    MaxCardLimitException() : GameException(GameErrorCode::MAX_CARD_LIMIT, "Slot untuk kartu sudah limit! Maksimal 3"){}
+};
+
+class InvalidCommandException : public GameException{
+public:
+    InvalidCommandException(const std::string command) : GameException(GameErrorCode::INVALID_COMMAND, "Command " + command + " tidak dikenali!"){}
+};
+
+class InvalidPropertyException : public GameException{
+public:
+    InvalidPropertyException(const std::string kode) : GameException(GameErrorCode::INVALID_PROPERTY, "Kode petak " + kode + " tidak dikenali!"){}
+};
+
+class GameStateException : public GameException{
+public:
+    GameStateException(const std::string& context) : GameException(GameErrorCode::GAME_STATE_ERROR, "Tidak diperbolehkan melakukan " + context + " sekarang"){}
+};
+
+#endif

include/core/GameEngine.hpp

@@ -0,0 +1,61 @@
+#ifndef GAME_ENGINE_HPP
+#define GAME_ENGINE_HPP
+
+#include <vector>
+#include <string>
+#include <random>
+
+// Forward Declarations - Hindari include di header untuk mencegah circular dependency
+class Player;
+class Board;
+class SaveLoadManager;
+class TransactionLogger;
+class Auction;
+class SkillCard; 
+template <typename T> class CardDeck; 
+
+class GameEngine {
+private:
+    // State Game
+    std::vector<Player*> players;
+    Board* board;
+    SaveLoadManager* saveLoadManager;
+    TransactionLogger* logger;
+    CardDeck<SkillCard>* skillDeck; // Sesuaikan dengan tipe dari Miguel
+
+    int currentTurnIdx; // Indeks pemain aktif (0-3)
+    int roundCount;     // Jumlah putaran yang sudah berjalan
+    bool diceRolled;
+    bool turnEnded;
+
+    // Utilitas Internal
+    void checkWinCondition();
+    void nextTurn();
+
+public:
+    GameEngine(Board *board, TransactionLogger *logger);
+    ~GameEngine();
+
+    // Kontrol Alur Permainan
+    void startNewGame(const std::vector<std::string>& playerNames);
+    void loadGame(const std::string& filePath);
+    void saveGame(const std::string& filePath);
+
+    // Logika Turn
+    void rollDice(int d1 = 0, int d2 = 0); // Support ATUR_DADU (overload)
+    void executeTileAction();
+    void endTurn();
+
+    // Getters untuk Integrasi (Dibutuhkan SaveLoadManager & Auction)
+    Player* getCurrentPlayer() const;
+    std::vector<Player*> getAllPlayers() const { return players; }
+    Board* getBoard() const { return board; }
+    int getCurrentRound() const { return roundCount; }
+    int getCurrentTurnIdx() const { return currentTurnIdx; }
+
+    // Flags
+    bool hasDiceRolled() const { return diceRolled; }
+    bool isTurnEnded() const { return turnEnded; }
+};
+
+#endif

include/core/Player.hpp

@@ -0,0 +1,66 @@
+#ifndef PLAYER_HPP
+#define PLAYER_HPP
+
+#include <string>
+#include <vector>
+#include "../models/Card.hpp"
+
+using namespace std;
+
+class PropertyTile;
+class SkillCard;
+
+class Player {
+private:
+    string username;
+    int money;
+    int position;
+    PlayerStatus status;
+    vector<PropertyTile*> ownedProperties;
+    vector<SkillCard*> handCards;
+
+    int activeDiscount;
+    int jailTurnsLeft;
+    int doubleStreak;
+    bool hasUsedCardThisTurn;
+    bool shieldActive;
+public:
+    Player(string username, int startingMoney);
+
+    void move(int steps);
+    void goToJail();
+    void declareBankruptcy();
+    void resetTurnFlags();
+
+    int getWealth() const; 
+    string getUsername() const;
+    int getMoney() const;
+    int getPosition() const;
+    PlayerStatus getStatus() const;
+    const vector<SkillCard*>& getHandCards() const;
+    const vector<PropertyTile*>& getOwnedProperties() const;
+    int getJailTurnsLeft() const;
+    int getDoubleStreak() const;
+    bool getHasUsedCardThisTurn() const;
+    bool isShieldActive() const;
+    int getActiveDiscountPercent() const;
+
+    void setHasUsedCardThisTurn(bool used);
+    void setActiveDiscountPercent(int percent);
+
+    void addCard(SkillCard* card);
+    void removeCard(int index);
+    void addProperty(PropertyTile* property);
+    void removeProperty(PropertyTile* property);
+
+    void setShieldActive(bool active);
+    void incrementDoubleStreak();
+    void decrementJailTurn();
+
+    // Operator Overloading
+    Player& operator+=(int amount);
+    Player& operator-=(int amount);
+    bool operator<(const Player& other) const; 
+};
+
+#endif