RPG.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "rpg/LevelSystem.h"
#include "rpg/BattleVictory.h"
#include "rpg/RPGActor.h"
#include "rpg/StatusTypes.h"
#include "rpg/SkillTypes.h"
#include "rpg/VitalsSystem.h"
 
#include <memory>
#include <string>
#include <vector>
 
namespace eve {
class SubjectRef;
namespace inventory {
class Bag;
class EquipmentSet;
}
}  // namespace eve
 
namespace eve::rpg {
 
struct SettlementContext;
class Tracker;
class Battle;
class BattleControl;
class ProductControl;
class Party;
class GameState;
class WorldState;
class StoryEventSession;
class RpgStorySession;
struct WorldLootRequest;
 
class EVENGINE_API_PLATFORM RPG : public Module {
public:
    Module_REG(RPG);
    RPG() = default;
    ~RPG() override = default;
 
    RPGActor *newActor();
    Party *newParty();
 
    int registerEffectsFromJson(const std::string &json);
    void clearEffectDefinitions();
    int getEffectDefinitionCount();
 
    int registerSkillsFromJson(const std::string &json);
    void clearSkillDefinitions();
    int getSkillDefinitionCount();
 
    int registerQuestsFromJson(const std::string &json);
    [[nodiscard]] eve::Result<int> replaceQuestsFromJson(const std::string &json);
    void clearQuestDefinitions();
    int getQuestDefinitionCount();
    bool hasQuestDefinition(const std::string &id) const;
    [[nodiscard]] eve::Result<int> claimQuestRewards(Tracker *tracker, GameState *gameState,
                                                      inventory::Bag *bag, const std::string &questId);
    [[nodiscard]] eve::Result<int> collectWorldLoot(Tracker *tracker, GameState *gameState,
                                                     inventory::Bag *bag,
                                                     const WorldLootRequest &request);
    [[nodiscard]] eve::Result<BattleVictoryReceipt>
    settleBattleVictory(RPGActor *actor, Tracker *tracker, GameState *gameState,
                        const BattleVictoryRequest &request);
    [[nodiscard]] eve::Result<int> buyFromShop(GameState *gameState, inventory::Bag *bag,
                                                const std::string &currencyId,
                                                const std::string &itemId, int quantity,
                                                double unitPrice);
    [[nodiscard]] eve::Result<int> sellToShop(GameState *gameState, inventory::Bag *bag,
                                               const std::string &currencyId,
                                               const std::string &itemId, int quantity,
                                               double unitPrice);
    [[nodiscard]] eve::Result<int> replaceShopOffersFromJson(const std::string &json);
    int getShopOfferCount() const;
    void clearShopOffers();
    bool hasShopOffer(const std::string &offerId) const;
    std::string getShopOfferId(int index) const;
    std::string getShopOfferItemId(int index) const;
    std::string getShopOfferName(int index) const;
    std::string getShopOfferDescription(int index) const;
    int getShopOfferBuyPrice(int index) const;
    int getShopOfferSellPrice(int index) const;
    [[nodiscard]] eve::Result<int> buyShopOffer(GameState *gameState, inventory::Bag *bag,
                                                const std::string &currencyId,
                                                const std::string &offerId, int quantity);
    [[nodiscard]] eve::Result<int> sellShopOffer(GameState *gameState, inventory::Bag *bag,
                                                 const std::string &currencyId,
                                                 const std::string &offerId, int quantity);
    [[nodiscard]] eve::Result<int> replaceEncountersFromJson(const std::string &json);
    void clearEncounters();
    bool hasEncounter(const std::string &encounterId) const;
    int getEncounterMemberCount(const std::string &encounterId) const;
    RPGActor *newEncounterActor(const std::string &encounterId);
    RPGActor *newEncounterMemberActor(const std::string &encounterId, int memberIndex);
    std::string getEncounterDisplayName(const std::string &encounterId) const;
    double getEncounterMaxHp(const std::string &encounterId) const;
    std::string getEncounterMemberDisplayName(const std::string &encounterId, int memberIndex) const;
    double getEncounterMemberMaxHp(const std::string &encounterId, int memberIndex) const;
    [[nodiscard]] eve::Result<int> replaceBattleTacticsFromJson(const std::string &json);
    void clearBattleTactics();
    [[nodiscard]] eve::Result<std::string> queueBattleTactic(Battle *battle, RPGActor *actor,
                                                             const std::string &tacticsId);
    [[nodiscard]] eve::Result<int> replaceStoryEventsFromJson(const std::string &json);
    void clearStoryEvents();
    int getStoryEventCount() const;
    bool hasStoryEvent(const std::string &eventId) const;
    StoryEventSession *newStoryEventSession();
    [[nodiscard]] eve::Result<int> replaceStoriesFromDnut(const std::string &source, const std::string &path);
    void clearStories();
    int getStoryCount() const;
    bool hasStory(const std::string &storyId) const;
    RpgStorySession *newStorySession();
    [[nodiscard]] eve::Result<BattleVictoryReceipt>
    settleEncounterVictory(RPGActor *actor, Tracker *tracker, GameState *gameState,
                           const std::string &encounterId, const std::string &mapId,
                           const std::string &objectId);
    Tracker *newTracker();
 
