CardPlay.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "card/CardTypes.h"
#include "common/Container.h"
#include "decision/Condition.h"
#include "transaction/AtomicResourcePayment.h"
 
#include <functional>
#include <optional>
#include <string>
#include <string_view>
 
namespace eve::card {
 
struct CardPlayConditionQueries {
    using Resource  = std::function<std::optional<eve::Value>(std::string_view key)>;
    using Authority = std::function<std::optional<bool>(std::string_view scope)>;
    using Policy =
        std::function<std::optional<decision::ConditionResult>(std::string_view name, const eve::Value& arguments)>;
 
    Resource  resource;
    Authority authority;
    Policy    policy;
};
 
class CardPlayConditionContext final : public decision::EvaluationContext {
public:
    CardPlayConditionContext(const CardData* card, const CardDefinition& definition,
                             CardPlayConditionQueries queries = {});
 
    [[nodiscard]] std::optional<eve::Value> value(std::string_view key) const override;
    [[nodiscard]] std::optional<bool> hasTag(std::string_view tag) const override;
    [[nodiscard]] std::optional<eve::Value> attribute(std::string_view key) const override;
    [[nodiscard]] std::optional<eve::Value> resource(std::string_view key) const override;
    [[nodiscard]] std::optional<eve::Value> state(std::string_view key) const override;
    [[nodiscard]] std::optional<bool> authority(std::string_view scope) const override;
    [[nodiscard]] std::optional<decision::ConditionResult> policy(std::string_view  name,
                                                                  const eve::Value& arguments) const override;
 
private:
    const CardData*          card_       = nullptr;
    const CardDefinition*    definition_ = nullptr;
    CardPlayConditionQueries queries_;
};
 
class EVENGINE_API_WORLD CardPlayConditionAdapter {
public:
    [[nodiscard]] static decision::ConditionResult evaluate(const CardData* card, const CardDefinition& definition,
                                                            const decision::Condition& condition,
                                                            CardPlayConditionQueries   queries = {});
};
 
class CardPlayParticipant final : public eve::transaction::ITransactionParticipant {
public:
    explicit CardPlayParticipant(CardData& card);
 
    [[nodiscard]] std::string_view name() const noexcept override { return "card-play-effect"; }
    [[nodiscard]] eve::Result<void> prepare(const eve::transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> commit(const eve::transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> rollback(const eve::transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> compensate(const eve::transaction::TransactionContext& context) override;
 
private:
    CardData& card_;
    CardState previousState_ = CardState::Hand;
    bool      prepared_      = false;
    bool      committed_     = false;
};
 
struct CardPlayComposition {
    CardPlayConditionQueries                   conditionQueries;
    eve::container::IContainer*                source      = nullptr;
    eve::container::IContainer*                destination = nullptr;
    std::optional<eve::container::SlotIndex>   sourceSlot;
    std::optional<eve::container::SlotIndex>   destinationSlot;
    eve::transaction::ITransactionParticipant* effect = nullptr;
};
 
struct CardPlayRequest {
    CardData*                        card          = nullptr;
    const CardDefinition*            definition    = nullptr;
    eve::resource::IResourceAccount* playerAccount = nullptr;
    CardPlayComposition              composition;
    std::string                      transactionId;
};
 
class EVENGINE_API_WORLD CardPlayPaymentAdapter final {
public:
    [[nodiscard]] static eve::Result<eve::transaction::TransactionReceipt> play(CardPlayRequest request);
 
    [[nodiscard]] static eve::Result<std::optional<eve::resource::CostSpec>> manaCost(const CardDefinition& definition);
 
    [[nodiscard]] static eve::Result<eve::transaction::TransactionReceipt> play(
        CardData& card, const CardDefinition& definition, eve::resource::IResourceAccount& playerAccount,
        std::string transactionId = {});
};
 
}  // namespace eve::card