Scoreboard.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
#include "mc/world/scores/PlayerScoreSetFunction.h"
 
// auto generated inclusion list
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/server/commands/CommandOperator.h"
#include "mc/server/commands/CommandSoftEnumRegistry.h"
#include "mc/world/events/PlayerScoreboardEventListener.h"
#include "mc/world/events/ScoreboardEventCoordinator.h"
#include "mc/world/scores/IdentityDictionary.h"
#include "mc/world/scores/ObjectiveSortOrder.h"
#include "mc/world/scores/ScoreboardId.h"
#include "mc/world/scores/ScoreboardOperationResult.h"
 
// auto generated forward declare list
// clang-format off
class Actor;
class DisplayObjective;
class Objective;
class ObjectiveCriteria;
class PacketSender;
class Player;
class ScoreboardIdentityRef;
struct ActorUniqueID;
struct PlayerScore;
struct PlayerScoreboardId;
struct ScoreInfo;
// clang-format on
 
class Scoreboard {
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 8, ::CommandSoftEnumRegistry>                                            mRegistry;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::std::string, ::DisplayObjective>>             mDisplayObjectives;
    ::ll::TypedStorage<8, 256, ::IdentityDictionary>                                               mIdentityDict;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::ScoreboardId, ::ScoreboardIdentityRef>>       mIdentityRefs;
    ::ll::TypedStorage<1, 1, bool>                                                                 mShouldUpdateUI;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::std::string, ::std::unique_ptr<::Objective>>> mObjectives;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<uint64, ::Bedrock::NonOwnerPointer<::Objective>>>
        mObjectivesHashLookup;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::std::string, ::std::unique_ptr<::ObjectiveCriteria>>> mCriteria;
    ::ll::TypedStorage<8, 96, ::ScoreboardEventCoordinator>    mScoreboardEventCoordinator;
    ::ll::TypedStorage<8, 72, ::PlayerScoreboardEventListener> mPlayerListener;
    // NOLINTEND
 
public:
    // prevent constructor by default
    Scoreboard();
 
public:
    LLAPI int modifyPlayerScore(
        ScoreboardOperationResult& result,
        ScoreboardId const&        id,
        Objective&                 objective,
        int                        scoreValue,
        PlayerScoreSetFunction     action
    );
 
    LLNDAPI ScoreboardId getId(PlayerScoreboardId const& playerId) const;
 
    [[nodiscard]] std::vector<::Objective const*> getObjectives() const {
        std::vector<::Objective const*> result;
        for (auto const& [name, objective] : *mObjectives) {
            result.emplace_back(objective.get());
        }
        return result;
    }
 
    LLAPI bool resetPlayerScore(::ScoreboardId const& id, ::Objective& objective);
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~Scoreboard() = default;
 
    virtual ::DisplayObjective const* setDisplayObjective(
        ::std::string const&       displaySlotName,
        ::Objective const&         objective,
        ::ObjectiveSortOrder const order
    );
 
    virtual ::Objective* clearDisplayObjective(::std::string const& displaySlotName);
 
    virtual ::ScoreboardId const& createScoreboardId(::Player const& player);
 
    virtual ::ScoreboardId const& createScoreboardId(::Actor const& entity);
 
    virtual ::ScoreboardId const& createScoreboardId(::std::string const& fakePlayer);
 
    virtual void onObjectiveAdded(::Objective const& objective);
 
    virtual void onObjectiveRemoved(::Objective& objective);
 
    virtual void onScoreChanged(::ScoreboardId const& id, ::Objective const& obj);
 
    virtual void onPlayerScoreRemoved(::ScoreboardId const& id, ::Objective const& objective);
 
    virtual void onPlayerJoined(::Player const& player);
 
    virtual void onPlayerIdentityUpdated(::PlayerScoreboardId const& playerId);
 
    virtual void tick();
 
    virtual void setPacketSender(::PacketSender* sender);
 
    virtual void writeToLevelStorage();
 
    virtual bool isClientSide() const;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI explicit Scoreboard(::CommandSoftEnumRegistry registry);
 
    MCAPI ::Objective*
    addObjective(::std::string const& name, ::std::string const& displayName, ::ObjectiveCriteria const& criteria);
 
