Card.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "card/CardPlay.h"
#include "card/CardTypes.h"
#include "common/ECS.h"
#include "common/Module.h"
#include "common/Result.h"
 
#include <cstddef>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
namespace eve::graphics {
class Graphics;
}
 
namespace eve::resource {
class IResourceAccount;
}
 
namespace eve::card {
 
class CardControl;
 
struct CardPresentationSnapshot {
    std::string instanceId;
    std::string definitionId;
    std::string state;
    float x = 0.f;
    float y = 0.f;
    float width = 0.f;
    float height = 0.f;
    float angle = 0.f;
    float scale = 1.f;
    float alpha = 1.f;
    bool hovered = false;
    bool dragging = false;
    bool disabled = false;
    bool faceUp = true;
};
 
class EVENGINE_API_WORLD CardPlaneMapper {
public:
    void setLogicalRect(float x, float y, float width, float height);
    void setPlane(float ox, float oy, float oz, float ux, float uy, float uz,
                  float vx, float vy, float vz);
    bool mapRay(float ox, float oy, float oz, float dx, float dy, float dz);
    bool mapLayout(float x, float y);
    float getLogicalX() const { return resultLogicalX_; }
    float getLogicalY() const { return resultLogicalY_; }
    float getWorldX() const { return resultWorld_.x; }
    float getWorldY() const { return resultWorld_.y; }
    float getWorldZ() const { return resultWorld_.z; }
 
private:
    glm::vec3 origin_{0.f};
    glm::vec3 axisU_{1.f, 0.f, 0.f};
    glm::vec3 axisV_{0.f, 0.f, 1.f};
    glm::vec3 resultWorld_{0.f};
    float logicalX_ = 0.f;
    float logicalY_ = 0.f;
    float logicalWidth_ = 1.f;
    float logicalHeight_ = 1.f;
    float resultLogicalX_ = 0.f;
    float resultLogicalY_ = 0.f;
};
 
class EVENGINE_API_WORLD Card : public Module {
public:
    Module_REG(Card);
    Card();
    ~Card() override;
 
    // The two `vector<unique_ptr<...>>` members make the implicit copy operations
    // ill-formed (C2280) the moment a class-level dllexport instantiates them;
    // spell the four out so the export surface stays defined. Semantics unchanged:
    // a module instance was never copyable or assignable in practice.
    Card(const Card &)            = delete;
    Card &operator=(const Card &) = delete;
    // Out of line for the same reason as the constructor and destructor above: a
    // defaulted move in the class body instantiates the move of every member,
    // including the deleter of the incomplete `CardControl`.
    Card(Card &&) noexcept;
    Card &operator=(Card &&) noexcept;
 
    int registerCardsFromJson(const std::string &json);
    void clearCardDefinitions();
    int getCardDefinitionCount();
    std::string getCardDefinitionId(int index) const;
    bool hasCardDefinition(const std::string &id);
    bool setCardDefinition(const std::string &id, const std::string &name, const std::string &kind,
                           int cost, int attack, int health, float tintR, float tintG, float tintB);
    bool removeCardDefinition(const std::string &id);
    [[nodiscard]] eve::Result<void> setCardPlayCondition(const std::string &id, decision::Condition condition);
    std::string getCardDefinitionName(const std::string &id);
    std::string getCardDefinitionKind(const std::string &id);
    int getCardDefinitionCost(const std::string &id);
    int getCardDefinitionAttack(const std::string &id);
    int getCardDefinitionHealth(const std::string &id);
    float getCardDefinitionTintR(const std::string &id);
    float getCardDefinitionTintG(const std::string &id);
    float getCardDefinitionTintB(const std::string &id);
 
    LayoutConfig *newConfig();
    CardData *newCard(const std::string &defId);
    Deck *newDeck();
    Zone *newZone(const std::string &id, const std::string &label, float x, float y, float w, float h);
    Hand *newHand(LayoutConfig *cfg);
    CardPlaneMapper *newPlaneMapper();
 
