ScoreboardCommand.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/server/commands/Command.h"
#include "mc/server/commands/CommandOperator.h"
#include "mc/server/commands/CommandWildcardInt.h"
#include "mc/server/commands/WildcardCommandSelector.h"
#include "mc/world/scores/ObjectiveSortOrder.h"
#include "mc/world/scores/PlayerScoreSetFunction.h"
 
// auto generated forward declare list
// clang-format off
class Actor;
class CommandOrigin;
class CommandOutput;
class CommandRegistry;
class Objective;
class Scoreboard;
struct ActorUniqueID;
struct ScoreboardId;
// clang-format on
 
class ScoreboardCommand : public ::Command {
public:
    // ScoreboardCommand inner types declare
    // clang-format off
    struct InitProxy;
    struct SetScoreOutput;
    // clang-format on
 
    // ScoreboardCommand inner types define
    enum class Action : int {
        Invalid    = 0,
        Add        = 1,
        List       = 2,
        Operation  = 3,
        Random     = 4,
        Remove     = 5,
        Reset      = 6,
        Set        = 7,
        SetDisplay = 8,
        Test       = 9,
    };
 
    enum class Category : int {
        Objectives = 0,
        Players    = 1,
    };
 
    struct InitProxy {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::Scoreboard&> mScoreboard;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        InitProxy& operator=(InitProxy const&);
        InitProxy(InitProxy const&);
        InitProxy();
    };
 
    struct SetScoreOutput {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<4, 4, int>            mSuccessCount;
        ::ll::TypedStorage<4, 4, int>            mFirstNewScore;
        ::ll::TypedStorage<8, 32, ::std::string> mFirstSuccess;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCAPI ~SetScoreOutput();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCFOLD void $dtor();
        // NOLINTEND
    };
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<4, 4, ::ScoreboardCommand::Category>        mCategory;
    ::ll::TypedStorage<4, 4, ::ScoreboardCommand::Action>          mAction;
    ::ll::TypedStorage<8, 32, ::std::string>                       mObjective;
    ::ll::TypedStorage<8, 32, ::std::string>                       mSourceObjective;
    ::ll::TypedStorage<1, 1, ::ObjectiveSortOrder>                 mOrder;
    ::ll::TypedStorage<8, 32, ::std::string>                       mCriteria;
    ::ll::TypedStorage<8, 32, ::std::string>                       mName;
    ::ll::TypedStorage<8, 32, ::std::string>                       mDisplayName;
    ::ll::TypedStorage<8, 200, ::WildcardCommandSelector<::Actor>> mTargets;
    ::ll::TypedStorage<8, 200, ::WildcardCommandSelector<::Actor>> mSources;
    ::ll::TypedStorage<1, 1, ::CommandOperator>                    mOperator;
    ::ll::TypedStorage<4, 8, ::CommandWildcardInt>                 mMin;
    ::ll::TypedStorage<4, 8, ::CommandWildcardInt>                 mMax;
    ::ll::TypedStorage<4, 4, int>                                  mRandMin;
    ::ll::TypedStorage<4, 4, int>                                  mRandMax;
    ::ll::TypedStorage<4, 4, int>                                  mValue;
    ::ll::TypedStorage<1, 1, bool>                                 mTargetsSet;
    // NOLINTEND
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual void execute(::CommandOrigin const& origin, ::CommandOutput& output) const /*override*/;
 
    virtual ~ScoreboardCommand() /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI ScoreboardCommand();
 
    MCAPI void _generateCumulativeOutput(
        ::ScoreboardCommand::SetScoreOutput const& cumulativeOutput,
        ::Objective const&                         objective,
        ::CommandOutput&                           output
    ) const;
 
    MCAPI ::Objective* _getObjective(
        ::Scoreboard const&  scoreboard,
        ::std::string const& name,
        bool                 forWrite,
        ::CommandOutput&     output
    ) const;
 
    MCAPI ::std::vector<::ScoreboardId> _getScoreboardIdsForSelector(
        ::Scoreboard&                             scoreboard,
        ::WildcardCommandSelector<::Actor> const& selector,
        ::CommandOrigin const&                    origin,
        ::CommandOutput&                          output,
        bool                                      shouldCreateMissingId
    ) const;
 