    MCNAPI int applyPlayerOperation(
        ::ScoreboardOperationResult&   result,
        ::std::vector<::ScoreboardId>& sourceErrorIds,
        ::ScoreboardId const&          target,
        ::Objective&                   targetObjective,
        ::std::vector<::ScoreboardId>& selector,
        ::Objective&                   objective,
        ::CommandOperator              opCode
    );
 
#ifdef LL_PLAT_C
    MCNAPI bool clearScoreboardIdentity(::ScoreboardId const& scoreboardId);
#endif
 
    MCAPI ::ObjectiveCriteria* getCriteria(::std::string const& criteriaName) const;
 
    MCNAPI ::std::vector<::PlayerScore> getDisplayInfoFiltered(::std::string const& displaySlot) const;
 
#ifdef LL_PLAT_C
    MCNAPI ::std::vector<::PlayerScore> getDisplayInfoSorted(
        ::std::string const&                                                       displaySlot,
        ::std::function<void(::ObjectiveSortOrder, ::std::vector<::PlayerScore>&)> sortMethod
    ) const;
#endif
 
    MCAPI ::DisplayObjective const* getDisplayObjective(::std::string const& displaySlotName) const;
 
    MCAPI ::std::vector<::std::string> getDisplayObjectiveSlotNames() const;
 
    MCAPI ::Objective* getObjective(::std::string const& name) const;
 
    MCAPI ::ScoreboardId const& getScoreboardId(::Actor const& entity) const;
 
    MCNAPI ::ScoreboardId const& getScoreboardId(::ActorUniqueID const& entityId) const;
 
    MCAPI ::ScoreboardId const& getScoreboardId(::std::string const& name) const;
 
    MCAPI ::std::vector<::ScoreboardId> getTrackedIds() const;
 
    MCNAPI ::ScoreboardIdentityRef const&
    registerScoreboardIdentity(::ScoreboardId const& scoreboardId, ::PlayerScoreboardId const& playerId);
 
    MCAPI bool removeObjective(::Objective* objective);
 
    MCNAPI void removeScoreListener(::Player const& player, ::std::string const& objective);
 
    MCAPI void resetPlayerScore(::ScoreboardId const& id);
 
    MCAPI ::std::optional<::ScoreInfo> tryGetIdScore(::ScoreboardId const& id, uint64 const& objectiveHash) const;
    // NOLINTEND
 
public:
    // static variables
    // NOLINTBEGIN
    MCAPI static ::std::string const& DEFAULT_CRITERIA();
 
    MCNAPI static ::std::string const& DISPLAY_SLOT_BELOWNAME();
 
    MCNAPI static ::std::string const& DISPLAY_SLOT_LIST();
 
    MCNAPI static ::std::string const& DISPLAY_SLOT_SIDEBAR();
 
    MCNAPI static char const*& OBJECTIVES_ENUM();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(::CommandSoftEnumRegistry registry);
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI ::DisplayObjective const* $setDisplayObjective(
        ::std::string const&       displaySlotName,
        ::Objective const&         objective,
        ::ObjectiveSortOrder const order
    );
 
    MCNAPI ::Objective* $clearDisplayObjective(::std::string const& displaySlotName);
 
    MCNAPI ::ScoreboardId const& $createScoreboardId(::Player const& player);
 
    MCNAPI ::ScoreboardId const& $createScoreboardId(::Actor const& entity);
 
    MCNAPI ::ScoreboardId const& $createScoreboardId(::std::string const& fakePlayer);
 
    MCNAPI void $onObjectiveAdded(::Objective const& objective);
 
    MCNAPI void $onObjectiveRemoved(::Objective& objective);
 
    MCNAPI void $onScoreChanged(::ScoreboardId const& id, ::Objective const& obj);
 
    MCNAPI void $onPlayerScoreRemoved(::ScoreboardId const& id, ::Objective const& objective);
 
    MCNAPI void $onPlayerJoined(::Player const& player);
 
    MCNAPI void $onPlayerIdentityUpdated(::PlayerScoreboardId const& playerId);
 
    MCNAPI void $tick();
 
    MCNAPI void $setPacketSender(::PacketSender* sender);
 
    MCNAPI void $writeToLevelStorage();
 
    MCNAPI bool $isClientSide() const;
 
 
    // NOLINTEND
};