CharacterSheet.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once

 
#include <array>
#include <cstddef>
#include <filesystem>
#include <set>
#include <string>
#include <string_view>
#include <vector>
 
#include "Core/Rpg/Ability.h"
#include "Core/Rpg/CharacterOptions.h"
#include "Core/Rpg/Inventory.h"
#include "Core/Rpg/Skill.h"
 
namespace core {

struct ExperienceLevel {
    int level = 0;
    int experience = 0;
    int proficiencyBonus = 0;
};

struct ExperienceTable {
    std::vector<ExperienceLevel> levels;
    std::vector<std::string> errors;

    [[nodiscard]] int levelFor(int experiencePoints) const;
    [[nodiscard]] int proficiencyBonusAt(int level) const;
    [[nodiscard]] int thresholdAt(int level) const;
    [[nodiscard]] int maximumLevel() const;
};

struct CharacterCreationRules {
    int unarmoredArmorClass = 0;
    int maximumAbilityScore = 0;
    std::vector<std::string> errors;

    [[nodiscard]] bool ok() const {
        return unarmoredArmorClass > 0 && maximumAbilityScore > 0;
    }
};

[[nodiscard]] CharacterCreationRules loadCharacterCreationRules(const std::filesystem::path& path);

[[nodiscard]] ExperienceTable loadExperienceTable(const std::filesystem::path& path);

struct CharacterSheet {
    std::string name;
    std::string speciesId;
    std::string classId;
    std::string backgroundId;

    std::array<int, 6> abilities{};
 
    int level = 1;
    int experiencePoints = 0;
    int maximumHitPoints = 0;
    int currentHitPoints = 0;
    int armorClass = 0;
    float speedMeters = 0.0F;

    std::set<std::string> skillProficiencies;
    std::set<Ability> savingThrowProficiencies;

    [[nodiscard]] int ability(Ability which) const {
        return abilities[static_cast<std::size_t>(which)];
    }

    [[nodiscard]] int modifier(Ability which) const {
        return abilityModifier(ability(which));
    }

    [[nodiscard]] bool isDown() const {
        return currentHitPoints <= 0;
    }

    [[nodiscard]] float speedInTiles() const;
};

struct LevelUpResult {
    int previousLevel = 0;
    int newLevel = 0;
    int hitPointsGained = 0;
    int previousProficiencyBonus = 0;
    int newProficiencyBonus = 0;

    [[nodiscard]] bool gainedLevel() const {
        return newLevel > previousLevel;
    }
};

struct LoadedCharacterSheet {
    CharacterSheet sheet;
    Inventory inventory;
    std::vector<std::string> errors;
 
    [[nodiscard]] bool ok() const {
        return errors.empty();
    }
};

[[nodiscard]] LoadedCharacterSheet loadCharacterSheet(const std::filesystem::path& path,
                                                      const CharacterOptions& options,
                                                      const CharacterCreationRules& rules,
                                                      const ExperienceTable& table);

[[nodiscard]] int proficiencyBonus(const CharacterSheet& sheet, const ExperienceTable& table);

[[nodiscard]] int savingThrowModifier(const CharacterSheet& sheet, const ExperienceTable& table,
                                      Ability which);

struct SkillCheckModifier {
    int value = 0;
    bool found = false;
    bool proficient = false;
};
[[nodiscard]] SkillCheckModifier skillModifier(const CharacterSheet& sheet,
                                               const ExperienceTable& table,
                                               const SkillCatalog& catalog,
                                               std::string_view skillId);

[[nodiscard]] int maximumHitPointsFor(int hitDie, int level, int constitutionModifier);

LevelUpResult gainExperience(CharacterSheet& sheet, const ExperienceTable& table, int hitDie,
                             int amount);

[[nodiscard]] CharacterSheet buildCharacterSheet(
    std::string name, const std::array<int, 6>& baseAbilities, const Species* species,
    const PlayableClass* playableClass, const Background* background,
    const CharacterCreationRules& rules, const ExperienceTable& table);
 
}  // namespace core