    MCAPI bool _getSelectorResultsForObjective(
        ::std::vector<::ScoreboardId>&            results,
        ::Scoreboard&                             scoreboard,
        ::WildcardCommandSelector<::Actor> const& selector,
        ::Objective&                              objective,
        ::CommandOrigin const&                    origin,
        ::CommandOutput&                          output,
        bool                                      shouldCreateMissingId
    ) const;
 
    MCAPI void addObjective(
        ::Scoreboard&        scoreboard,
        ::std::string const& name,
        ::std::string const& criteriaName,
        ::std::string const& displayName,
        ::CommandOutput&     output
    ) const;
 
    MCAPI void addPlayerScore(
        ::Scoreboard&                                                 scoreboard,
        ::PlayerScoreSetFunction                                      fn,
        ::ScoreboardId const&                                         targetId,
        ::Objective&                                                  objective,
        ::std::function<::std::string const&(::ActorUniqueID)> const& playerNameResolver,
        ::CommandOutput&                                              output,
        ::ScoreboardCommand::SetScoreOutput&                          cumulativeOutput
    ) const;
 
    MCAPI bool applyPlayerOperation(
        ::Scoreboard&                                                 scoreboard,
        ::std::function<::std::string const&(::ActorUniqueID)> const& playerNameResolver,
        ::ScoreboardId const&                                         targetId,
        ::Objective&                                                  targetObjective,
        ::Objective&                                                  objective,
        ::CommandOrigin const&                                        origin,
        ::CommandOutput&                                              output,
        ::ScoreboardCommand::SetScoreOutput&                          cumulativeOutput
    ) const;
 
    MCAPI void listObjectives(::Scoreboard const& scoreboard, ::CommandOutput& output) const;
 
    MCAPI void listPlayers(
        ::Scoreboard&                                                 scoreboard,
        ::ScoreboardId const&                                         targetId,
        ::std::function<::std::string const&(::ActorUniqueID)> const& playerNameResolver,
        ::CommandOutput&                                              output
    ) const;
 
    MCAPI void players(::Scoreboard& scoreboard, ::CommandOrigin const& origin, ::CommandOutput& output) const;
 
    MCAPI void removeObjective(::Scoreboard& scoreboard, ::std::string const& name, ::CommandOutput& output) const;
 
    MCAPI void resetPlayer(
        ::Scoreboard&                                                 scoreboard,
        ::ScoreboardId const&                                         targetId,
        ::Objective*                                                  objective,
        ::std::function<::std::string const&(::ActorUniqueID)> const& playerNameResolver,
        ::CommandOutput&                                              output
    ) const;
 
    MCAPI void setDisplayObjective(
        ::Scoreboard&        scoreboard,
        ::std::string const& displaySlotName,
        ::std::string const& objectiveName,
        ::ObjectiveSortOrder order,
        ::CommandOutput&     output
    ) const;
 
    MCAPI bool setPlayerRandomScore(
        ::Scoreboard&                                                 scoreboard,
        ::ScoreboardId const&                                         targetId,
        ::Objective&                                                  targetObjective,
        ::std::function<::std::string const&(::ActorUniqueID)> const& playerNameResolver,
        ::CommandOutput&                                              output,
        ::ScoreboardCommand::SetScoreOutput&                          cumulativeOutput
    ) const;
 
    MCAPI void testPlayerScore(
        ::ScoreboardId const&                                         targetId,
        ::Objective&                                                  objective,
        ::std::function<::std::string const&(::ActorUniqueID)> const& playerNameResolver,
        ::CommandOutput&                                              output
    ) const;
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCAPI static ::std::vector<::std::string> _getNonSortableDisplaySlots(::Scoreboard& scoreboard);
 
    MCAPI static ::std::vector<::std::string> _getSortableDisplaySlots(::Scoreboard& scoreboard);
 
    MCAPI static void setup(::CommandRegistry& registry, ::ScoreboardCommand::InitProxy&& dependencies);
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor();
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCAPI void $execute(::CommandOrigin const& origin, ::CommandOutput& output) const;
 
 
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};