    int getLevelUpEventCount() const;
    RPGActor *getLevelUpEventActor(int index) const;
    int getLevelUpEventPreviousLevel(int index) const;
    int getLevelUpEventNewLevel(int index) const;
 
    int getVitalsEventCount() const;
    RPGActor *getVitalsEventActor(int index) const;
    std::string getVitalsEventResource(int index) const;
    std::string getVitalsEventAction(int index) const;
    double getVitalsEventAmount(int index) const;
    std::string getVitalsEventSource(int index) const;
    double getVitalsEventCurrent(int index) const;
    double getVitalsEventMax(int index) const;
 
    int registerItemStatsFromJson(const std::string &itemId, const std::string &json);
    void clearItemStats(const std::string &itemId);
    void clearAllItemStats();
    int getItemStatCount();
    int syncEquipModifiers(RPGActor *actor, inventory::EquipmentSet *equip);
 
    int registerLootTablesFromJson(const std::string &json);
    void clearLootTables();
    int getLootTableCount();
    int rollLoot(const std::string &tableId, inventory::Bag *bag, int seed);
 
    int registerTraitsFromJson(const std::string &json);
    void clearTraitDefinitions();
    int getTraitDefinitionCount();
 
    int registerClassesFromJson(const std::string &json);
    void clearClassDefinitions();
    int getClassDefinitionCount();
 
    int registerSkillDamage(const std::string &skillId, const std::string &damageType,
                            const std::string &formula, const std::string &element,
                            double critChance, int hitChance);
    void clearSkillDamage();
    Battle *newBattle();
    [[nodiscard]] Result<std::unique_ptr<BattleControl>> newBattleControl(Battle *battle,
                                                                          SubjectRef instance);
    [[nodiscard]] Result<std::unique_ptr<ProductControl>> newProductControl(
        SubjectRef instance, GameState *gameState, Tracker *tracker, inventory::Bag *bag);
 
    GameState *newGameState();
 
    WorldState *newWorldState(GameState *gameState);
    GameState *globalGameState();
 
    void update(float dt);
 
    int getTickEventCount() const;
    RPGActor *getTickEventActor(int index) const;
    int getTickEventInstanceId(int index) const;
    std::string getTickEventEffectId(int index) const;
    std::string getTickEventSource(int index) const;
    int getTickEventStacks(int index) const;
 
    int getStatusChangeEventCount() const;
    RPGActor *getStatusChangeEventActor(int index) const;
    int getStatusChangeEventInstanceId(int index) const;
    std::string getStatusChangeEventEffectId(int index) const;
    std::string getStatusChangeEventSource(int index) const;
    std::string getStatusChangeEventAction(int index) const;
    int getStatusChangeEventStacks(int index) const;
    std::string getStatusChangeEventReason(int index) const;
 
    int getCastEventCount() const;
    RPGActor *getCastEventCaster(int index) const;
    RPGActor *getCastEventTarget(int index) const;
    std::string getCastEventSkillId(int index) const;
 
    SettlementContext *newSettlementContext();
    void runSettlement(const std::string &pipeline, SettlementContext *ctx);
    int getSettlementStageCount(const std::string &pipeline);
    bool hasSettlementStage(const std::string &pipeline, const std::string &stage);
    bool setSettlementStageEnabled(const std::string &pipeline, const std::string &stage,
                                    bool enabled);
    bool setSettlementStagePriority(const std::string &pipeline, const std::string &stage,
                                     int priority);
    bool removeSettlementStage(const std::string &pipeline, const std::string &stage);
    void clearSettlementPipeline(const std::string &pipeline);
 
private:
    std::vector<StatusTickEvent> ticks_;
    std::vector<StatusChangeEvent> changes_;
    std::vector<SkillCastEvent> casts_;
    std::vector<LevelUpEvent> levelUps_;
    std::vector<VitalsEvent> vitals_;
};
 
}  // namespace eve::rpg