CardTypes.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "attributes/AttributeProjection.h"
#include "card/CardEffects.h"
#include "common/ECS.h"
#include "common/definitions/DefinitionRuntime.h"
#include "decision/Condition.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Texture;
}  // namespace eve::graphics
 
namespace eve::card {
 
enum class CardState : uint8_t {
    Deck,
    Hand,
    Hovered,
    Dragging,
    Returning,
    Played,
    Discarded,
    Disabled,
};
 
EVENGINE_API_WORLD const char *cardStateName(CardState state);
 
struct LayoutConfig {
    float cardW = 110.f;
    float cardH = 150.f;
    float spacing = 26.f;
    float handX = 640.f;
    float handY = 640.f;
    float arcHeight = 46.f;
    float rotationAngle = 14.f;
    bool  hoverRotation = true;
    float hoverScale = 1.22f;
    float hoverLift = 46.f;
    float hoverSpeed = 0.18f;
    float motionSpeed = 0.12f;
    float disabledAlpha = 0.35f;
    bool  showZones = true;
    float deckX = 360.f;
    float deckY = 640.f;
    float dragThreshold = 64.f;
};
 
struct CardDefinition {
    std::string id;
    std::string name;
    std::string kind = "creature";  // "creature" | "spell" | ...
    int         cost = 0;
    int         attack = 0;
    int         health = 0;
    glm::vec3   tint{0.62f, 0.50f, 0.40f};
    eve::decision::Condition playCondition;
    std::vector<std::string> tags;
};
 
class EVENGINE_API_WORLD CardData : public ecs::Entity {
public:
    ENTITY(CardData, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Identity {
        std::string id;
        std::string definitionId;
        std::string name;
        std::string kind = "creature";
    };
    struct Stats {
        int cost = 0;
        int attack = 0;
        int health = 0;
    };
    struct Attributes {
        eve::attributes::AttributeProjection values;
    };
    struct Effects {
        CardEffectAdapter values;
    };
    struct Visual {
        bool faceUp = true;
        bool disabled = false;
        glm::vec3 tint{0.62f, 0.50f, 0.40f};
        graphics::Texture *texture = nullptr;
    };
    struct Layout {
        float x = 0.f;
        float y = 0.f;
        float w = 0.f;
        float h = 0.f;
        float angle = 0.f;
        float scale = 1.f;
        float alpha = 1.f;
    };
    struct State {
        CardState phase = CardState::Deck;
        bool hovered = false;
        bool dragging = false;
    };
 
    struct DefinitionBinding {
        eve::definition::InstanceIdentity identity;
        eve::definition::ReloadPolicy     reloadPolicy = eve::definition::ReloadPolicy::KeepInstanceValues;
        bool                              active       = true;
    };
 
    COMPONENT(Identity, identity)
    COMPONENT(Stats, stats)
    COMPONENT(Attributes, attributes)
    COMPONENT(Effects, effects)
    COMPONENT(Visual, visual)
    COMPONENT(Layout, layout)
    COMPONENT(State, state)
    COMPONENT(DefinitionBinding, definitionBinding)
 
    
    static CardData *createCard();
 
    bool hit(float px, float py);
    std::string describe();
};
 
class EVENGINE_API_WORLD Deck : public ecs::Entity {
public:
    ENTITY(Deck, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Membership {
        std::vector<CardData *> cards;
    };
 
    COMPONENT(Membership, membership)
 
    
    static Deck *createDeck();
 
    void push(CardData *c) { membership()->cards.push_back(c); }
    CardData *draw();
    CardData *peek();
    void clear() { membership()->cards.clear(); }
    void shuffle();
    int  count() { return static_cast<int>(membership()->cards.size()); }
    bool isEmpty() { return membership()->cards.empty(); }
    CardData *get(int index);
};
 
class EVENGINE_API_WORLD Zone : public ecs::Entity {
public:
    ENTITY(Zone, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Rect {
        std::string id;
        std::string label;
        float x = 0.f, y = 0.f, w = 0.f, h = 0.f;
        glm::vec3 color{0.30f, 0.60f, 0.30f};
        float alpha = 0.16f;
        bool  enabled = true;
    };
    struct Filter {
        std::vector<std::string> acceptKinds;
    };
 
    COMPONENT(Rect, rect)
    COMPONENT(Filter, filter)
 
    
    static Zone *createZone();
 
    bool contains(float px, float py);
    bool accepts(CardData *card);
    void render(graphics::Graphics *gfx, bool showLabel);
};
 
struct CardEvent {
    std::string type;
    std::string hand;
    std::string zoneId;
    std::string cardId;
    std::string reason;
};
 
class EVENGINE_API_WORLD Hand : public ecs::Entity {
public:
    ENTITY(Hand, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Meta {
        std::string owner = "player";
        LayoutConfig *config = nullptr;
        bool faceDown = false;
        bool peek = false;
        bool interactive = true;
    };
    struct Membership {
        std::vector<CardData *> cards;
    };
    struct Drag {
        CardData *card = nullptr;
        CardData *press = nullptr;
        float ox = 0.f, oy = 0.f;
        float pressX = 0.f, pressY = 0.f;
        bool wasDown = false;
    };
 
    COMPONENT(Meta, meta)
    COMPONENT(Membership, membership)
    COMPONENT(Drag, drag)
 
    
    static Hand *createHand();
 
    void addCard(CardData *c);
    bool removeCard(CardData *c);
    void clear();
    int  count() { return static_cast<int>(membership()->cards.size()); }
    CardData *get(int index);
    CardData *find(const std::string &id);
    CardData *pick(float px, float py);
 
    void slotTransform(int i, int n, float &ox, float &oy, float &angle);
 
    void update(float dt, float mx, float my, bool down, const std::vector<Zone *> &zones,
                std::vector<CardEvent> &out);
 
    void render(graphics::Graphics *gfx);
};
 
void printCentered(graphics::Graphics *gfx, const std::string &text, float cx, float cy, float scale,
                   const glm::vec4 &color);
void renderCardBack(graphics::Graphics *gfx, float x, float y, float w, float h, float angle, float a);
void renderCard(graphics::Graphics *gfx, const CardData &card, const LayoutConfig &cfg, bool back);
 
}  // namespace eve::card