/****************************************************************************
** Meta object code from reading C++ file 'player.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.9.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../cockatrice/src/game/player/player.h"
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'player.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.9.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN10PlayerAreaE_t {};
} // unnamed namespace

template <> constexpr inline auto PlayerArea::qt_create_metaobjectdata<qt_meta_tag_ZN10PlayerAreaE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PlayerArea",
        "updateBg",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'updateBg'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PlayerArea, qt_meta_tag_ZN10PlayerAreaE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject PlayerArea::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PlayerAreaE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PlayerAreaE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10PlayerAreaE_t>.metaTypes,
    nullptr
} };

void PlayerArea::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PlayerArea *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->updateBg(); break;
        default: ;
        }
    }
    (void)_a;
}

const QMetaObject *PlayerArea::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *PlayerArea::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PlayerAreaE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "QGraphicsItem"))
        return static_cast< QGraphicsItem*>(this);
    if (!strcmp(_clname, "org.qt-project.Qt.QGraphicsItem"))
        return static_cast< QGraphicsItem*>(this);
    return QObject::qt_metacast(_clname);
}

int PlayerArea::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN6PlayerE_t {};
} // unnamed namespace

template <> constexpr inline auto Player::qt_create_metaobjectdata<qt_meta_tag_ZN6PlayerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Player",
        "openDeckEditor",
        "",
        "const DeckLoader*",
        "deck",
        "newCardAdded",
        "AbstractCardItem*",
        "card",
        "logSay",
        "Player*",
        "player",
        "message",
        "logShuffle",
        "CardZone*",
        "zone",
        "start",
        "end",
        "logRollDie",
        "sides",
        "QList<uint>",
        "rolls",
        "logCreateArrow",
        "startPlayer",
        "startCard",
        "targetPlayer",
        "targetCard",
        "_playerTarget",
        "logCreateToken",
        "cardName",
        "pt",
        "logDrawCards",
        "number",
        "deckIsEmpty",
        "logUndoDraw",
        "logMoveCard",
        "CardItem*",
        "startZone",
        "oldX",
        "targetZone",
        "newX",
        "logFlipCard",
        "faceDown",
        "logDestroyCard",
        "logAttachCard",
        "targetCardName",
        "logUnattachCard",
        "logSetCardCounter",
        "counterId",
        "value",
        "oldValue",
        "logSetTapped",
        "tapped",
        "logSetCounter",
        "counterName",
        "logSetDoesntUntap",
        "doesntUntap",
        "logSetPT",
        "newPT",
        "logSetAnnotation",
        "newAnnotation",
        "logDumpZone",
        "numberCards",
        "isReversed",
        "logRevealCards",
        "cardId",
        "otherPlayer",
        "amount",
        "isLentToAnotherPlayer",
        "logAlwaysRevealTopCard",
        "reveal",
        "logAlwaysLookAtTopCard",
        "sizeChanged",
        "playerCountChanged",
        "actUntapAll",
        "actRollDie",
        "actCreateToken",
        "actCreateAnotherToken",
        "actShuffle",
        "actShuffleTop",
        "actShuffleBottom",
        "actDrawCard",
        "actDrawCards",
        "actUndoDraw",
        "actMulligan",
        "actPlay",
        "actPlayFacedown",
        "actHide",
        "actMoveTopCardToPlay",
        "actMoveTopCardToPlayFaceDown",
        "actMoveTopCardToGrave",
        "actMoveTopCardToExile",
        "actMoveTopCardsToGrave",
        "actMoveTopCardsToExile",
        "actMoveTopCardsUntil",
        "actMoveTopCardToBottom",
        "actDrawBottomCard",
        "actDrawBottomCards",
        "actMoveBottomCardToPlay",
        "actMoveBottomCardToPlayFaceDown",
        "actMoveBottomCardToGrave",
        "actMoveBottomCardToExile",
        "actMoveBottomCardsToGrave",
        "actMoveBottomCardsToExile",
        "actMoveBottomCardToTop",
        "actSelectAll",
        "actSelectRow",
        "actSelectColumn",
        "actViewLibrary",
        "actViewHand",
        "actViewTopCards",
        "actViewBottomCards",
        "actAlwaysRevealTopCard",
        "actAlwaysLookAtTopCard",
        "actViewGraveyard",
        "actRevealRandomGraveyardCard",
        "actViewRfg",
        "actViewSideboard",
        "actSayMessage",
        "addPlayer",
        "removePlayer",
        "playerListActionTriggered",
        "updateBoundingRect",
        "rearrangeZones",
        "actOpenDeckInDeckEditor",
        "actCreatePredefinedToken",
        "actCreateRelatedCard",
        "actCreateAllRelatedCards",
        "cardMenuAction",
        "actMoveCardXCardsFromTop",
        "actCardCounterTrigger",
        "actAttach",
        "actUnattach",
        "actDrawArrow",
        "actIncPT",
        "deltaP",
        "deltaT",
        "actResetPT",
        "actSetPT",
        "actIncP",
        "actDecP",
        "actIncT",
        "actDecT",
        "actDecPT",
        "actFlowP",
        "actFlowT",
        "actSetAnnotation",
        "actReveal",
        "QAction*",
        "action",
        "refreshShortcuts",
        "initSayMenu"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'openDeckEditor'
        QtMocHelpers::SignalData<void(const DeckLoader *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'newCardAdded'
        QtMocHelpers::SignalData<void(AbstractCardItem *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'logSay'
        QtMocHelpers::SignalData<void(Player *, QString)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 11 },
        }}),
        // Signal 'logShuffle'
        QtMocHelpers::SignalData<void(Player *, CardZone *, int, int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Int, 15 }, { QMetaType::Int, 16 },
        }}),
        // Signal 'logRollDie'
        QtMocHelpers::SignalData<void(Player *, int, const QList<uint> &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::Int, 18 }, { 0x80000000 | 19, 20 },
        }}),
        // Signal 'logCreateArrow'
        QtMocHelpers::SignalData<void(Player *, Player *, QString, Player *, QString, bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 9, 22 }, { QMetaType::QString, 23 }, { 0x80000000 | 9, 24 },
            { QMetaType::QString, 25 }, { QMetaType::Bool, 26 },
        }}),
        // Signal 'logCreateToken'
        QtMocHelpers::SignalData<void(Player *, QString, QString)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 }, { QMetaType::QString, 29 },
        }}),
        // Signal 'logDrawCards'
        QtMocHelpers::SignalData<void(Player *, int, bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::Int, 31 }, { QMetaType::Bool, 32 },
        }}),
        // Signal 'logUndoDraw'
        QtMocHelpers::SignalData<void(Player *, QString)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 },
        }}),
        // Signal 'logMoveCard'
        QtMocHelpers::SignalData<void(Player *, CardItem *, CardZone *, int, CardZone *, int)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 35, 7 }, { 0x80000000 | 13, 36 }, { QMetaType::Int, 37 },
            { 0x80000000 | 13, 38 }, { QMetaType::Int, 39 },
        }}),
        // Signal 'logFlipCard'
        QtMocHelpers::SignalData<void(Player *, QString, bool)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 }, { QMetaType::Bool, 41 },
        }}),
        // Signal 'logDestroyCard'
        QtMocHelpers::SignalData<void(Player *, QString)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 },
        }}),
        // Signal 'logAttachCard'
        QtMocHelpers::SignalData<void(Player *, QString, Player *, QString)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 }, { 0x80000000 | 9, 24 }, { QMetaType::QString, 44 },
        }}),
        // Signal 'logUnattachCard'
        QtMocHelpers::SignalData<void(Player *, QString)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 },
        }}),
        // Signal 'logSetCardCounter'
        QtMocHelpers::SignalData<void(Player *, QString, int, int, int)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 28 }, { QMetaType::Int, 47 }, { QMetaType::Int, 48 },
            { QMetaType::Int, 49 },
        }}),
        // Signal 'logSetTapped'
        QtMocHelpers::SignalData<void(Player *, CardItem *, bool)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 35, 7 }, { QMetaType::Bool, 51 },
        }}),
        // Signal 'logSetCounter'
        QtMocHelpers::SignalData<void(Player *, QString, int, int)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { QMetaType::QString, 53 }, { QMetaType::Int, 48 }, { QMetaType::Int, 49 },
        }}),
        // Signal 'logSetDoesntUntap'
        QtMocHelpers::SignalData<void(Player *, CardItem *, bool)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 35, 7 }, { QMetaType::Bool, 55 },
        }}),
        // Signal 'logSetPT'
        QtMocHelpers::SignalData<void(Player *, CardItem *, QString)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 35, 7 }, { QMetaType::QString, 57 },
        }}),
        // Signal 'logSetAnnotation'
        QtMocHelpers::SignalData<void(Player *, CardItem *, QString)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 35, 7 }, { QMetaType::QString, 59 },
        }}),
        // Signal 'logDumpZone'
        QtMocHelpers::SignalData<void(Player *, CardZone *, int, bool)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Int, 61 }, { QMetaType::Bool, 62 },
        }}),
        // Signal 'logDumpZone'
        QtMocHelpers::SignalData<void(Player *, CardZone *, int)>(60, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Int, 61 },
        }}),
        // Signal 'logRevealCards'
        QtMocHelpers::SignalData<void(Player *, CardZone *, int, QString, Player *, bool, int, bool)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Int, 64 }, { QMetaType::QString, 28 },
            { 0x80000000 | 9, 65 }, { QMetaType::Bool, 41 }, { QMetaType::Int, 66 }, { QMetaType::Bool, 67 },
        }}),
        // Signal 'logRevealCards'
        QtMocHelpers::SignalData<void(Player *, CardZone *, int, QString, Player *, bool, int)>(63, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Int, 64 }, { QMetaType::QString, 28 },
            { 0x80000000 | 9, 65 }, { QMetaType::Bool, 41 }, { QMetaType::Int, 66 },
        }}),
        // Signal 'logAlwaysRevealTopCard'
        QtMocHelpers::SignalData<void(Player *, CardZone *, bool)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Bool, 69 },
        }}),
        // Signal 'logAlwaysLookAtTopCard'
        QtMocHelpers::SignalData<void(Player *, CardZone *, bool)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 13, 14 }, { QMetaType::Bool, 69 },
        }}),
        // Signal 'sizeChanged'
        QtMocHelpers::SignalData<void()>(71, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'playerCountChanged'
        QtMocHelpers::SignalData<void()>(72, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actUntapAll'
        QtMocHelpers::SlotData<void()>(73, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actRollDie'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actCreateToken'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actCreateAnotherToken'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actShuffle'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actShuffleTop'
        QtMocHelpers::SlotData<void()>(78, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actShuffleBottom'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actDrawCard'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actDrawCards'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actUndoDraw'
        QtMocHelpers::SlotData<void()>(82, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMulligan'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actPlay'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actPlayFacedown'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actHide'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardToPlay'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardToPlayFaceDown'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardToGrave'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardToExile'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardsToGrave'
        QtMocHelpers::SlotData<void()>(91, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardsToExile'
        QtMocHelpers::SlotData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardsUntil'
        QtMocHelpers::SlotData<void()>(93, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveTopCardToBottom'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actDrawBottomCard'
        QtMocHelpers::SlotData<void()>(95, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actDrawBottomCards'
        QtMocHelpers::SlotData<void()>(96, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardToPlay'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardToPlayFaceDown'
        QtMocHelpers::SlotData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardToGrave'
        QtMocHelpers::SlotData<void()>(99, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardToExile'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardsToGrave'
        QtMocHelpers::SlotData<void()>(101, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardsToExile'
        QtMocHelpers::SlotData<void()>(102, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actMoveBottomCardToTop'
        QtMocHelpers::SlotData<void()>(103, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actSelectAll'
        QtMocHelpers::SlotData<void()>(104, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actSelectRow'
        QtMocHelpers::SlotData<void()>(105, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actSelectColumn'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewLibrary'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewHand'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewTopCards'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewBottomCards'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actAlwaysRevealTopCard'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actAlwaysLookAtTopCard'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewGraveyard'
        QtMocHelpers::SlotData<void()>(113, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actRevealRandomGraveyardCard'
        QtMocHelpers::SlotData<void()>(114, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewRfg'
        QtMocHelpers::SlotData<void()>(115, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actViewSideboard'
        QtMocHelpers::SlotData<void()>(116, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'actSayMessage'
        QtMocHelpers::SlotData<void()>(117, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addPlayer'
        QtMocHelpers::SlotData<void(Player *)>(118, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'removePlayer'
        QtMocHelpers::SlotData<void(Player *)>(119, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'playerListActionTriggered'
        QtMocHelpers::SlotData<void()>(120, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateBoundingRect'
        QtMocHelpers::SlotData<void()>(121, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'rearrangeZones'
        QtMocHelpers::SlotData<void()>(122, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actOpenDeckInDeckEditor'
        QtMocHelpers::SlotData<void()>(123, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actCreatePredefinedToken'
        QtMocHelpers::SlotData<void()>(124, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actCreateRelatedCard'
        QtMocHelpers::SlotData<void()>(125, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actCreateAllRelatedCards'
        QtMocHelpers::SlotData<void()>(126, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'cardMenuAction'
        QtMocHelpers::SlotData<void()>(127, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actMoveCardXCardsFromTop'
        QtMocHelpers::SlotData<void()>(128, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actCardCounterTrigger'
        QtMocHelpers::SlotData<void()>(129, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actAttach'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actUnattach'
        QtMocHelpers::SlotData<void()>(131, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actDrawArrow'
        QtMocHelpers::SlotData<void()>(132, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actIncPT'
        QtMocHelpers::SlotData<void(int, int)>(133, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 134 }, { QMetaType::Int, 135 },
        }}),
        // Slot 'actResetPT'
        QtMocHelpers::SlotData<void()>(136, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actSetPT'
        QtMocHelpers::SlotData<void()>(137, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actIncP'
        QtMocHelpers::SlotData<void()>(138, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actDecP'
        QtMocHelpers::SlotData<void()>(139, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actIncT'
        QtMocHelpers::SlotData<void()>(140, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actDecT'
        QtMocHelpers::SlotData<void()>(141, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actIncPT'
        QtMocHelpers::SlotData<void()>(133, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actDecPT'
        QtMocHelpers::SlotData<void()>(142, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actFlowP'
        QtMocHelpers::SlotData<void()>(143, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actFlowT'
        QtMocHelpers::SlotData<void()>(144, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actSetAnnotation'
        QtMocHelpers::SlotData<void()>(145, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'actReveal'
        QtMocHelpers::SlotData<void(QAction *)>(146, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 147, 148 },
        }}),
        // Slot 'refreshShortcuts'
        QtMocHelpers::SlotData<void()>(149, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'initSayMenu'
        QtMocHelpers::SlotData<void()>(150, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Player, qt_meta_tag_ZN6PlayerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Player::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6PlayerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6PlayerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6PlayerE_t>.metaTypes,
    nullptr
} };

void Player::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Player *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->openDeckEditor((*reinterpret_cast< std::add_pointer_t<const DeckLoader*>>(_a[1]))); break;
        case 1: _t->newCardAdded((*reinterpret_cast< std::add_pointer_t<AbstractCardItem*>>(_a[1]))); break;
        case 2: _t->logSay((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 3: _t->logShuffle((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[4]))); break;
        case 4: _t->logRollDie((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QList<uint>>>(_a[3]))); break;
        case 5: _t->logCreateArrow((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<Player*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<Player*>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[5])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[6]))); break;
        case 6: _t->logCreateToken((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[3]))); break;
        case 7: _t->logDrawCards((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 8: _t->logUndoDraw((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 9: _t->logMoveCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[5])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[6]))); break;
        case 10: _t->logFlipCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 11: _t->logDestroyCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 12: _t->logAttachCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<Player*>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[4]))); break;
        case 13: _t->logUnattachCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2]))); break;
        case 14: _t->logSetCardCounter((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[5]))); break;
        case 15: _t->logSetTapped((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 16: _t->logSetCounter((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[4]))); break;
        case 17: _t->logSetDoesntUntap((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 18: _t->logSetPT((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[3]))); break;
        case 19: _t->logSetAnnotation((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[3]))); break;
        case 20: _t->logDumpZone((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[4]))); break;
        case 21: _t->logDumpZone((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3]))); break;
        case 22: _t->logRevealCards((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<Player*>>(_a[5])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[6])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[7])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[8]))); break;
        case 23: _t->logRevealCards((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast< std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast< std::add_pointer_t<Player*>>(_a[5])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[6])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[7]))); break;
        case 24: _t->logAlwaysRevealTopCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 25: _t->logAlwaysLookAtTopCard((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<CardZone*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<bool>>(_a[3]))); break;
        case 26: _t->sizeChanged(); break;
        case 27: _t->playerCountChanged(); break;
        case 28: _t->actUntapAll(); break;
        case 29: _t->actRollDie(); break;
        case 30: _t->actCreateToken(); break;
        case 31: _t->actCreateAnotherToken(); break;
        case 32: _t->actShuffle(); break;
        case 33: _t->actShuffleTop(); break;
        case 34: _t->actShuffleBottom(); break;
        case 35: _t->actDrawCard(); break;
        case 36: _t->actDrawCards(); break;
        case 37: _t->actUndoDraw(); break;
        case 38: _t->actMulligan(); break;
        case 39: _t->actPlay(); break;
        case 40: _t->actPlayFacedown(); break;
        case 41: _t->actHide(); break;
        case 42: _t->actMoveTopCardToPlay(); break;
        case 43: _t->actMoveTopCardToPlayFaceDown(); break;
        case 44: _t->actMoveTopCardToGrave(); break;
        case 45: _t->actMoveTopCardToExile(); break;
        case 46: _t->actMoveTopCardsToGrave(); break;
        case 47: _t->actMoveTopCardsToExile(); break;
        case 48: _t->actMoveTopCardsUntil(); break;
        case 49: _t->actMoveTopCardToBottom(); break;
        case 50: _t->actDrawBottomCard(); break;
        case 51: _t->actDrawBottomCards(); break;
        case 52: _t->actMoveBottomCardToPlay(); break;
        case 53: _t->actMoveBottomCardToPlayFaceDown(); break;
        case 54: _t->actMoveBottomCardToGrave(); break;
        case 55: _t->actMoveBottomCardToExile(); break;
        case 56: _t->actMoveBottomCardsToGrave(); break;
        case 57: _t->actMoveBottomCardsToExile(); break;
        case 58: _t->actMoveBottomCardToTop(); break;
        case 59: _t->actSelectAll(); break;
        case 60: _t->actSelectRow(); break;
        case 61: _t->actSelectColumn(); break;
        case 62: _t->actViewLibrary(); break;
        case 63: _t->actViewHand(); break;
        case 64: _t->actViewTopCards(); break;
        case 65: _t->actViewBottomCards(); break;
        case 66: _t->actAlwaysRevealTopCard(); break;
        case 67: _t->actAlwaysLookAtTopCard(); break;
        case 68: _t->actViewGraveyard(); break;
        case 69: _t->actRevealRandomGraveyardCard(); break;
        case 70: _t->actViewRfg(); break;
        case 71: _t->actViewSideboard(); break;
        case 72: _t->actSayMessage(); break;
        case 73: _t->addPlayer((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1]))); break;
        case 74: _t->removePlayer((*reinterpret_cast< std::add_pointer_t<Player*>>(_a[1]))); break;
        case 75: _t->playerListActionTriggered(); break;
        case 76: _t->updateBoundingRect(); break;
        case 77: _t->rearrangeZones(); break;
        case 78: _t->actOpenDeckInDeckEditor(); break;
        case 79: _t->actCreatePredefinedToken(); break;
        case 80: _t->actCreateRelatedCard(); break;
        case 81: _t->actCreateAllRelatedCards(); break;
        case 82: _t->cardMenuAction(); break;
        case 83: _t->actMoveCardXCardsFromTop(); break;
        case 84: _t->actCardCounterTrigger(); break;
        case 85: _t->actAttach(); break;
        case 86: _t->actUnattach(); break;
        case 87: _t->actDrawArrow(); break;
        case 88: _t->actIncPT((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2]))); break;
        case 89: _t->actResetPT(); break;
        case 90: _t->actSetPT(); break;
        case 91: _t->actIncP(); break;
        case 92: _t->actDecP(); break;
        case 93: _t->actIncT(); break;
        case 94: _t->actDecT(); break;
        case 95: _t->actIncPT(); break;
        case 96: _t->actDecPT(); break;
        case 97: _t->actFlowP(); break;
        case 98: _t->actFlowT(); break;
        case 99: _t->actSetAnnotation(); break;
        case 100: _t->actReveal((*reinterpret_cast< std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 101: _t->refreshShortcuts(); break;
        case 102: _t->initSayMenu(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<uint> >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 3:
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 10:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 19:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 20:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 22:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 4:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 4:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 73:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 74:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Player* >(); break;
            }
            break;
        case 100:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Player::*)(const DeckLoader * )>(_a, &Player::openDeckEditor, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(AbstractCardItem * )>(_a, &Player::newCardAdded, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString )>(_a, &Player::logSay, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardZone * , int , int )>(_a, &Player::logShuffle, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , int , const QList<uint> & )>(_a, &Player::logRollDie, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , Player * , QString , Player * , QString , bool )>(_a, &Player::logCreateArrow, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString , QString )>(_a, &Player::logCreateToken, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , int , bool )>(_a, &Player::logDrawCards, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString )>(_a, &Player::logUndoDraw, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardItem * , CardZone * , int , CardZone * , int )>(_a, &Player::logMoveCard, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString , bool )>(_a, &Player::logFlipCard, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString )>(_a, &Player::logDestroyCard, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString , Player * , QString )>(_a, &Player::logAttachCard, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString )>(_a, &Player::logUnattachCard, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString , int , int , int )>(_a, &Player::logSetCardCounter, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardItem * , bool )>(_a, &Player::logSetTapped, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , QString , int , int )>(_a, &Player::logSetCounter, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardItem * , bool )>(_a, &Player::logSetDoesntUntap, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardItem * , QString )>(_a, &Player::logSetPT, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardItem * , QString )>(_a, &Player::logSetAnnotation, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardZone * , int , bool )>(_a, &Player::logDumpZone, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardZone * , int , QString , Player * , bool , int , bool )>(_a, &Player::logRevealCards, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardZone * , bool )>(_a, &Player::logAlwaysRevealTopCard, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)(Player * , CardZone * , bool )>(_a, &Player::logAlwaysLookAtTopCard, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)()>(_a, &Player::sizeChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Player::*)()>(_a, &Player::playerCountChanged, 27))
            return;
    }
}

const QMetaObject *Player::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Player::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6PlayerE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "QGraphicsItem"))
        return static_cast< QGraphicsItem*>(this);
    if (!strcmp(_clname, "org.qt-project.Qt.QGraphicsItem"))
        return static_cast< QGraphicsItem*>(this);
    return QObject::qt_metacast(_clname);
}

int Player::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 103)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 103;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 103)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 103;
    }
    return _id;
}

// SIGNAL 0
void Player::openDeckEditor(const DeckLoader * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Player::newCardAdded(AbstractCardItem * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Player::logSay(Player * _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 3
void Player::logShuffle(Player * _t1, CardZone * _t2, int _t3, int _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 4
void Player::logRollDie(Player * _t1, int _t2, const QList<uint> & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2, _t3);
}

// SIGNAL 5
void Player::logCreateArrow(Player * _t1, Player * _t2, QString _t3, Player * _t4, QString _t5, bool _t6)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2, _t3, _t4, _t5, _t6);
}

// SIGNAL 6
void Player::logCreateToken(Player * _t1, QString _t2, QString _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2, _t3);
}

// SIGNAL 7
void Player::logDrawCards(Player * _t1, int _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2, _t3);
}

// SIGNAL 8
void Player::logUndoDraw(Player * _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2);
}

// SIGNAL 9
void Player::logMoveCard(Player * _t1, CardItem * _t2, CardZone * _t3, int _t4, CardZone * _t5, int _t6)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1, _t2, _t3, _t4, _t5, _t6);
}

// SIGNAL 10
void Player::logFlipCard(Player * _t1, QString _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2, _t3);
}

// SIGNAL 11
void Player::logDestroyCard(Player * _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}

// SIGNAL 12
void Player::logAttachCard(Player * _t1, QString _t2, Player * _t3, QString _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 13
void Player::logUnattachCard(Player * _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1, _t2);
}

// SIGNAL 14
void Player::logSetCardCounter(Player * _t1, QString _t2, int _t3, int _t4, int _t5)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1, _t2, _t3, _t4, _t5);
}

// SIGNAL 15
void Player::logSetTapped(Player * _t1, CardItem * _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2, _t3);
}

// SIGNAL 16
void Player::logSetCounter(Player * _t1, QString _t2, int _t3, int _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 17
void Player::logSetDoesntUntap(Player * _t1, CardItem * _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1, _t2, _t3);
}

// SIGNAL 18
void Player::logSetPT(Player * _t1, CardItem * _t2, QString _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2, _t3);
}

// SIGNAL 19
void Player::logSetAnnotation(Player * _t1, CardItem * _t2, QString _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2, _t3);
}

// SIGNAL 20
void Player::logDumpZone(Player * _t1, CardZone * _t2, int _t3, bool _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 22
void Player::logRevealCards(Player * _t1, CardZone * _t2, int _t3, QString _t4, Player * _t5, bool _t6, int _t7, bool _t8)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1, _t2, _t3, _t4, _t5, _t6, _t7, _t8);
}

// SIGNAL 24
void Player::logAlwaysRevealTopCard(Player * _t1, CardZone * _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1, _t2, _t3);
}

// SIGNAL 25
void Player::logAlwaysLookAtTopCard(Player * _t1, CardZone * _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1, _t2, _t3);
}

// SIGNAL 26
void Player::sizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void Player::playerCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}
namespace {
struct qt_meta_tag_ZN16AnnotationDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto AnnotationDialog::qt_create_metaobjectdata<qt_meta_tag_ZN16AnnotationDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AnnotationDialog"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<AnnotationDialog, qt_meta_tag_ZN16AnnotationDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject AnnotationDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QInputDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AnnotationDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AnnotationDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16AnnotationDialogE_t>.metaTypes,
    nullptr
} };

void AnnotationDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<AnnotationDialog *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *AnnotationDialog::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *AnnotationDialog::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AnnotationDialogE_t>.strings))
        return static_cast<void*>(this);
    return QInputDialog::qt_metacast(_clname);
}

int AnnotationDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QInputDialog::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