    void setConfig(LayoutConfig *cfg);
    LayoutConfig *getConfig() const;
    int handCount() const;
    Hand *getHand(int index) const;
    Hand *findHand(const std::string &owner) const;
    int zoneCount() const;
    Zone *getZone(int index) const;
    Deck *getDeck() const;
    CardData *drawCard(const std::string &handOwner);
 
    [[nodiscard]] decision::ConditionResult evaluatePlay(const CardData          *card,
                                                         CardPlayConditionQueries queries = {}) const;
 
    [[nodiscard]] eve::Result<double> getCardAttribute(CardData &card, std::string_view attribute) const;
 
    [[nodiscard]] eve::Result<void> setCardAttribute(CardData &card, std::string_view attribute, double value) const;
 
    [[nodiscard]] eve::Result<effects::EffectHandle> applyEffect(CardData &card, const CardEffectDefinition &definition,
                                                                 eve::SubjectRef subject) const;
 
    [[nodiscard]] eve::Result<std::size_t> step(const eve::SimulationStep &step);
 
    [[nodiscard]] eve::Result<eve::transaction::TransactionReceipt> play(CardData                        &card,
                                                                         eve::resource::IResourceAccount &playerAccount,
                                                                         CardPlayComposition composition   = {},
                                                                         std::string         transactionId = {});
 
    int capturePresentation();
    int getPresentationCount() const;
    CardPresentationSnapshot *getPresentation(int index);
 
    void update(float dt, float mx, float my, bool down);
    void render(graphics::Graphics *gfx);
    void renderDeck(graphics::Graphics *gfx);
 
    void setBuiltInVisuals(bool enabled) { builtInVisuals_ = enabled; }
    bool getBuiltInVisuals() const { return builtInVisuals_; }
 
    [[nodiscard]] eve::Result<void> publishGameplay(const std::string &instanceId, const std::string &ownerId,
                                                    Hand *hand, eve::resource::IResourceAccount *account = nullptr);
    [[nodiscard]] eve::Result<void> unpublishGameplay(const std::string &instanceId);
    void clearGameplayControls();
    [[nodiscard]] int gameplayControlCount() const;
    [[nodiscard]] std::vector<std::string> gameplayInstances() const;
 
private:
    std::unique_ptr<CardControl> gameplay_;
 
    void beginTargeting(const std::string &sourceId, float x, float y);
    void updateTargeting(float x, float y, const std::string &targetId, bool valid);
    void cancelTargeting();
    void renderTargeting(graphics::Graphics *gfx);
    bool isTargeting() const { return targetingActive_; }
    bool isTargetValid() const { return targetingValid_; }
    std::string getTargetSource() const { return targetingSource_; }
    std::string getTargetId() const { return targetingId_; }
 
    void clearEvents();
    int getEventCount() const;
    std::string getEventType(int index) const;
    std::string getEventHand(int index) const;
    std::string getEventZone(int index) const;
    std::string getEventCardId(int index) const;
    std::string getEventReason(int index) const;
 
private:
    const CardDefinition *findDef(const std::string &id) const;
 
    std::unordered_map<std::string, CardDefinition> defs_;
    mutable std::vector<std::string> definitionView_;
    mutable bool definitionViewDirty_ = true;
    std::vector<std::unique_ptr<LayoutConfig>> configs_;
    std::vector<std::unique_ptr<CardPlaneMapper>> planeMappers_;
    std::vector<CardEvent> events_;
    std::vector<ecs::EntityHandle> cards_;
    std::vector<ecs::EntityHandle> decks_;
    std::vector<ecs::EntityHandle> zones_;
    std::vector<ecs::EntityHandle> hands_;
    std::vector<CardPresentationSnapshot> presentation_;
 
    LayoutConfig *activeConfig_ = nullptr;
    Deck *activeDeck_ = nullptr;
    int nextInstance_ = 1;
    bool builtInVisuals_ = true;
    bool targetingActive_ = false;
    bool targetingValid_ = false;
    float targetingStartX_ = 0.f;
    float targetingStartY_ = 0.f;
    float targetingX_ = 0.f;
    float targetingY_ = 0.f;
    std::string targetingSource_;
    std::string targetingId_;
};
 
}  // namespace eve::card