From 9b030a3d6b668eb9a3e5364934e36fdfc9575ab4 Mon Sep 17 00:00:00 2001 From: DawnFire42 Date: Thu, 21 May 2026 21:30:40 -0400 Subject: [PATCH 1/4] [Game] Add Command Zone support with commander tax tracking - Add CommandZone and CommandZoneLogic for commander - Add CommanderTaxCounter - Add counter active state protocol (show/hide tax counters) - Add "Enable Command Zone" option in game creation dialogs - Add context menu actions for command zone operations Took 9 minutes Took 11 minutes --- cockatrice/CMakeLists.txt | 6 +- .../src/client/settings/cache_settings.cpp | 14 ++ .../src/client/settings/cache_settings.h | 12 ++ .../src/game/board/commander_tax_counter.cpp | 60 ++++++ .../src/game/board/commander_tax_counter.h | 72 +++++++ cockatrice/src/game/board/counter_state.cpp | 22 ++- cockatrice/src/game/board/counter_state.h | 15 +- cockatrice/src/game/player/player_actions.cpp | 88 ++++++++- cockatrice/src/game/player/player_actions.h | 19 ++ .../src/game/player/player_event_handler.cpp | 34 +++- .../src/game/player/player_event_handler.h | 2 + cockatrice/src/game/player/player_logic.cpp | 37 +++- cockatrice/src/game/player/player_logic.h | 22 ++- cockatrice/src/game/zones/card_zone_logic.cpp | 3 + cockatrice/src/game/zones/command_zone.cpp | 176 +++++++++++++++++ cockatrice/src/game/zones/command_zone.h | 103 ++++++++++ .../src/game/zones/command_zone_logic.cpp | 19 ++ .../src/game/zones/command_zone_logic.h | 51 +++++ .../game_graphics/board/abstract_counter.cpp | 13 ++ .../game_graphics/board/abstract_counter.h | 27 +++ .../board/translate_counter_name.cpp | 4 +- .../game_graphics/log/message_log_widget.cpp | 19 ++ .../player/card_menu_action_type.h | 3 +- .../game_graphics/player/menu/card_menu.cpp | 37 ++++ .../src/game_graphics/player/menu/card_menu.h | 3 + .../player/menu/command_zone_menu.cpp | 184 ++++++++++++++++++ .../player/menu/command_zone_menu.h | 62 ++++++ .../game_graphics/player/menu/move_menu.cpp | 6 + .../src/game_graphics/player/menu/move_menu.h | 1 + .../game_graphics/player/menu/player_menu.cpp | 16 ++ .../game_graphics/player/menu/player_menu.h | 3 + .../player/player_graphics_item.cpp | 80 +++++++- .../player/player_graphics_item.h | 20 ++ cockatrice/src/game_graphics/z_values.h | 5 + .../src/game_graphics/zones/stack_zone.cpp | 4 + cockatrice/src/interface/theme_manager.cpp | 10 + cockatrice/src/interface/theme_manager.h | 3 +- .../widgets/dialogs/dlg_create_game.cpp | 7 + .../widgets/dialogs/dlg_create_game.h | 1 + .../dialogs/dlg_local_game_options.cpp | 6 + .../widgets/dialogs/dlg_local_game_options.h | 2 + .../src/interface/widgets/tabs/tab_game.cpp | 2 +- cockatrice/src/interface/window_main.cpp | 1 + .../themes/Fabric/zones/commandzone.png | Bin 0 -> 225500 bytes .../themes/Leather/zones/commandzone.png | Bin 0 -> 144085 bytes .../themes/Plasma/zones/commandzone.png | Bin 0 -> 41412 bytes .../themes/VelvetMarble/zones/commandzone.png | Bin 0 -> 37913 bytes doc/doxygen/groups/doc_groups.dox | 9 +- .../game/server_abstract_participant.cpp | 11 ++ .../remote/game/server_abstract_participant.h | 3 + .../server/remote/game/server_card.cpp | 8 +- .../network/server/remote/game/server_card.h | 4 +- .../server/remote/game/server_counter.cpp | 24 +-- .../server/remote/game/server_counter.h | 70 +++++-- .../server/remote/game/server_game.cpp | 7 +- .../network/server/remote/game/server_game.h | 6 + .../server/remote/game/server_player.cpp | 64 ++++++ .../server/remote/game/server_player.h | 3 + .../server/remote/server_protocolhandler.cpp | 9 +- .../libcockatrice/protocol/pb/CMakeLists.txt | 2 + .../pb/command_set_counter_active.proto | 9 + .../pb/event_set_counter_active.proto | 10 + .../protocol/pb/game_commands.proto | 1 + .../protocol/pb/game_event.proto | 1 + .../protocol/pb/room_commands.proto | 3 + .../protocol/pb/serverinfo_counter.proto | 1 + libcockatrice_utility/CMakeLists.txt | 1 + .../libcockatrice/utility/counter_ids.h | 46 +++++ .../libcockatrice/utility/trice_limits.h | 6 +- .../libcockatrice/utility/zone_names.h | 3 + .../movecard_tests/reverse_card_move_test.cpp | 3 +- tests/server_card_counter_test.cpp | 16 +- tests/server_counter_test.cpp | 32 +++ 73 files changed, 1540 insertions(+), 86 deletions(-) create mode 100644 cockatrice/src/game/board/commander_tax_counter.cpp create mode 100644 cockatrice/src/game/board/commander_tax_counter.h create mode 100644 cockatrice/src/game/zones/command_zone.cpp create mode 100644 cockatrice/src/game/zones/command_zone.h create mode 100644 cockatrice/src/game/zones/command_zone_logic.cpp create mode 100644 cockatrice/src/game/zones/command_zone_logic.h create mode 100644 cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp create mode 100644 cockatrice/src/game_graphics/player/menu/command_zone_menu.h create mode 100644 cockatrice/themes/Fabric/zones/commandzone.png create mode 100644 cockatrice/themes/Leather/zones/commandzone.png create mode 100644 cockatrice/themes/Plasma/zones/commandzone.png create mode 100644 cockatrice/themes/VelvetMarble/zones/commandzone.png create mode 100644 libcockatrice_protocol/libcockatrice/protocol/pb/command_set_counter_active.proto create mode 100644 libcockatrice_protocol/libcockatrice/protocol/pb/event_set_counter_active.proto create mode 100644 libcockatrice_utility/libcockatrice/utility/counter_ids.h diff --git a/cockatrice/CMakeLists.txt b/cockatrice/CMakeLists.txt index bd99d08bf..649cd49cd 100644 --- a/cockatrice/CMakeLists.txt +++ b/cockatrice/CMakeLists.txt @@ -67,6 +67,7 @@ set(cockatrice_SOURCES src/game_graphics/board/card_item.cpp src/game/board/card_list.cpp src/game/board/card_state.cpp + src/game_graphics/board/commander_tax_counter.cpp src/game_graphics/board/counter_general.cpp src/game/board/counter_state.cpp src/game_graphics/board/translate_counter_name.cpp @@ -86,7 +87,8 @@ set(cockatrice_SOURCES src/game_graphics/log/message_log_widget.cpp src/game/phase.cpp src/game_graphics/phases_toolbar.cpp - src/game_graphics/player/menu/card_menu.cpp + src/game_graphics/player/menu/card_menu. + src/game_graphics/player/menu/command_zone_menu.cpp src/game_graphics/player/menu/custom_zone_menu.cpp src/game_graphics/player/menu/grave_menu.cpp src/game_graphics/player/menu/hand_menu.cpp @@ -110,6 +112,8 @@ set(cockatrice_SOURCES src/game_graphics/player/player_target.cpp src/game/replay.cpp src/game/zones/card_zone_logic.cpp + src/game/zones/command_zone.cpp + src/game/zones/command_zone_logic.cpp src/game/zones/hand_zone_logic.cpp src/game/zones/pile_zone_logic.cpp src/game/zones/stack_zone_logic.cpp diff --git a/cockatrice/src/client/settings/cache_settings.cpp b/cockatrice/src/client/settings/cache_settings.cpp index 73e5a98a1..0bbea7f40 100644 --- a/cockatrice/src/client/settings/cache_settings.cpp +++ b/cockatrice/src/client/settings/cache_settings.cpp @@ -414,6 +414,7 @@ SettingsCache::SettingsCache() createGameAsSpectator = settings->value("game/creategameasspectator", false).toBool(); defaultStartingLifeTotal = settings->value("game/defaultstartinglifetotal", 20).toInt(); shareDecklistsOnLoad = settings->value("game/sharedecklistsonload", false).toBool(); + enableCommandZone = settings->value("game/enablecommandzone", false).toBool(); rememberGameSettings = settings->value("game/remembergamesettings", true).toBool(); // Local game settings use "localgameoptions/" prefix to keep them separate @@ -421,6 +422,7 @@ SettingsCache::SettingsCache() localGameRememberSettings = settings->value("localgameoptions/remembersettings", false).toBool(); localGameMaxPlayers = settings->value("localgameoptions/maxplayers", 1).toInt(); localGameStartingLifeTotal = settings->value("localgameoptions/startinglifetotal", 20).toInt(); + localGameEnableCommandZone = settings->value("localgameoptions/enablecommandzone", false).toBool(); clientID = settings->value("personal/clientid", CLIENT_INFO_NOT_SET).toString(); clientVersion = settings->value("personal/clientversion", CLIENT_INFO_NOT_SET).toString(); @@ -1265,6 +1267,12 @@ void SettingsCache::setShareDecklistsOnLoad(const bool _shareDecklistsOnLoad) settings->setValue("game/sharedecklistsonload", shareDecklistsOnLoad); } +void SettingsCache::setEnableCommandZone(const bool _enableCommandZone) +{ + enableCommandZone = _enableCommandZone; + settings->setValue("game/enablecommandzone", enableCommandZone); +} + void SettingsCache::setCheckUpdatesOnStartup(QT_STATE_CHANGED_T value) { checkUpdatesOnStartup = static_cast(value); @@ -1325,6 +1333,12 @@ void SettingsCache::setLocalGameStartingLifeTotal(int value) settings->setValue("localgameoptions/startinglifetotal", value); } +void SettingsCache::setLocalGameEnableCommandZone(bool value) +{ + localGameEnableCommandZone = value; + settings->setValue("localgameoptions/enablecommandzone", value); +} + void SettingsCache::setNotifyAboutUpdate(QT_STATE_CHANGED_T _notifyaboutupdate) { notifyAboutUpdates = static_cast(_notifyaboutupdate); diff --git a/cockatrice/src/client/settings/cache_settings.h b/cockatrice/src/client/settings/cache_settings.h index 8ee372766..92ca96098 100644 --- a/cockatrice/src/client/settings/cache_settings.h +++ b/cockatrice/src/client/settings/cache_settings.h @@ -332,6 +332,7 @@ private: bool createGameAsSpectator; int defaultStartingLifeTotal; bool shareDecklistsOnLoad; + bool enableCommandZone; int keepalive; int timeout; void translateLegacySettings(); @@ -344,6 +345,7 @@ private: bool localGameRememberSettings; int localGameMaxPlayers; int localGameStartingLifeTotal; + bool localGameEnableCommandZone; QList releaseChannels; bool isPortableBuild; @@ -895,6 +897,10 @@ public: { return shareDecklistsOnLoad; } + [[nodiscard]] bool getEnableCommandZone() const + { + return enableCommandZone; + } [[nodiscard]] bool getCreateGameAsSpectator() const { return createGameAsSpectator; @@ -915,6 +921,10 @@ public: { return localGameStartingLifeTotal; } + [[nodiscard]] bool getLocalGameEnableCommandZone() const + { + return localGameEnableCommandZone; + } [[nodiscard]] int getKeepAlive() const override { return keepalive; @@ -1145,10 +1155,12 @@ public slots: void setCreateGameAsSpectator(const bool _createGameAsSpectator); void setDefaultStartingLifeTotal(const int _defaultStartingLifeTotal); void setShareDecklistsOnLoad(const bool _shareDecklistsOnLoad); + void setEnableCommandZone(const bool _enableCommandZone); void setRememberGameSettings(const bool _rememberGameSettings); void setLocalGameRememberSettings(bool value); void setLocalGameMaxPlayers(int value); void setLocalGameStartingLifeTotal(int value); + void setLocalGameEnableCommandZone(bool value); void setCheckUpdatesOnStartup(QT_STATE_CHANGED_T value); void setStartupCardUpdateCheckPromptForUpdate(bool value); void setStartupCardUpdateCheckAlwaysUpdate(bool value); diff --git a/cockatrice/src/game/board/commander_tax_counter.cpp b/cockatrice/src/game/board/commander_tax_counter.cpp new file mode 100644 index 000000000..d0ae0ad5c --- /dev/null +++ b/cockatrice/src/game/board/commander_tax_counter.cpp @@ -0,0 +1,60 @@ +#include "commander_tax_counter.h" + +#include "counter_state.h" +#include "translate_counter_name.h" + +#include +#include +#include + +static constexpr qreal CORNER_RADIUS = 4.0; +static constexpr qreal FONT_SIZE_RATIO = 0.6; +static constexpr int OVERLAY_ALPHA = 191; +static const QColor OVERLAY_BG_NORMAL{40, 40, 40, OVERLAY_ALPHA}; +static const QColor OVERLAY_BG_HOVERED{70, 70, 70, OVERLAY_ALPHA}; + +CommanderTaxCounter::CommanderTaxCounter(CounterState *state, PlayerLogic *player, QGraphicsItem *parent) + : AbstractCounter(state, player, false, false, parent), size(TaxCounterSizes::TAX_COUNTER_SIZE) +{ + setCacheMode(DeviceCoordinateCache); + setAcceptHoverEvents(true); + setCursor(Qt::ArrowCursor); + + setToolTip(tr("%1: %2").arg(TranslateCounterName::getDisplayName(getName())).arg(getValue())); +} + +QRectF CommanderTaxCounter::boundingRect() const +{ + return QRectF(0, 0, size, size); +} + +void CommanderTaxCounter::paint(QPainter *painter, + [[maybe_unused]] const QStyleOptionGraphicsItem *option, + [[maybe_unused]] QWidget *widget) +{ + painter->save(); + + QRectF rect = boundingRect().adjusted(1, 1, -1, -1); + + QColor bgColor = hovered ? OVERLAY_BG_HOVERED : OVERLAY_BG_NORMAL; + + painter->setPen(Qt::NoPen); + painter->setBrush(bgColor); + painter->drawRoundedRect(rect, CORNER_RADIUS, CORNER_RADIUS); + + QFont f = QFontDatabase::systemFont(QFontDatabase::GeneralFont); + f.setPixelSize(static_cast(size * FONT_SIZE_RATIO)); + f.setWeight(QFont::Bold); + painter->setFont(f); + painter->setPen(Qt::white); + painter->drawText(rect, Qt::AlignCenter, QString::number(value)); + + painter->restore(); +} + +void CommanderTaxCounter::setValue(int _value) +{ + int clampedValue = qMax(0, _value); + AbstractCounter::setValue(clampedValue); + setToolTip(tr("%1: %2").arg(TranslateCounterName::getDisplayName(getName())).arg(clampedValue)); +} diff --git a/cockatrice/src/game/board/commander_tax_counter.h b/cockatrice/src/game/board/commander_tax_counter.h new file mode 100644 index 000000000..220113303 --- /dev/null +++ b/cockatrice/src/game/board/commander_tax_counter.h @@ -0,0 +1,72 @@ +/** + * @file commander_tax_counter.h + * @ingroup GameGraphicsPlayers + * @brief Square counter for commander tax, clamped to non-negative values. + */ + +#ifndef COCKATRICE_COMMANDER_TAX_COUNTER_H +#define COCKATRICE_COMMANDER_TAX_COUNTER_H + +#include "abstract_counter.h" + +/** + * @namespace TaxCounterSizes + * @brief Size constants for commander tax counter layout. + */ +namespace TaxCounterSizes +{ + +/** @brief Size of commander tax counter icons (width and height) */ +constexpr int TAX_COUNTER_SIZE = 24; + +/** @brief Margin around and between tax counter icons */ +constexpr int TAX_COUNTER_MARGIN = 2; + +} // namespace TaxCounterSizes + +/** + * @class CommanderTaxCounter + * @brief Counter for tracking commander tax in Commander format. + * + * Displays cumulative cost increase for casting a commander. The counter + * is manually adjusted by the player to track their commander tax. Values + * are clamped to >= 0. + * + * Appearance: square with rounded corners, semi-transparent background, + * positioned at top-left of command zone. + * + * Two instances per player: CounterIds::CommanderTax and CounterIds::PartnerTax. + * Each counter supports an active/inactive state (inherited from AbstractCounter): + * commander tax starts active; partner tax starts inactive until explicitly + * enabled by the player via the context menu. + * + * @see AbstractCounter + * @see AbstractCounter::setActive() + * @see CounterIds + */ +class CommanderTaxCounter : public AbstractCounter +{ + Q_OBJECT +private: + int size; + +public: + /** + * @brief Constructs a CommanderTaxCounter. + * @param state Counter state containing id, name, value, etc. + * @param player The player who owns this counter + * @param parent Parent graphics item (typically the command zone) + */ + CommanderTaxCounter(CounterState *state, PlayerLogic *player, QGraphicsItem *parent = nullptr); + + [[nodiscard]] QRectF boundingRect() const override; + void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; + + /** + * @brief Overrides AbstractCounter::setValue to clamp values to >= 0 and update the tooltip. + * @param _value New value (clamped if negative) + */ + void setValue(int _value) override; +}; + +#endif // COCKATRICE_COMMANDER_TAX_COUNTER_H diff --git a/cockatrice/src/game/board/counter_state.cpp b/cockatrice/src/game/board/counter_state.cpp index 6da18b662..b8377102f 100644 --- a/cockatrice/src/game/board/counter_state.cpp +++ b/cockatrice/src/game/board/counter_state.cpp @@ -2,15 +2,22 @@ #include -CounterState::CounterState(int id, const QString &name, const QColor &color, int radius, int value, QObject *parent) - : QObject(parent), id(id), name(name), color(color), radius(radius), value(value) +CounterState::CounterState(int id, + const QString &name, + const QColor &color, + int radius, + int value, + bool active, + QObject *parent) + : QObject(parent), id(id), name(name), color(color), radius(radius), value(value), active(active) { } CounterState *CounterState::fromProto(const ServerInfo_Counter &counter, QObject *parent) { return new CounterState(counter.id(), QString::fromStdString(counter.name()), - convertColorToQColor(counter.counter_color()), counter.radius(), counter.count(), parent); + convertColorToQColor(counter.counter_color()), counter.radius(), counter.count(), + counter.active(), parent); } void CounterState::setValue(int newValue) @@ -21,4 +28,13 @@ void CounterState::setValue(int newValue) int old = value; value = newValue; emit valueChanged(old, newValue); +} + +void CounterState::setActive(bool newActive) +{ + if (newActive == active) { + return; + } + active = newActive; + emit activeChanged(newActive); } \ No newline at end of file diff --git a/cockatrice/src/game/board/counter_state.h b/cockatrice/src/game/board/counter_state.h index 0f2f16b55..4a0f48203 100644 --- a/cockatrice/src/game/board/counter_state.h +++ b/cockatrice/src/game/board/counter_state.h @@ -10,7 +10,13 @@ class CounterState : public QObject { Q_OBJECT public: - CounterState(int id, const QString &name, const QColor &color, int radius, int value, QObject *parent = nullptr); + CounterState(int id, + const QString &name, + const QColor &color, + int radius, + int value, + bool active = true, + QObject *parent = nullptr); static CounterState *fromProto(const ServerInfo_Counter &counter, QObject *parent = nullptr); @@ -34,11 +40,17 @@ public: { return value; } + bool isActive() const + { + return active; + } void setValue(int newValue); + void setActive(bool newActive); signals: void valueChanged(int oldValue, int newValue); + void activeChanged(bool newActive); private: int id; @@ -46,6 +58,7 @@ private: QColor color; int radius; int value; + bool active; }; #endif // COCKATRICE_COUNTER_STATE_H diff --git a/cockatrice/src/game/player/player_actions.cpp b/cockatrice/src/game/player/player_actions.cpp index de909ca5e..3fc3e3ef7 100644 --- a/cockatrice/src/game/player/player_actions.cpp +++ b/cockatrice/src/game/player/player_actions.cpp @@ -7,6 +7,7 @@ #include "../../game_graphics/zones/table_zone.h" #include "../../interface/widgets/tabs/tab_game.h" #include "../../interface/widgets/utility/get_text_with_max.h" + #include "../zones/view_zone_logic.h" #include @@ -24,9 +25,11 @@ #include #include #include +#include #include #include #include +#include #include #include #include @@ -1526,9 +1529,9 @@ void PlayerActions::offsetCardCounter(QList selectedCards, int count int oldValue = card->getCounters().value(counterId, 0); int newValue = oldValue + offset; - // Early exit optimization: server enforces [0, MAX_COUNTERS_ON_CARD]. + // Early exit optimization: server enforces [0, MAX_COUNTER_VALUE]. // Compare clamped value to allow recovery from invalid states. - int clampedValue = qBound(0, newValue, MAX_COUNTERS_ON_CARD); + int clampedValue = qBound(0, newValue, MAX_COUNTER_VALUE); if (clampedValue != oldValue) { auto *cmd = new Command_SetCardCounter; cmd->set_zone(card->getZone()->getName().toStdString()); @@ -1562,7 +1565,7 @@ void PlayerActions::actSetCardCounter(QList selectedCards, int count Expression exp(oldValue); double parsed = exp.parse(counterValue); // Clamp in double precision first to avoid UB, then cast - int number = static_cast(qBound(0.0, parsed, static_cast(MAX_COUNTERS_ON_CARD))); + int number = static_cast(qBound(0.0, parsed, static_cast(MAX_COUNTER_VALUE))); auto *cmd = new Command_SetCardCounter; cmd->set_zone(card->getZone()->getName().toStdString()); @@ -1592,7 +1595,7 @@ void PlayerActions::actIncrementAllCardCounters(QList cardsToUpdate) counterIterator.next(); int counterId = counterIterator.key(); int currentValue = counterIterator.value(); - if (currentValue >= MAX_COUNTERS_ON_CARD) { + if (currentValue >= MAX_COUNTER_VALUE) { continue; } @@ -1624,6 +1627,14 @@ static bool isUnwritableRevealZone(CardZoneLogic *zone) void PlayerActions::playSelectedCards(QList selectedCards, const bool faceDown) { + playSelectedCardsImpl(faceDown, nullptr); +} + +void PlayerActions::playSelectedCardsImpl(bool faceDown, + const std::function &postPlayCallback) +{ + QList selectedCards = player->getGameScene()->selectedCards(); + // CardIds will get shuffled downwards when cards leave the deck. // We need to iterate through the cards in reverse order so cardIds don't get changed out from under us as we play // out the cards one-by-one. @@ -1632,11 +1643,68 @@ void PlayerActions::playSelectedCards(QList selectedCards, const boo for (auto &card : selectedCards) { if (card && !isUnwritableRevealZone(card->getZone()) && card->getZone()->getName() != ZoneNames::TABLE) { + const QString originalZone = card->getZone()->getName(); playCard(card, faceDown); + if (postPlayCallback) { + postPlayCallback(card, originalZone); + } } } } +void PlayerActions::actPlayAndIncreaseTax() +{ + playSelectedCardsImpl(false, [this](CardItem * /*card*/, const QString &originalZone) { + if (originalZone == ZoneNames::COMMAND) { + AbstractCounter *ctr = player->getCounterWidget(CounterIds::CommanderTax); + if (ctr && ctr->isActive()) { + sendIncCounter(CounterIds::CommanderTax, 2); + } + } + }); +} + +void PlayerActions::actPlayAndIncreasePartnerTax() +{ + playSelectedCardsImpl(false, [this](CardItem * /*card*/, const QString &originalZone) { + if (originalZone == ZoneNames::COMMAND) { + AbstractCounter *ctr = player->getCounterWidget(CounterIds::PartnerTax); + if (ctr && ctr->isActive()) { + sendIncCounter(CounterIds::PartnerTax, 2); + } + } + }); +} + +void PlayerActions::sendIncCounter(int counterId, int delta) +{ + Command_IncCounter cmd; + cmd.set_counter_id(counterId); + cmd.set_delta(delta); + sendGameCommand(cmd); +} + +void PlayerActions::actModifyTaxCounter(int counterId, int delta) +{ + AbstractCounter *ctr = player->getCounterWidget(counterId); + if (!ctr || !ctr->isActive()) { + return; + } + sendIncCounter(counterId, delta); +} + +void PlayerActions::actToggleTaxCounter(int counterId) +{ + AbstractCounter *ctr = player->getCounterWidget(counterId); + if (!ctr || (ctr->isActive() && ctr->getValue() != 0)) { + return; + } + Command_SetCounterActive cmd; + cmd.set_counter_id(counterId); + cmd.set_active(!ctr->isActive()); + sendGameCommand(cmd); +} + void PlayerActions::actPlay(QList selectedCards) { playSelectedCards(selectedCards, false); @@ -1917,6 +1985,18 @@ void PlayerActions::cardMenuAction(QList selectedCards, CardMenuActi commandList.append(cmd); break; } + case cmMoveToCommandZone: { + auto *cmd = new Command_MoveCard; + cmd->set_start_player_id(startPlayerId); + cmd->set_start_zone(startZone.toStdString()); + cmd->mutable_cards_to_move()->CopyFrom(idList); + cmd->set_target_player_id(player->getPlayerInfo()->getId()); + cmd->set_target_zone(ZoneNames::COMMAND); + cmd->set_x(0); + cmd->set_y(0); + commandList.append(cmd); + break; + } case cmMoveToTable: { // Each card needs its own command because table row, pt, and cipt vary per card for (const auto &card : cardList) { diff --git a/cockatrice/src/game/player/player_actions.h b/cockatrice/src/game/player/player_actions.h index 3f1960892..3c552f509 100644 --- a/cockatrice/src/game/player/player_actions.h +++ b/cockatrice/src/game/player/player_actions.h @@ -17,6 +17,7 @@ #include #include +#include #include #include @@ -126,6 +127,14 @@ public slots: void actPlay(QList selectedCards); void actPlayFacedown(QList selectedCards); + /** @brief Plays the selected card and increments the primary commander tax counter. */ + void actPlayAndIncreaseTax(); + /** @brief Plays the selected card and increments the partner commander tax counter. */ + void actPlayAndIncreasePartnerTax(); + /** @brief Modifies a tax counter by delta if it is active. */ + void actModifyTaxCounter(int counterId, int delta); + /** @brief Toggles a tax counter's active state (only if inactive or value is 0). */ + void actToggleTaxCounter(int counterId); void actHide(QList selectedCards); void actMoveTopCardToPlay(); @@ -219,6 +228,8 @@ public slots: void cardMenuAction(QList selectedCards, CardMenuActionType type); private: + void sendIncCounter(int counterId, int delta); + PlayerLogic *player; int defaultNumberTopCards = 1; @@ -244,6 +255,14 @@ private: void playSelectedCards(QList selectedCards, bool faceDown = false); + /** + * @brief Shared implementation for playing selected cards with an optional post-play callback. + * @param postPlayCallback Called after each card is played, receiving the card and its *original* zone name + * (captured before playCard, since playCard sends a move command that may change the card's zone). + */ + void playSelectedCardsImpl(bool faceDown, + const std::function &postPlayCallback = nullptr); + void cmdSetTopCard(Command_MoveCard &cmd); void cmdSetBottomCard(Command_MoveCard &cmd); diff --git a/cockatrice/src/game/player/player_event_handler.cpp b/cockatrice/src/game/player/player_event_handler.cpp index bc48298f7..6900e2c16 100644 --- a/cockatrice/src/game/player/player_event_handler.cpp +++ b/cockatrice/src/game/player/player_event_handler.cpp @@ -4,6 +4,7 @@ #include "../../game_graphics/board/card_item.h" #include "../../game_graphics/zones/view_zone.h" #include "../../interface/widgets/tabs/tab_game.h" +#include "../board/abstract_counter.h" #include "../board/arrow_data.h" #include "../board/card_list.h" #include "player_actions.h" @@ -31,8 +32,10 @@ #include #include #include +#include #include #include +#include #include PlayerEventHandler::PlayerEventHandler(PlayerLogic *_player) : QObject(_player), player(_player) @@ -264,13 +267,31 @@ void PlayerEventHandler::eventCreateCounter(const Event_CreateCounter &event) void PlayerEventHandler::eventSetCounter(const Event_SetCounter &event) { - CounterState *ctr = player->getCounters().value(event.counter_id(), nullptr); - if (!ctr) { + CounterState *state = player->getCounters().value(event.counter_id(), nullptr); + if (!state) { return; } - int oldValue = ctr->getValue(); - ctr->setValue(event.value()); - emit logSetCounter(player, ctr->getName(), event.value(), oldValue); + int oldValue = state->getValue(); + state->setValue(event.value()); + + if (event.value() != oldValue) { + emit logSetCounter(player, state->getName(), event.value(), oldValue); + } +} + +void PlayerEventHandler::eventSetCounterActive(const Event_SetCounterActive &event) +{ + CounterState *state = player->getCounters().value(event.counter_id(), nullptr); + if (!state) { + return; + } + state->setActive(event.active()); + + AbstractCounter *widget = player->getGraphicsItem()->getCounterWidget(event.counter_id()); + if (widget) { + widget->setActive(event.active()); + emit player->rearrangeCounters(); + } } void PlayerEventHandler::eventDelCounter(const Event_DelCounter &event) @@ -627,6 +648,9 @@ void PlayerEventHandler::processGameEvent(GameEvent::GameEventType type, case GameEvent::SET_COUNTER: eventSetCounter(event.GetExtension(Event_SetCounter::ext)); break; + case GameEvent::SET_COUNTER_ACTIVE: + eventSetCounterActive(event.GetExtension(Event_SetCounterActive::ext)); + break; case GameEvent::DEL_COUNTER: eventDelCounter(event.GetExtension(Event_DelCounter::ext)); break; diff --git a/cockatrice/src/game/player/player_event_handler.h b/cockatrice/src/game/player/player_event_handler.h index cfd82933f..6416b0ed7 100644 --- a/cockatrice/src/game/player/player_event_handler.h +++ b/cockatrice/src/game/player/player_event_handler.h @@ -34,6 +34,7 @@ class Event_RollDie; class Event_SetCardAttr; class Event_SetCardCounter; class Event_SetCounter; +class Event_SetCounterActive; class Event_Shuffle; class Event_GameLogNotice; @@ -104,6 +105,7 @@ public: void eventSetCardCounter(const Event_SetCardCounter &event); void eventCreateCounter(const Event_CreateCounter &event); void eventSetCounter(const Event_SetCounter &event); + void eventSetCounterActive(const Event_SetCounterActive &event); void eventDelCounter(const Event_DelCounter &event); void eventDumpZone(const Event_DumpZone &event); void eventMoveCard(const Event_MoveCard &event, const GameEventContext &context); diff --git a/cockatrice/src/game/player/player_logic.cpp b/cockatrice/src/game/player/player_logic.cpp index 485e2fc5c..35b197763 100644 --- a/cockatrice/src/game/player/player_logic.cpp +++ b/cockatrice/src/game/player/player_logic.cpp @@ -12,6 +12,10 @@ #include "../../interface/theme_manager.h" #include "../../interface/widgets/tabs/tab_game.h" #include "../board/card_list.h" +#include "../board/commander_tax_counter.h" +#include "../board/counter_general.h" +#include "../game_scene.h" +#include "../zones/command_zone.h" #include "player_actions.h" #include @@ -28,11 +32,12 @@ #include #include #include +#include PlayerLogic::PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool _judge, AbstractGame *_parent) : QObject(_parent), game(_parent), playerInfo(new PlayerInfo(info, _id, _local, _judge)), playerEventHandler(new PlayerEventHandler(this)), playerActions(new PlayerActions(this)), active(false), - conceded(false), zoneId(0), dialogSemaphore(false) + conceded(false), zoneId(0), dialogSemaphore(false), serverHasCommandZone(false) { initializeZones(); } @@ -48,6 +53,7 @@ void PlayerLogic::initializeZones() bool visibleHand = playerInfo->getLocalOrJudge() || (game->getPlayerManager()->isSpectator() && game->getGameMetaInfo()->spectatorsOmniscient()); addZone(new HandZoneLogic(this, ZoneNames::HAND, false, false, visibleHand, this)); + addZone(new CommandZoneLogic(this, ZoneNames::COMMAND, true, false, true, this)); } PlayerLogic::~PlayerLogic() @@ -104,7 +110,9 @@ void PlayerLogic::processPlayerInfo(const ServerInfo_Player &info) /* StackZone */ ZoneNames::STACK, /* HandZone */ - ZoneNames::HAND}; + ZoneNames::HAND, + /* CommandZone */ + ZoneNames::COMMAND}; clearCounters(); emit arrowsClearedLocally(); @@ -119,7 +127,19 @@ void PlayerLogic::processPlayerInfo(const ServerInfo_Player &info) emit clearCustomZonesMenu(); + // Check if server has command zone by scanning the zone list const int zoneListSize = info.zone_list_size(); + bool foundCommandZone = false; + for (int i = 0; i < zoneListSize; ++i) { + if (QString::fromStdString(info.zone_list(i).name()) == ZoneNames::COMMAND) { + foundCommandZone = true; + break; + } + } + if (serverHasCommandZone != foundCommandZone) { + serverHasCommandZone = foundCommandZone; + emit commandZoneSupportChanged(foundCommandZone); + } for (int i = 0; i < zoneListSize; ++i) { const ServerInfo_Zone &zoneInfo = info.zone_list(i); @@ -253,15 +273,17 @@ void PlayerLogic::setDeck(const DeckList &_deck) CounterState *PlayerLogic::addCounter(const ServerInfo_Counter &counter) { return addCounter(counter.id(), QString::fromStdString(counter.name()), - convertColorToQColor(counter.counter_color()), counter.radius(), counter.count()); + convertColorToQColor(counter.counter_color()), counter.radius(), counter.count(), + counter.active()); } -CounterState *PlayerLogic::addCounter(int id, const QString &name, const QColor &color, int radius, int value) +CounterState * +PlayerLogic::addCounter(int id, const QString &name, const QColor &color, int radius, int value, bool active) { if (counters.contains(id)) { return nullptr; } - auto *state = new CounterState(id, name, color, radius, value, this); + auto *state = new CounterState(id, name, color, radius, value, active, this); counters.insert(id, state); emit counterAdded(state); return state; @@ -296,6 +318,11 @@ CounterState *PlayerLogic::getLifeCounter() const return nullptr; } +AbstractCounter *PlayerLogic::getCounterWidget(int counterId) const +{ + return graphicsItem->getCounterWidget(counterId); +} + bool PlayerLogic::clearCardsToDelete() { if (cardsToDelete.isEmpty()) { diff --git a/cockatrice/src/game/player/player_logic.h b/cockatrice/src/game/player/player_logic.h index a89cb6eed..4bb22f80c 100644 --- a/cockatrice/src/game/player/player_logic.h +++ b/cockatrice/src/game/player/player_logic.h @@ -11,6 +11,7 @@ #include "../../interface/widgets/menus/tearoff_menu.h" #include "../board/arrow_data.h" #include "../interface/deck_loader/loaded_deck.h" +#include "../zones/command_zone_logic.h" #include "../zones/hand_zone_logic.h" #include "../zones/pile_zone_logic.h" #include "../zones/stack_zone_logic.h" @@ -57,6 +58,7 @@ class ServerInfo_Counter; class ServerInfo_Player; class ServerInfo_User; class TabGame; +class AbstractCounter; const int MAX_TOKENS_PER_DIALOG = 99; @@ -87,6 +89,7 @@ signals: void arrowDeleteRequested(int creatorId, int arrowId); void arrowDeleted(int creatorId, int arrowId); void arrowsClearedLocally(); // fires on clear() and processPlayerInfo + void commandZoneSupportChanged(bool hasCommandZone); public slots: void setActive(bool _active); @@ -191,8 +194,21 @@ public: return qobject_cast(zones.value(ZoneNames::HAND)); } + /** @brief Returns the command zone logic, or nullptr if not present. */ + CommandZoneLogic *getCommandZone() + { + return qobject_cast(zones.value(ZoneNames::COMMAND)); + } + + /** @brief Whether the server confirmed command zone support for this game. */ + bool hasServerCommandZone() const + { + return serverHasCommandZone; + } + CounterState *addCounter(const ServerInfo_Counter &counter); - CounterState *addCounter(int id, const QString &name, const QColor &color, int radius, int value); + CounterState * + addCounter(int id, const QString &name, const QColor &color, int radius, int value, bool active = true); void delCounter(int counterId); void clearCounters(); @@ -206,6 +222,9 @@ public: */ CounterState *getLifeCounter() const; + /** @brief Returns the counter widget for the given ID, or nullptr if not found. */ + AbstractCounter *getCounterWidget(int counterId) const; + void setConceded(bool _conceded); bool getConceded() const { @@ -242,6 +261,7 @@ private: QMap counters; bool dialogSemaphore; + bool serverHasCommandZone; QList cardsToDelete; }; diff --git a/cockatrice/src/game/zones/card_zone_logic.cpp b/cockatrice/src/game/zones/card_zone_logic.cpp index 7e0585f4e..136f8bd72 100644 --- a/cockatrice/src/game/zones/card_zone_logic.cpp +++ b/cockatrice/src/game/zones/card_zone_logic.cpp @@ -202,6 +202,9 @@ QString CardZoneLogic::getTranslatedName(bool theirOwn, GrammaticalCase gc) cons return (theirOwn ? tr("their graveyard", "nominative") : tr("%1's graveyard", "nominative").arg(ownerName)); } else if (name == ZoneNames::EXILE) { return (theirOwn ? tr("their exile", "nominative") : tr("%1's exile", "nominative").arg(ownerName)); + } else if (name == ZoneNames::COMMAND) { + return (theirOwn ? tr("their command zone", "nominative") + : tr("%1's command zone", "nominative").arg(ownerName)); } else if (name == ZoneNames::SIDEBOARD) { switch (gc) { case CaseLookAtZone: diff --git a/cockatrice/src/game/zones/command_zone.cpp b/cockatrice/src/game/zones/command_zone.cpp new file mode 100644 index 000000000..cbac7ce31 --- /dev/null +++ b/cockatrice/src/game/zones/command_zone.cpp @@ -0,0 +1,176 @@ +#include "command_zone.h" + +#include "../../client/settings/cache_settings.h" +#include "../../game_graphics/zones/select_zone.h" +#include "../../interface/theme_manager.h" +#include "../board/card_drag_item.h" +#include "../board/card_item.h" +#include "../board/commander_tax_counter.h" +#include "../player/player_actions.h" +#include "../player/player_logic.h" +#include "../z_values.h" + +#include +#include +#include +#include + +CommandZone::CommandZone(CommandZoneLogic *_logic, int _zoneHeight, QGraphicsItem *parent) + : SelectZone(_logic, parent), zoneHeight(_zoneHeight) +{ + connect(themeManager, &ThemeManager::themeChanged, this, &CommandZone::updateBg); + updateBg(); + setCacheMode(DeviceCoordinateCache); + setupClipContainer(ZValues::CARD_BASE); +} + +void CommandZone::updateBg() +{ + update(); +} + +QRectF CommandZone::boundingRect() const +{ + return {0, 0, ZoneSizes::COMMAND_ZONE_WIDTH, currentHeight()}; +} + +qreal CommandZone::currentHeight() const +{ + return minimized ? qMax(zoneHeight * MINIMIZED_HEIGHT_RATIO, static_cast(minimumHeight)) : zoneHeight; +} + +void CommandZone::setMinimumHeight(int height) +{ + if (minimumHeight == height) { + return; + } + minimumHeight = height; + prepareGeometryChange(); + updateClipRect(); + reorganizeCards(); + update(); + // NOTE: Do NOT emit minimizedChanged here. The minimized STATE has not changed, + // only the minimum height constraint. Emitting here causes an infinite loop: + // rearrangeZones -> rearrangeCounters -> rearrangeTaxCounters -> setMinimumHeight + // -> minimizedChanged -> rearrangeZones (loop!) +} + +bool CommandZone::isMinimized() const +{ + return minimized; +} + +void CommandZone::toggleMinimized() +{ + minimized = !minimized; + + prepareGeometryChange(); + updateClipRect(); + reorganizeCards(); + update(); + + emit minimizedChanged(minimized); +} + +void CommandZone::paint(QPainter *painter, + [[maybe_unused]] const QStyleOptionGraphicsItem *option, + [[maybe_unused]] QWidget *widget) +{ + QBrush brush = themeManager->getExtraBgBrush(ThemeManager::Command, getLogic()->getPlayer()->getZoneId()); + + QPointF scenePos = mapToScene(QPointF(0, 0)); + painter->setBrushOrigin(-scenePos); + + painter->fillRect(boundingRect(), brush); +} + +void CommandZone::handleDropEvent(const QList &dragItems, + CardZoneLogic *startZone, + const QPoint &dropPoint) +{ + if (startZone == nullptr || startZone->getPlayer() == nullptr || dragItems.isEmpty()) { + return; + } + + int index = calcDropIndexFromY(dropPoint.y(), MIN_CARD_VISIBLE); + + // Same-zone no-op: don't move a card onto itself + const auto &cards = getLogic()->getCards(); + if (!cards.isEmpty() && startZone == getLogic() && cards.at(index)->getId() == dragItems.at(0)->getId()) { + return; + } + + Command_MoveCard cmd; + cmd.set_start_player_id(startZone->getPlayer()->getPlayerInfo()->getId()); + cmd.set_start_zone(startZone->getName().toStdString()); + cmd.set_target_player_id(getLogic()->getPlayer()->getPlayerInfo()->getId()); + cmd.set_target_zone(getLogic()->getName().toStdString()); + cmd.set_x(index); + cmd.set_y(0); + + for (const CardDragItem *item : dragItems) { + if (item) { + auto *cardToMove = cmd.mutable_cards_to_move()->add_card(); + cardToMove->set_card_id(item->getId()); + if (item->isForceFaceDown()) { + cardToMove->set_face_down(true); + } + } + } + + getLogic()->getPlayer()->getPlayerActions()->sendGameCommand(cmd); +} + +void CommandZone::reorganizeCards() +{ + restoreStaleEscapedCards(); + updateClipRect(); + + const auto &cards = getLogic()->getCards(); + if (cards.isEmpty()) { + update(); + return; + } + + auto params = buildStackParams(MIN_CARD_VISIBLE); + params.allowBottomOverflow = true; + layoutCardsVertically(params); + update(); +} + +void CommandZone::rearrangeTaxCounters() +{ + bool commandZoneVisible = isVisible(); + int activeTaxCounterCount = 0; + + auto *graphicsItem = getLogic()->getPlayer()->getGraphicsItem(); + if (!graphicsItem) { + return; + } + + for (AbstractCounter *ctr : graphicsItem->getTaxCounterWidgets()) { + qreal y = TaxCounterSizes::TAX_COUNTER_MARGIN + + activeTaxCounterCount * (TaxCounterSizes::TAX_COUNTER_SIZE + TaxCounterSizes::TAX_COUNTER_MARGIN); + ctr->setPos(TaxCounterSizes::TAX_COUNTER_MARGIN, y); + ctr->setZValue(ZValues::TAX_COUNTERS); + bool visible = commandZoneVisible && ctr->isActive(); + ctr->setVisible(visible); + if (visible) { + ++activeTaxCounterCount; + } + } + + int minHeight = activeTaxCounterCount * (TaxCounterSizes::TAX_COUNTER_SIZE + TaxCounterSizes::TAX_COUNTER_MARGIN) + + TaxCounterSizes::TAX_COUNTER_MARGIN; + setMinimumHeight(minHeight); +} + +void CommandZone::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) +{ + if (event->button() == Qt::LeftButton) { + toggleMinimized(); + event->accept(); + } else { + SelectZone::mouseDoubleClickEvent(event); + } +} diff --git a/cockatrice/src/game/zones/command_zone.h b/cockatrice/src/game/zones/command_zone.h new file mode 100644 index 000000000..4a6143890 --- /dev/null +++ b/cockatrice/src/game/zones/command_zone.h @@ -0,0 +1,103 @@ +/** + * @file command_zone.h + * @ingroup GameGraphicsZones + * @brief Graphics layer for the command zone, used for Commander format. + */ + +#ifndef COCKATRICE_COMMAND_ZONE_H +#define COCKATRICE_COMMAND_ZONE_H + +#include "../../game_graphics/zones/select_zone.h" +#include "../card_dimensions.h" +#include "command_zone_logic.h" + +#include + +inline Q_LOGGING_CATEGORY(CommandZoneLog, "command_zone"); + +/** + * @namespace ZoneSizes + * @brief Size constants for the command zone and its sub-elements. + */ +namespace ZoneSizes +{ + +/** @brief Height of the command zone (accommodates a card plus padding) */ +constexpr qreal COMMAND_ZONE_HEIGHT = CardDimensions::HEIGHT + 8; + +/** @brief Width of the command zone (matches stack zone) */ +constexpr qreal COMMAND_ZONE_WIDTH = CardDimensions::WIDTH_F * 1.5; + +} // namespace ZoneSizes + +/** + * @class CommandZone + * @brief Graphics layer for the command zone in Commander format games. + * + * Always visible when enabled. Supports multiple cards using a zigzag + * horizontal stacking pattern: single cards display centered, multiple + * cards alternate left-right with vertical overlap compression. + * Can be minimized to 25% height via double-click. + * + * @see CommandZoneLogic for card data management + * @see CommanderTaxCounter for the tax counter overlay + */ +class CommandZone : public SelectZone +{ + Q_OBJECT +public: + static constexpr qreal MINIMUM_STACKING_HEIGHT = 50.0; + +private: + static constexpr double MINIMIZED_HEIGHT_RATIO = 0.25; + int zoneHeight; ///< Full height in pixels when expanded + bool minimized = false; ///< Whether zone is at 25% height + int minimumHeight = 0; ///< Floor for minimized height (e.g. to fit tax counters) + +public: + /** + * @brief Constructs a CommandZone graphics item. + * @param _logic Logic layer managing card data + * @param _zoneHeight Zone height in pixels + * @param parent Parent graphics item + */ + CommandZone(CommandZoneLogic *_logic, int _zoneHeight, QGraphicsItem *parent); + + /** + * @brief Handles card drops, calculating insertion position from drop point. + * @param dragItems Cards being dragged + * @param startZone Source zone + * @param dropPoint Drop position in local coordinates + */ + void + handleDropEvent(const QList &dragItems, CardZoneLogic *startZone, const QPoint &dropPoint) override; + + /** @brief Returns the bounding rectangle, accounting for minimized state. */ + [[nodiscard]] QRectF boundingRect() const override; + /** @brief Paints the zone background using the Commander theme brush. */ + void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override; + /** @brief Repositions cards using zigzag horizontal stacking with overlap compression. */ + void reorganizeCards() override; + + /** @brief Toggles between full and 25% minimized height. */ + void toggleMinimized(); + [[nodiscard]] bool isMinimized() const; + /** @brief Returns the current display height (full or minimized). */ + [[nodiscard]] qreal currentHeight() const; + /** @brief Sets the minimum height floor, e.g. to ensure tax counters remain visible. */ + void setMinimumHeight(int height); + /** @brief Lays out visible tax counters vertically in the top-left corner of the command zone. */ + void rearrangeTaxCounters(); + +signals: + /** @brief Emitted when the zone toggles between minimized and expanded states. */ + void minimizedChanged(bool isMinimized); + +protected: + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override; + +private slots: + void updateBg(); +}; + +#endif // COCKATRICE_COMMAND_ZONE_H diff --git a/cockatrice/src/game/zones/command_zone_logic.cpp b/cockatrice/src/game/zones/command_zone_logic.cpp new file mode 100644 index 000000000..3e97ece41 --- /dev/null +++ b/cockatrice/src/game/zones/command_zone_logic.cpp @@ -0,0 +1,19 @@ +#include "command_zone_logic.h" + +#include "../board/card_item.h" +#include "card_zone_algorithms.h" + +CommandZoneLogic::CommandZoneLogic(PlayerLogic *_player, + const QString &_name, + bool _hasCardAttr, + bool _isShufflable, + bool _contentsKnown, + QObject *parent) + : CardZoneLogic(_player, _name, _hasCardAttr, _isShufflable, _contentsKnown, parent) +{ +} + +void CommandZoneLogic::addCardImpl(CardItem *card, int x, int /*y*/) +{ + CardZoneAlgorithms::addCardToList(cards, card, x, false); +} diff --git a/cockatrice/src/game/zones/command_zone_logic.h b/cockatrice/src/game/zones/command_zone_logic.h new file mode 100644 index 000000000..8085537ab --- /dev/null +++ b/cockatrice/src/game/zones/command_zone_logic.h @@ -0,0 +1,51 @@ +/** + * @file command_zone_logic.h + * @ingroup GameLogicZones + * @brief Logic layer for the command zone, used for Commander format. + */ + +#ifndef COCKATRICE_COMMAND_ZONE_LOGIC_H +#define COCKATRICE_COMMAND_ZONE_LOGIC_H +#include "card_zone_logic.h" + +/** + * @class CommandZoneLogic + * @brief Logic layer for managing cards in the command zone. + * + * Handles data storage and card management for the command zone in Commander format. + * Supports ordered card insertion for drag-and-drop operations. + * + * @see CommandZone for the graphics layer + * @see CardZoneLogic + */ +class CommandZoneLogic : public CardZoneLogic +{ + Q_OBJECT +public: + /** + * @brief Constructs a CommandZoneLogic instance. + * @param _player The player who owns this zone + * @param _name Zone name (ZoneNames::COMMAND) + * @param _hasCardAttr Whether cards in this zone have attributes + * @param _isShufflable Whether the zone can be shuffled + * @param _contentsKnown Whether the zone contents are public knowledge + * @param parent Parent QObject + */ + CommandZoneLogic(PlayerLogic *_player, + const QString &_name, + bool _hasCardAttr, + bool _isShufflable, + bool _contentsKnown, + QObject *parent = nullptr); + +protected: + /** + * @brief Adds a card at position x (y ignored). Appends if x is -1 or out of range. + * @param card Card to add + * @param x Insertion index, or -1 to append + * @param y Unused + */ + void addCardImpl(CardItem *card, int x, int y) override; +}; + +#endif // COCKATRICE_COMMAND_ZONE_LOGIC_H diff --git a/cockatrice/src/game_graphics/board/abstract_counter.cpp b/cockatrice/src/game_graphics/board/abstract_counter.cpp index 219dd456e..ac092803d 100644 --- a/cockatrice/src/game_graphics/board/abstract_counter.cpp +++ b/cockatrice/src/game_graphics/board/abstract_counter.cpp @@ -79,6 +79,19 @@ void AbstractCounter::delCounter() } } +void AbstractCounter::setValue(int _value) +{ + value = _value; + update(); +} + +void AbstractCounter::setActive(bool _active) +{ + active = _active; + setVisible(_active); + update(); +} + void AbstractCounter::retranslateUi() { if (aSet) { diff --git a/cockatrice/src/game_graphics/board/abstract_counter.h b/cockatrice/src/game_graphics/board/abstract_counter.h index b319a722d..d65ec9825 100644 --- a/cockatrice/src/game_graphics/board/abstract_counter.h +++ b/cockatrice/src/game_graphics/board/abstract_counter.h @@ -1,6 +1,7 @@ /** * @file abstract_counter.h * @ingroup GameGraphicsPlayers + * @brief Abstract base for player counters displayed on the game board. */ //! \todo Document this file. @@ -61,6 +62,13 @@ public: ~AbstractCounter() override; void retranslateUi() override; + + /** + * @brief Sets the counter value and triggers a visual update. + * Virtual to allow subclass display customization (e.g., CommanderTaxCounter tooltip updates). + * Overflow protection is handled server-side, not in client counter classes. + */ + virtual void setValue(int _value); void setShortcutsActive() override; void setShortcutsInactive() override; void delCounter(); @@ -93,6 +101,25 @@ public: { return shownInCounterArea; } + + /** + * @brief Returns whether this counter is active (visible and interactable). + * Inactive counters are hidden and their menu actions should be disabled. + */ + [[nodiscard]] bool isActive() const + { + return active; + } + + /** + * @brief Sets the active state of this counter. + * When inactive, the counter is hidden via setVisible(false). + * @param _active True to show and enable the counter, false to hide it + */ + virtual void setActive(bool _active); + +private: + bool active = true; }; class AbstractCounterDialog : public QInputDialog diff --git a/cockatrice/src/game_graphics/board/translate_counter_name.cpp b/cockatrice/src/game_graphics/board/translate_counter_name.cpp index 4f1c97657..892eea426 100644 --- a/cockatrice/src/game_graphics/board/translate_counter_name.cpp +++ b/cockatrice/src/game_graphics/board/translate_counter_name.cpp @@ -8,4 +8,6 @@ const QMap TranslateCounterName::translated = { {"r", QT_TRANSLATE_NOOP("TranslateCounterName", "Red")}, {"g", QT_TRANSLATE_NOOP("TranslateCounterName", "Green")}, {"x", QT_TRANSLATE_NOOP("TranslateCounterName", "Colorless")}, - {"storm", QT_TRANSLATE_NOOP("TranslateCounterName", "Other")}}; + {"storm", QT_TRANSLATE_NOOP("TranslateCounterName", "Other")}, + {"commander_tax_counter", QT_TRANSLATE_NOOP("TranslateCounterName", "Commander Tax")}, + {"partner_tax_counter", QT_TRANSLATE_NOOP("TranslateCounterName", "Partner Tax")}}; diff --git a/cockatrice/src/game_graphics/log/message_log_widget.cpp b/cockatrice/src/game_graphics/log/message_log_widget.cpp index ccd903b04..423a66e92 100644 --- a/cockatrice/src/game_graphics/log/message_log_widget.cpp +++ b/cockatrice/src/game_graphics/log/message_log_widget.cpp @@ -10,6 +10,7 @@ #include #include +#include #include #include @@ -80,6 +81,8 @@ MessageLogWidget::getFromStr(CardZoneLogic *zone, QString cardName, int position fromStr = tr(" from sideboard"); } else if (zoneName == ZoneNames::STACK) { fromStr = tr(" from the stack"); + } else if (zoneName == ZoneNames::COMMAND) { + fromStr = tr(" from the command zone"); } else { fromStr = tr(" from custom zone '%1'").arg(zoneName); } @@ -344,6 +347,8 @@ void MessageLogWidget::logMoveCard(PlayerLogic *player, } else { finalStr = tr("%1 plays %2%3."); } + } else if (targetZoneName == ZoneNames::COMMAND) { + finalStr = tr("%1 moves %2%3 to the command zone."); } else { fourthArg = targetZoneName; if (card->getFaceDown()) { @@ -671,6 +676,20 @@ void MessageLogWidget::logSetCounter(PlayerLogic *player, QString counterName, i soundEngine->playSound("life_change"); } + if (counterName == CounterNames::CommanderTax || counterName == CounterNames::PartnerTax) { + QString playerName = sanitizeHtml(player->getPlayerInfo()->getName()); + QString valueStr = QString("%1").arg(value); + int delta = value - oldValue; + QString counterDisplayName = TranslateCounterName::getDisplayName(counterName); + QString taxLabel = QString("%1").arg(sanitizeHtml(counterDisplayName)); + if (value > oldValue) { + appendHtmlServerMessage(tr("%1 increases %2 to %3 (+%4).").arg(playerName, taxLabel, valueStr).arg(delta)); + } else { + appendHtmlServerMessage(tr("%1 decreases %2 to %3 (%4).").arg(playerName, taxLabel, valueStr).arg(delta)); + } + return; + } + QString counterDisplayName = TranslateCounterName::getDisplayName(counterName); appendHtmlServerMessage(tr("%1 sets counter %2 to %3 (%4%5).") .arg(sanitizeHtml(player->getPlayerInfo()->getName())) diff --git a/cockatrice/src/game_graphics/player/card_menu_action_type.h b/cockatrice/src/game_graphics/player/card_menu_action_type.h index 4cae22716..f0fc1bd37 100644 --- a/cockatrice/src/game_graphics/player/card_menu_action_type.h +++ b/cockatrice/src/game_graphics/player/card_menu_action_type.h @@ -22,7 +22,8 @@ enum CardMenuActionType cmMoveToHand, cmMoveToGraveyard, cmMoveToExile, - cmMoveToTable + cmMoveToTable, + cmMoveToCommandZone }; #endif // COCKATRICE_CARD_MENU_ACTION_TYPE_H diff --git a/cockatrice/src/game_graphics/player/menu/card_menu.cpp b/cockatrice/src/game_graphics/player/menu/card_menu.cpp index aa94c3be7..cac772023 100644 --- a/cockatrice/src/game_graphics/player/menu/card_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/card_menu.cpp @@ -2,6 +2,7 @@ #include "../../../client/settings/card_counter_settings.h" #include "../../../interface/widgets/tabs/tab_game.h" +#include "../../board/abstract_counter.h" #include "../../board/card_item.h" #include "../../game/player/player_actions.h" #include "../../game/player/player_logic.h" @@ -14,6 +15,7 @@ #include #include #include +#include #include /** @@ -92,6 +94,12 @@ CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _sho aSelectRow = new QAction(this); aSelectColumn = new QAction(this); + aPlayAndIncreaseTax = new QAction(this); + connect(aPlayAndIncreaseTax, &QAction::triggered, playerActions, &PlayerActions::actPlayAndIncreaseTax); + aPlayAndIncreasePartnerTax = new QAction(this); + connect(aPlayAndIncreasePartnerTax, &QAction::triggered, playerActions, + &PlayerActions::actPlayAndIncreasePartnerTax); + connect(aAttach, &QAction::triggered, actions, &PlayerActions::actAttach); connect(aDrawArrow, &QAction::triggered, actions, &PlayerActions::actDrawArrow); connect(aSelectAll, &QAction::triggered, actions, &PlayerActions::actSelectAll); @@ -157,6 +165,33 @@ CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _sho } else if (card->getZone()->getName() == ZoneNames::EXILE || card->getZone()->getName() == ZoneNames::GRAVE) { createGraveyardOrExileMenu(writeableCard); + } else if (card->getZone()->getName() == ZoneNames::COMMAND) { + if (writeableCard) { + addAction(aPlay); + + AbstractCounter *cmdTax = player->getCounterWidget(CounterIds::CommanderTax); + if (cmdTax && cmdTax->isActive()) { + addAction(aPlayAndIncreaseTax); + } + + AbstractCounter *partnerTax = player->getCounterWidget(CounterIds::PartnerTax); + if (partnerTax && partnerTax->isActive()) { + addAction(aPlayAndIncreasePartnerTax); + } + + // No reveal submenu - command zone is public + addSeparator(); + addAction(aClone); + addMenu(new MoveMenu(player)); + } else { + addAction(aDrawArrow); + addSeparator(); + addAction(aClone); + } + addSeparator(); + addAction(aSelectAll); + addRelatedCardView(); + addRelatedCardActions(); } else { createHandOrCustomZoneMenu(writeableCard); } @@ -487,6 +522,8 @@ void CardMenu::retranslateUi() aPlay->setText(tr("&Play")); aHide->setText(tr("&Hide")); aPlayFacedown->setText(tr("Play &Face Down")); + aPlayAndIncreaseTax->setText(tr("Play and &Increase Commander Tax")); + aPlayAndIncreasePartnerTax->setText(tr("Play and Increase &Partner Tax")); aRevealToAll->setText(tr("&All players")); //: Turn sideways or back again aTap->setText(tr("&Tap / Untap")); diff --git a/cockatrice/src/game_graphics/player/menu/card_menu.h b/cockatrice/src/game_graphics/player/menu/card_menu.h index d67ef3876..c4eba1c46 100644 --- a/cockatrice/src/game_graphics/player/menu/card_menu.h +++ b/cockatrice/src/game_graphics/player/menu/card_menu.h @@ -32,6 +32,9 @@ public: QMenu *mCardCounters; QAction *aPlay, *aPlayFacedown; + QAction * + aPlayAndIncreaseTax; ///< Plays card and increments the primary commander tax counter (CounterIds::CommanderTax) + QAction *aPlayAndIncreasePartnerTax; QAction *aRevealToAll; QAction *aHide; QAction *aClone; diff --git a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp new file mode 100644 index 000000000..f7d979b7d --- /dev/null +++ b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp @@ -0,0 +1,184 @@ +#include "command_zone_menu.h" + +#include "../../../client/settings/cache_settings.h" +#include "../../board/abstract_counter.h" +#include "../../game_scene.h" +#include "../../zones/command_zone.h" +#include "../player_actions.h" +#include "../player_graphics_item.h" +#include "../player_logic.h" + +#include +#include + +CommandZoneMenu::CommandZoneMenu(PlayerLogic *_player, QMenu *playerMenu) : QMenu(playerMenu), player(_player) +{ + viewZoneShortcutKey = QStringLiteral("Player/aViewCommandZone"); + incTaxShortcutKey = QStringLiteral("Player/aAddCommanderTax"); + decTaxShortcutKey = QStringLiteral("Player/aRemoveCommanderTax"); + incPartnerTaxShortcutKey = QStringLiteral("Player/aAddPartnerTax"); + decPartnerTaxShortcutKey = QStringLiteral("Player/aRemovePartnerTax"); + + aViewZone = new QAction(this); + connect(aViewZone, &QAction::triggered, this, + [this]() { player->getGameScene()->toggleZoneView(player, ZoneNames::COMMAND, -1); }); + + if (player->getPlayerInfo()->getLocalOrJudge()) { + addAction(aViewZone); + addSeparator(); + + PlayerActions *playerActions = player->getPlayerActions(); + + aIncreaseCommanderTax = new QAction(this); + connect(aIncreaseCommanderTax, &QAction::triggered, this, + [playerActions]() { playerActions->actModifyTaxCounter(CounterIds::CommanderTax, 1); }); + addAction(aIncreaseCommanderTax); + + aDecreaseCommanderTax = new QAction(this); + connect(aDecreaseCommanderTax, &QAction::triggered, this, + [playerActions]() { playerActions->actModifyTaxCounter(CounterIds::CommanderTax, -1); }); + addAction(aDecreaseCommanderTax); + + addSeparator(); + + aIncreasePartnerTax = new QAction(this); + connect(aIncreasePartnerTax, &QAction::triggered, this, + [playerActions]() { playerActions->actModifyTaxCounter(CounterIds::PartnerTax, 1); }); + addAction(aIncreasePartnerTax); + + aDecreasePartnerTax = new QAction(this); + connect(aDecreasePartnerTax, &QAction::triggered, this, + [playerActions]() { playerActions->actModifyTaxCounter(CounterIds::PartnerTax, -1); }); + addAction(aDecreasePartnerTax); + + addSeparator(); + + aToggleCommanderTaxCounter = new QAction(this); + connect(aToggleCommanderTaxCounter, &QAction::triggered, this, + [playerActions]() { playerActions->actToggleTaxCounter(CounterIds::CommanderTax); }); + addAction(aToggleCommanderTaxCounter); + + aTogglePartnerTaxCounter = new QAction(this); + connect(aTogglePartnerTaxCounter, &QAction::triggered, this, + [playerActions]() { playerActions->actToggleTaxCounter(CounterIds::PartnerTax); }); + addAction(aTogglePartnerTaxCounter); + + addSeparator(); + + aToggleMinimized = new QAction(this); + connect(aToggleMinimized, &QAction::triggered, this, &CommandZoneMenu::actToggleMinimized); + addAction(aToggleMinimized); + + connect(this, &QMenu::aboutToShow, this, &CommandZoneMenu::updateTaxCounterActionStates); + } + + retranslateUi(); +} + +void CommandZoneMenu::retranslateUi() +{ + setTitle(tr("Co&mmander")); + if (aViewZone) { + aViewZone->setText(tr("&View command zone")); + } + if (aIncreaseCommanderTax) { + aIncreaseCommanderTax->setText(tr("&Increase Commander Tax (+1)")); + } + if (aDecreaseCommanderTax) { + aDecreaseCommanderTax->setText(tr("&Decrease Commander Tax (-1)")); + } + if (aToggleCommanderTaxCounter) { + aToggleCommanderTaxCounter->setText(tr("&Remove Commander Tax")); + } + if (aIncreasePartnerTax) { + aIncreasePartnerTax->setText(tr("Increase &Partner Tax (+1)")); + } + if (aDecreasePartnerTax) { + aDecreasePartnerTax->setText(tr("Decrease P&artner Tax (-1)")); + } + if (aTogglePartnerTaxCounter) { + aTogglePartnerTaxCounter->setText(tr("&Add Partner Tax")); + } + if (aToggleMinimized) { + aToggleMinimized->setText(tr("&Minimize")); + } +} + +void CommandZoneMenu::actToggleMinimized() +{ + CommandZone *zone = player->getGraphicsItem()->getCommandZoneGraphicsItem(); + if (zone) { + zone->toggleMinimized(); + } +} + +void CommandZoneMenu::updateTaxCounterActionStates() +{ + AbstractCounter *cmdTax = player->getCounterWidget(CounterIds::CommanderTax); + bool cmdActive = cmdTax && cmdTax->isActive(); + + AbstractCounter *partnerTax = player->getCounterWidget(CounterIds::PartnerTax); + bool partnerActive = partnerTax && partnerTax->isActive(); + + if (aIncreaseCommanderTax) { + aIncreaseCommanderTax->setVisible(cmdActive); + } + if (aDecreaseCommanderTax) { + aDecreaseCommanderTax->setVisible(cmdActive); + } + if (aToggleCommanderTaxCounter) { + aToggleCommanderTaxCounter->setText(cmdActive ? tr("&Remove Commander Tax") : tr("&Add Commander Tax")); + aToggleCommanderTaxCounter->setVisible(!cmdActive || (cmdTax && cmdTax->getValue() == 0)); + } + + if (aIncreasePartnerTax) { + aIncreasePartnerTax->setVisible(partnerActive); + } + if (aDecreasePartnerTax) { + aDecreasePartnerTax->setVisible(partnerActive); + } + if (aTogglePartnerTaxCounter) { + aTogglePartnerTaxCounter->setText(partnerActive ? tr("R&emove Partner Tax") : tr("&Add Partner Tax")); + aTogglePartnerTaxCounter->setVisible(!partnerActive || (partnerTax && partnerTax->getValue() == 0)); + } +} + +void CommandZoneMenu::setShortcutsActive() +{ + ShortcutsSettings &shortcuts = SettingsCache::instance().shortcuts(); + + if (aViewZone) { + aViewZone->setShortcuts(shortcuts.getShortcut(viewZoneShortcutKey)); + } + if (aIncreaseCommanderTax) { + aIncreaseCommanderTax->setShortcuts(shortcuts.getShortcut(incTaxShortcutKey)); + } + if (aDecreaseCommanderTax) { + aDecreaseCommanderTax->setShortcuts(shortcuts.getShortcut(decTaxShortcutKey)); + } + if (aIncreasePartnerTax) { + aIncreasePartnerTax->setShortcuts(shortcuts.getShortcut(incPartnerTaxShortcutKey)); + } + if (aDecreasePartnerTax) { + aDecreasePartnerTax->setShortcuts(shortcuts.getShortcut(decPartnerTaxShortcutKey)); + } +} + +void CommandZoneMenu::setShortcutsInactive() +{ + if (aViewZone) { + aViewZone->setShortcut(QKeySequence()); + } + if (aIncreaseCommanderTax) { + aIncreaseCommanderTax->setShortcut(QKeySequence()); + } + if (aDecreaseCommanderTax) { + aDecreaseCommanderTax->setShortcut(QKeySequence()); + } + if (aIncreasePartnerTax) { + aIncreasePartnerTax->setShortcut(QKeySequence()); + } + if (aDecreasePartnerTax) { + aDecreasePartnerTax->setShortcut(QKeySequence()); + } +} diff --git a/cockatrice/src/game_graphics/player/menu/command_zone_menu.h b/cockatrice/src/game_graphics/player/menu/command_zone_menu.h new file mode 100644 index 000000000..2f36c6d7a --- /dev/null +++ b/cockatrice/src/game_graphics/player/menu/command_zone_menu.h @@ -0,0 +1,62 @@ +/** + * @file command_zone_menu.h + * @ingroup GameMenusZones + * @brief Context menu for command zone right-click actions. + */ + +#ifndef COCKATRICE_COMMAND_ZONE_MENU_H +#define COCKATRICE_COMMAND_ZONE_MENU_H + +#include "abstract_player_component.h" + +#include + +class PlayerLogic; + +/** + * @class CommandZoneMenu + * @brief Context menu for the command zone. + * + * Appears when right-clicking on the command zone. Provides actions for + * viewing zone contents, adjusting the commander tax counter, and + * toggling minimized state. + * + * @see PlayerMenu + * @see CommandZone + */ +class CommandZoneMenu : public QMenu, public AbstractPlayerComponent +{ + Q_OBJECT + +public: + explicit CommandZoneMenu(PlayerLogic *player, QMenu *playerMenu); + void retranslateUi() override; + void setShortcutsActive() override; + void setShortcutsInactive() override; + + QAction *aViewZone = nullptr; ///< Opens a zone viewer for the command zone + +private: + QAction *aIncreaseCommanderTax = nullptr; ///< Increments the primary commander tax counter + QAction *aDecreaseCommanderTax = nullptr; ///< Decrements the primary commander tax counter + QAction *aToggleCommanderTaxCounter = nullptr; ///< Toggles primary commander tax counter visibility + QAction *aIncreasePartnerTax = nullptr; ///< Increments the partner commander tax counter + QAction *aDecreasePartnerTax = nullptr; ///< Decrements the partner commander tax counter + QAction *aTogglePartnerTaxCounter = nullptr; ///< Toggles partner commander tax counter visibility + QAction *aToggleMinimized = nullptr; ///< Toggles command zone minimized state + +private slots: + void actToggleMinimized(); + +private: + void updateTaxCounterActionStates(); + PlayerLogic *player; + + QString viewZoneShortcutKey; + QString incTaxShortcutKey; + QString decTaxShortcutKey; + QString incPartnerTaxShortcutKey; + QString decPartnerTaxShortcutKey; +}; + +#endif // COCKATRICE_COMMAND_ZONE_MENU_H diff --git a/cockatrice/src/game_graphics/player/menu/move_menu.cpp b/cockatrice/src/game_graphics/player/menu/move_menu.cpp index 5b7209a9f..2c345a81c 100644 --- a/cockatrice/src/game_graphics/player/menu/move_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/move_menu.cpp @@ -20,6 +20,8 @@ MoveMenu::MoveMenu(PlayerGraphicsItem *player) : QMenu(tr("Move to")) aMoveToGraveyard->setData(cmMoveToGraveyard); aMoveToExile = new QAction(this); aMoveToExile->setData(cmMoveToExile); + aMoveToCommandZone = new QAction(this); + aMoveToCommandZone->setData(cmMoveToCommandZone); auto *actions = player->getLogic()->getPlayerActions(); @@ -49,6 +51,8 @@ MoveMenu::MoveMenu(PlayerGraphicsItem *player) : QMenu(tr("Move to")) addAction(aMoveToGraveyard); addSeparator(); addAction(aMoveToExile); + addSeparator(); + addAction(aMoveToCommandZone); setShortcutsActive(); @@ -65,6 +69,7 @@ void MoveMenu::setShortcutsActive() aMoveToHand->setShortcuts(shortcuts.getShortcut("Player/aMoveToHand")); aMoveToGraveyard->setShortcuts(shortcuts.getShortcut("Player/aMoveToGraveyard")); aMoveToExile->setShortcuts(shortcuts.getShortcut("Player/aMoveToExile")); + aMoveToCommandZone->setShortcuts(shortcuts.getShortcut("Player/aMoveToCommandZone")); } void MoveMenu::retranslateUi() @@ -76,4 +81,5 @@ void MoveMenu::retranslateUi() aMoveToHand->setText(tr("&Hand")); aMoveToGraveyard->setText(tr("&Graveyard")); aMoveToExile->setText(tr("&Exile")); + aMoveToCommandZone->setText(tr("&Command Zone")); } diff --git a/cockatrice/src/game_graphics/player/menu/move_menu.h b/cockatrice/src/game_graphics/player/menu/move_menu.h index 150bdbd3c..af9f9b856 100644 --- a/cockatrice/src/game_graphics/player/menu/move_menu.h +++ b/cockatrice/src/game_graphics/player/menu/move_menu.h @@ -26,6 +26,7 @@ public: QAction *aMoveToTable = nullptr; QAction *aMoveToGraveyard = nullptr; QAction *aMoveToExile = nullptr; + QAction *aMoveToCommandZone = nullptr; }; #endif // COCKATRICE_MOVE_MENU_H diff --git a/cockatrice/src/game_graphics/player/menu/player_menu.cpp b/cockatrice/src/game_graphics/player/menu/player_menu.cpp index 17b791222..6fab513b0 100644 --- a/cockatrice/src/game_graphics/player/menu/player_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/player_menu.cpp @@ -5,6 +5,7 @@ #include "../../../game_graphics/zones/table_zone.h" #include "../../../interface/widgets/tabs/tab_game.h" #include "../../board/card_item.h" +#include "../../zones/command_zone.h" #include "../player_graphics_item.h" #include "card_menu.h" #include "hand_menu.h" @@ -31,6 +32,16 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_ if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) { sideboardMenu = addManagedMenu(player, playerMenu); + + commandZoneMenu = addManagedMenu(player, playerMenu); + auto updateCommandZoneMenuVisibility = [this](bool has) { + if (commandZoneMenu) { + commandZoneMenu->menuAction()->setVisible(has); + } + }; + connect(player, &PlayerLogic::commandZoneSupportChanged, this, updateCommandZoneMenuVisibility); + updateCommandZoneMenuVisibility(player->hasServerCommandZone()); + customZonesMenu = addManagedMenu(player); playerMenu->addSeparator(); @@ -39,6 +50,7 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_ utilityMenu = createManagedComponent(player, playerMenu); } else { sideboardMenu = nullptr; + commandZoneMenu = nullptr; customZonesMenu = nullptr; countersMenu = nullptr; utilityMenu = nullptr; @@ -66,6 +78,10 @@ void PlayerMenu::setMenusForGraphicItems() player->getHandZoneGraphicsItem()->setMenu(handMenu); player->getDeckZoneGraphicsItem()->setMenu(libraryMenu, libraryMenu->aDrawCard); player->getSideboardZoneGraphicsItem()->setMenu(sideboardMenu); + + if (auto *commandZone = player->getCommandZoneGraphicsItem()) { + commandZone->setMenu(commandZoneMenu, commandZoneMenu->aViewZone); + } } } diff --git a/cockatrice/src/game_graphics/player/menu/player_menu.h b/cockatrice/src/game_graphics/player/menu/player_menu.h index 62ba66df7..e77401f67 100644 --- a/cockatrice/src/game_graphics/player/menu/player_menu.h +++ b/cockatrice/src/game_graphics/player/menu/player_menu.h @@ -8,6 +8,8 @@ #define COCKATRICE_PLAYER_MENU_H #include "../../../interface/widgets/menus/tearoff_menu.h" +#include "../player_logic.h" +#include "command_zone_menu.h" #include "custom_zone_menu.h" #include "grave_menu.h" #include "hand_menu.h" @@ -88,6 +90,7 @@ private: RfgMenu *rfgMenu; UtilityMenu *utilityMenu; SayMenu *sayMenu; + CommandZoneMenu *commandZoneMenu; CustomZoneMenu *customZonesMenu; /** @brief Drives AbstractPlayerComponent lifecycle delegation. Counters are iterated separately via diff --git a/cockatrice/src/game_graphics/player/player_graphics_item.cpp b/cockatrice/src/game_graphics/player/player_graphics_item.cpp index e0194abda..7d5541c5f 100644 --- a/cockatrice/src/game_graphics/player/player_graphics_item.cpp +++ b/cockatrice/src/game_graphics/player/player_graphics_item.cpp @@ -3,6 +3,7 @@ #include "../../game/player/player_actions.h" #include "../../interface/widgets/tabs/tab_game.h" #include "../board/abstract_card_item.h" +#include "../board/commander_tax_counter.h" #include "../board/counter_general.h" #include "../hand_counter.h" #include "../zones/hand_zone.h" @@ -13,6 +14,10 @@ #include "player_dialogs.h" #include +#include "../z_values.h" +#include "../zones/command_zone.h" + +#include PlayerGraphicsItem::PlayerGraphicsItem(PlayerLogic *_player) : player(_player) { @@ -121,6 +126,12 @@ void PlayerGraphicsItem::initializeZones() new HandZone(player->getHandZone(), static_cast(tableZoneGraphicsItem->boundingRect().height()), this); connect(player->getPlayerActions(), &PlayerActions::requestSortHand, handZoneGraphicsItem, &HandZone::sortHand); + // Command zone + commandZoneGraphicsItem = new CommandZone(player->getCommandZone(), ZoneSizes::COMMAND_ZONE_HEIGHT, this); + commandZoneGraphicsItem->setZValue(ZValues::COMMAND_ZONE); + commandZoneGraphicsItem->setVisible(false); + connect(commandZoneGraphicsItem, &CommandZone::minimizedChanged, this, &PlayerGraphicsItem::rearrangeZones); + connect(handZoneGraphicsItem->getLogic(), &HandZoneLogic::cardCountChanged, handCounter, &HandCounter::updateNumber); connect(handCounter, &HandCounter::showContextMenu, handZoneGraphicsItem, &HandZone::showContextMenu); @@ -187,6 +198,13 @@ void PlayerGraphicsItem::onCounterAdded(CounterState *state) AbstractCounter *widget; if (state->getName() == "life") { widget = playerTarget->addCounter(state); + } else if (CounterNames::isTaxCounter(state->getName())) { + if (!commandZoneGraphicsItem) { + qWarning() << "Cannot create tax counter" << state->getName() << "- command zone not available"; + return; + } + widget = new CommanderTaxCounter(state, player, commandZoneGraphicsItem); + widget->setActive(state->isActive()); } else { widget = new GeneralCounter(state, player, true, this); } @@ -218,9 +236,16 @@ void PlayerGraphicsItem::onCounterRemoved(int counterId) void PlayerGraphicsItem::rearrangeCounters() { + if (commandZoneGraphicsItem) { + commandZoneGraphicsItem->rearrangeTaxCounters(); + } + qreal ySize = boundingRect().y() + 80; constexpr qreal padding = 5; for (auto *ctr : counterWidgets.values()) { + if (CounterNames::isTaxCounter(ctr->getName())) { + continue; + } if (!ctr->getShownInCounterArea()) { continue; } @@ -230,9 +255,33 @@ void PlayerGraphicsItem::rearrangeCounters() } } +QList PlayerGraphicsItem::getTaxCounterWidgets() const +{ + QList result; + for (AbstractCounter *ctr : counterWidgets.values()) { + if (CounterNames::isTaxCounter(ctr->getName())) { + result.append(ctr); + } + } + return result; +} + void PlayerGraphicsItem::rearrangeZones() { auto base = QPointF(CardDimensions::HEIGHT_F + counterAreaWidth + 15, 0); + + // Calculate stack height, accounting for command zone if visible + bool commandZoneVisible = commandZoneGraphicsItem && commandZoneGraphicsItem->isVisible(); + qreal tableHeight = tableZoneGraphicsItem->boundingRect().height(); + qreal stackHeight = tableHeight; + if (commandZoneVisible) { + stackHeight = tableHeight - totalCommandZoneHeight(); + if (stackHeight < CommandZone::MINIMUM_STACKING_HEIGHT) { + stackHeight = CommandZone::MINIMUM_STACKING_HEIGHT; + } + } + stackZoneGraphicsItem->setHeight(stackHeight); + if (SettingsCache::instance().getHorizontalHand()) { if (mirrored) { if (player->getHandZone()->contentsKnown()) { @@ -243,12 +292,12 @@ void PlayerGraphicsItem::rearrangeZones() handVisible = false; } - stackZoneGraphicsItem->setPos(base); + positionCommandAndStackZones(base); base += QPointF(stackZoneGraphicsItem->boundingRect().width(), 0); tableZoneGraphicsItem->setPos(base); } else { - stackZoneGraphicsItem->setPos(base); + positionCommandAndStackZones(base); tableZoneGraphicsItem->setPos(base.x() + stackZoneGraphicsItem->boundingRect().width(), 0); base += QPointF(0, tableZoneGraphicsItem->boundingRect().height()); @@ -268,7 +317,7 @@ void PlayerGraphicsItem::rearrangeZones() handZoneGraphicsItem->setPos(base); base += QPointF(handZoneGraphicsItem->boundingRect().width(), 0); - stackZoneGraphicsItem->setPos(base); + positionCommandAndStackZones(base); base += QPointF(stackZoneGraphicsItem->boundingRect().width(), 0); tableZoneGraphicsItem->setPos(base); @@ -297,3 +346,28 @@ void PlayerGraphicsItem::updateBoundingRect() emit sizeChanged(); } + +qreal PlayerGraphicsItem::totalCommandZoneHeight() const +{ + if (commandZoneGraphicsItem && commandZoneGraphicsItem->isVisible()) { + return commandZoneGraphicsItem->currentHeight(); + } + return 0; +} + +void PlayerGraphicsItem::positionCommandAndStackZones(const QPointF &base) +{ + bool commandZoneVisible = commandZoneGraphicsItem && commandZoneGraphicsItem->isVisible(); + if (commandZoneVisible) { + commandZoneGraphicsItem->setPos(base); + } + stackZoneGraphicsItem->setPos(base.x(), base.y() + (commandZoneVisible ? totalCommandZoneHeight() : 0)); +} + +void PlayerGraphicsItem::setCommandZoneVisible(bool visible) +{ + if (commandZoneGraphicsItem) { + commandZoneGraphicsItem->setVisible(visible); + } + rearrangeZones(); +} diff --git a/cockatrice/src/game_graphics/player/player_graphics_item.h b/cockatrice/src/game_graphics/player/player_graphics_item.h index d02234ded..47c5fafba 100644 --- a/cockatrice/src/game_graphics/player/player_graphics_item.h +++ b/cockatrice/src/game_graphics/player/player_graphics_item.h @@ -12,6 +12,7 @@ #include +class CommandZone; class HandZone; class PileZone; class PlayerDialogs; @@ -112,6 +113,18 @@ public: { return handZoneGraphicsItem; } + /** @brief Returns the command zone graphics item. */ + [[nodiscard]] CommandZone *getCommandZoneGraphicsItem() const + { + return commandZoneGraphicsItem; + } + /** @brief Returns the counter widget for the given counter ID, or nullptr if not found. */ + [[nodiscard]] AbstractCounter *getCounterWidget(int counterId) const + { + return counterWidgets.value(counterId, nullptr); + } + /** @brief Returns all tax counter widgets (commander tax and partner tax). */ + [[nodiscard]] QList getTaxCounterWidgets() const; public slots: void onPlayerActiveChanged(bool _active); @@ -120,6 +133,8 @@ public slots: void onCounterRemoved(int counterId); void rearrangeCounters(); void retranslateUi(); + /** @brief Shows or hides the command zone and rearranges dependent zones. */ + void setCommandZoneVisible(bool visible); signals: void sizeChanged(); @@ -142,10 +157,15 @@ private: TableZone *tableZoneGraphicsItem; StackZone *stackZoneGraphicsItem; HandZone *handZoneGraphicsItem; + CommandZone *commandZoneGraphicsItem; QRectF bRect; bool mirrored; bool handVisible = false; + /** @brief Returns the command zone's display height, or 0 if hidden. */ + [[nodiscard]] qreal totalCommandZoneHeight() const; + /** @brief Positions the command and stack zones vertically starting from base, updating base.y. */ + void positionCommandAndStackZones(const QPointF &base); private slots: void updateBoundingRect(); void rearrangeZones(); diff --git a/cockatrice/src/game_graphics/z_values.h b/cockatrice/src/game_graphics/z_values.h index c6e7f2c8a..7b30054a9 100644 --- a/cockatrice/src/game_graphics/z_values.h +++ b/cockatrice/src/game_graphics/z_values.h @@ -29,11 +29,16 @@ namespace ZValues { +/** @brief Command zone sits at standard zone level */ +constexpr qreal COMMAND_ZONE = 1.0; + // Expose base for callers that need it constexpr qreal OVERLAY_BASE = ZValueLayerManager::OVERLAY_BASE; // Overlay layer Z-values for items that should appear above normal cards constexpr qreal HOVERED_CARD = ZValueLayerManager::overlayZValue(1.0); +/** @brief Commander tax counter overlay */ +constexpr qreal TAX_COUNTERS = ZValueLayerManager::overlayZValue(2.0); constexpr qreal ARROWS = ZValueLayerManager::overlayZValue(3.0); constexpr qreal ZONE_VIEW_WIDGET = ZValueLayerManager::overlayZValue(4.0); constexpr qreal DRAG_ITEM = ZValueLayerManager::overlayZValue(5.0); diff --git a/cockatrice/src/game_graphics/zones/stack_zone.cpp b/cockatrice/src/game_graphics/zones/stack_zone.cpp index 46ff099ab..c3015496c 100644 --- a/cockatrice/src/game_graphics/zones/stack_zone.cpp +++ b/cockatrice/src/game_graphics/zones/stack_zone.cpp @@ -32,6 +32,10 @@ QRectF StackZone::boundingRect() const void StackZone::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) { QBrush brush = themeManager->getExtraBgBrush(ThemeManager::Stack, getLogic()->getPlayer()->getZoneId()); + + QPointF scenePos = mapToScene(QPointF(0, 0)); + painter->setBrushOrigin(-scenePos); + painter->fillRect(boundingRect(), brush); } diff --git a/cockatrice/src/interface/theme_manager.cpp b/cockatrice/src/interface/theme_manager.cpp index 086845fe6..5bd8cee71 100644 --- a/cockatrice/src/interface/theme_manager.cpp +++ b/cockatrice/src/interface/theme_manager.cpp @@ -25,10 +25,12 @@ #define PLAYERZONE_BG_NAME "playerzone" #define STACKZONE_BG_NAME "stackzone" #define TABLEZONE_BG_NAME "tablezone" +#define COMMANDZONE_BG_NAME "commandzone" static const QColor HANDZONE_BG_DEFAULT = QColor(80, 100, 50); static const QColor TABLEZONE_BG_DEFAULT = QColor(70, 50, 100); static const QColor PLAYERZONE_BG_DEFAULT = QColor(200, 200, 200); static const QColor STACKZONE_BG_DEFAULT = QColor(113, 43, 43); +static const QColor COMMANDZONE_BG_DEFAULT = QColor(50, 60, 80); static const QStringList DEFAULT_RESOURCE_PATHS = {":/resources"}; struct PaletteColorInfo @@ -271,6 +273,9 @@ void ThemeManager::applyStyleAndPalette(const QString &themeName, const PaletteConfig &palCfg, const QString &activeScheme) { +#if (QT_VERSION < QT_VERSION_CHECK(6, 5, 0)) + Q_UNUSED(activeScheme) +#endif QString styleName = themeCfg.styleName; if (styleName.isEmpty() || styleName.compare("Default", Qt::CaseInsensitive) == 0) { if (themeName == FUSION_THEME_NAME) { @@ -370,6 +375,8 @@ void ThemeManager::themeChangedSlot() brushes[Role::Player] = loadBrush(PLAYERZONE_BG_NAME, PLAYERZONE_BG_DEFAULT); brushes[Role::Stack] = loadBrush(STACKZONE_BG_NAME, STACKZONE_BG_DEFAULT); + + brushes[Role::Command] = loadBrush(COMMANDZONE_BG_NAME, COMMANDZONE_BG_DEFAULT); for (auto &brushCache : brushesCache) { brushCache.clear(); } @@ -394,6 +401,9 @@ static QString roleBgName(ThemeManager::Role role) case ThemeManager::Table: return TABLEZONE_BG_NAME; + case ThemeManager::Command: + return COMMANDZONE_BG_NAME; + default: Q_ASSERT(false); } diff --git a/cockatrice/src/interface/theme_manager.h b/cockatrice/src/interface/theme_manager.h index b9e764d08..02a728233 100644 --- a/cockatrice/src/interface/theme_manager.h +++ b/cockatrice/src/interface/theme_manager.h @@ -38,7 +38,8 @@ public: Stack, Table, Player, - MaxRole = Player, + Command, + MaxRole = Command, }; private: diff --git a/cockatrice/src/interface/widgets/dialogs/dlg_create_game.cpp b/cockatrice/src/interface/widgets/dialogs/dlg_create_game.cpp index 30364f242..fa96c55ea 100644 --- a/cockatrice/src/interface/widgets/dialogs/dlg_create_game.cpp +++ b/cockatrice/src/interface/widgets/dialogs/dlg_create_game.cpp @@ -102,6 +102,7 @@ void DlgCreateGame::sharedCtor() startingLifeTotalLabel->setBuddy(startingLifeTotalEdit); shareDecklistsOnLoadCheckBox = new QCheckBox(tr("Open decklists in lobby")); + enableCommandZoneCheckBox = new QCheckBox(tr("Enable command zone")); createGameAsJudgeCheckBox = new QCheckBox(tr("Create game as judge")); @@ -109,6 +110,7 @@ void DlgCreateGame::sharedCtor() gameSetupOptionsLayout->addWidget(startingLifeTotalLabel, 0, 0); gameSetupOptionsLayout->addWidget(startingLifeTotalEdit, 0, 1); gameSetupOptionsLayout->addWidget(shareDecklistsOnLoadCheckBox, 1, 0); + gameSetupOptionsLayout->addWidget(enableCommandZoneCheckBox, 1, 1); if (room && room->getUserInfo()->user_level() & ServerInfo_User::IsJudge) { gameSetupOptionsLayout->addWidget(createGameAsJudgeCheckBox, 2, 0); } else { @@ -171,6 +173,7 @@ DlgCreateGame::DlgCreateGame(TabRoom *_room, const QMap &_gameType createGameAsSpectatorCheckBox->setChecked(SettingsCache::instance().getCreateGameAsSpectator()); startingLifeTotalEdit->setValue(SettingsCache::instance().getDefaultStartingLifeTotal()); shareDecklistsOnLoadCheckBox->setChecked(SettingsCache::instance().getShareDecklistsOnLoad()); + enableCommandZoneCheckBox->setChecked(SettingsCache::instance().getEnableCommandZone()); if (!rememberGameSettings->isChecked()) { actReset(); @@ -204,6 +207,7 @@ DlgCreateGame::DlgCreateGame(const ServerInfo_Game &gameInfo, const QMapsetEnabled(false); startingLifeTotalEdit->setEnabled(false); shareDecklistsOnLoadCheckBox->setEnabled(false); + enableCommandZoneCheckBox->setEnabled(false); descriptionEdit->setText(QString::fromStdString(gameInfo.description())); maxPlayersEdit->setValue(gameInfo.max_players()); @@ -250,6 +254,7 @@ void DlgCreateGame::actReset() startingLifeTotalEdit->setValue(20); shareDecklistsOnLoadCheckBox->setChecked(false); + enableCommandZoneCheckBox->setChecked(false); createGameAsJudgeCheckBox->setChecked(false); QMapIterator gameTypeCheckBoxIterator(gameTypeCheckBoxes); @@ -280,6 +285,7 @@ void DlgCreateGame::actOK() cmd.set_join_as_spectator(createGameAsSpectatorCheckBox->isChecked()); cmd.set_starting_life_total(startingLifeTotalEdit->value()); cmd.set_share_decklists_on_load(shareDecklistsOnLoadCheckBox->isChecked()); + cmd.set_enable_command_zone(enableCommandZoneCheckBox->isChecked()); auto _gameTypes = QString(); QMapIterator gameTypeCheckBoxIterator(gameTypeCheckBoxes); @@ -304,6 +310,7 @@ void DlgCreateGame::actOK() SettingsCache::instance().setCreateGameAsSpectator(createGameAsSpectatorCheckBox->isChecked()); SettingsCache::instance().setDefaultStartingLifeTotal(startingLifeTotalEdit->value()); SettingsCache::instance().setShareDecklistsOnLoad(shareDecklistsOnLoadCheckBox->isChecked()); + SettingsCache::instance().setEnableCommandZone(enableCommandZoneCheckBox->isChecked()); SettingsCache::instance().setGameTypes(_gameTypes); } PendingCommand *pend = room->prepareRoomCommand(cmd); diff --git a/cockatrice/src/interface/widgets/dialogs/dlg_create_game.h b/cockatrice/src/interface/widgets/dialogs/dlg_create_game.h index 61925286d..4bb5eeb64 100644 --- a/cockatrice/src/interface/widgets/dialogs/dlg_create_game.h +++ b/cockatrice/src/interface/widgets/dialogs/dlg_create_game.h @@ -48,6 +48,7 @@ private: QCheckBox *spectatorsAllowedCheckBox, *spectatorsNeedPasswordCheckBox, *spectatorsCanTalkCheckBox, *spectatorsSeeEverythingCheckBox, *createGameAsJudgeCheckBox, *createGameAsSpectatorCheckBox; QCheckBox *shareDecklistsOnLoadCheckBox; + QCheckBox *enableCommandZoneCheckBox; QDialogButtonBox *buttonBox; QPushButton *clearButton; QCheckBox *rememberGameSettings; diff --git a/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.cpp b/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.cpp index d2d291556..cbd7383b3 100644 --- a/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.cpp +++ b/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.cpp @@ -33,10 +33,13 @@ DlgLocalGameOptions::DlgLocalGameOptions(QWidget *parent) : QDialog(parent) startingLifeTotalEdit->setValue(20); startingLifeTotalLabel->setBuddy(startingLifeTotalEdit); + enableCommandZoneCheckBox = new QCheckBox(tr("Enable command zone"), this); + auto *gameSetupGrid = new QGridLayout; gameSetupGrid->setContentsMargins(5, 5, 5, 5); gameSetupGrid->addWidget(startingLifeTotalLabel, 0, 0); gameSetupGrid->addWidget(startingLifeTotalEdit, 0, 1); + gameSetupGrid->addWidget(enableCommandZoneCheckBox, 1, 0, 1, 2); gameSetupOptionsGroupBox = new QGroupBox(tr("Game setup options"), this); gameSetupOptionsGroupBox->setLayout(gameSetupGrid); @@ -57,6 +60,7 @@ DlgLocalGameOptions::DlgLocalGameOptions(QWidget *parent) : QDialog(parent) if (rememberSettingsCheckBox->isChecked()) { numberPlayersEdit->setValue(SettingsCache::instance().getLocalGameMaxPlayers()); startingLifeTotalEdit->setValue(SettingsCache::instance().getLocalGameStartingLifeTotal()); + enableCommandZoneCheckBox->setChecked(SettingsCache::instance().getLocalGameEnableCommandZone()); } setWindowTitle(tr("Local game options")); @@ -71,6 +75,7 @@ void DlgLocalGameOptions::actOK() if (rememberSettingsCheckBox->isChecked()) { SettingsCache::instance().setLocalGameMaxPlayers(numberPlayersEdit->value()); SettingsCache::instance().setLocalGameStartingLifeTotal(startingLifeTotalEdit->value()); + SettingsCache::instance().setLocalGameEnableCommandZone(enableCommandZoneCheckBox->isChecked()); } accept(); @@ -81,5 +86,6 @@ LocalGameOptions DlgLocalGameOptions::getOptions() const return LocalGameOptions{ .numberPlayers = numberPlayersEdit->value(), .startingLifeTotal = startingLifeTotalEdit->value(), + .enableCommandZone = enableCommandZoneCheckBox->isChecked(), }; } diff --git a/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.h b/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.h index 4307581a4..d52257ec6 100644 --- a/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.h +++ b/cockatrice/src/interface/widgets/dialogs/dlg_local_game_options.h @@ -16,6 +16,7 @@ struct LocalGameOptions { int numberPlayers = 1; int startingLifeTotal = 20; + bool enableCommandZone = false; }; class QCheckBox; @@ -45,6 +46,7 @@ private: QLabel *startingLifeTotalLabel; QSpinBox *startingLifeTotalEdit; + QCheckBox *enableCommandZoneCheckBox; QCheckBox *rememberSettingsCheckBox; QDialogButtonBox *buttonBox; diff --git a/cockatrice/src/interface/widgets/tabs/tab_game.cpp b/cockatrice/src/interface/widgets/tabs/tab_game.cpp index a81161e83..a6fc3f151 100644 --- a/cockatrice/src/interface/widgets/tabs/tab_game.cpp +++ b/cockatrice/src/interface/widgets/tabs/tab_game.cpp @@ -690,7 +690,7 @@ void TabGame::addLocalPlayer(PlayerLogic *newPlayer, int playerId) auto *deckView = new TabbedDeckViewContainer(playerId, this); connect(deckView->playerDeckView, &DeckViewContainer::newCardAdded, this, &TabGame::newCardAdded); deckViewContainers.insert(playerId, deckView); - deckViewContainerLayout->addWidget(deckView); + deckViewContainerLayout->insertWidget(0, deckView, 1); // auto load deck for player if that debug setting is enabled QString deckPath = SettingsCache::instance().debug().getDeckPathForPlayer(newPlayer->getPlayerInfo()->getName()); diff --git a/cockatrice/src/interface/window_main.cpp b/cockatrice/src/interface/window_main.cpp index 69d3260bc..c4ad79085 100644 --- a/cockatrice/src/interface/window_main.cpp +++ b/cockatrice/src/interface/window_main.cpp @@ -171,6 +171,7 @@ void MainWindow::startLocalGame(const LocalGameOptions &options) Command_CreateGame createCommand; createCommand.set_max_players(static_cast(options.numberPlayers)); createCommand.set_starting_life_total(options.startingLifeTotal); + createCommand.set_enable_command_zone(options.enableCommandZone); mainClient->sendCommand(LocalClient::prepareRoomCommand(createCommand, 0)); } diff --git a/cockatrice/themes/Fabric/zones/commandzone.png b/cockatrice/themes/Fabric/zones/commandzone.png new file mode 100644 index 0000000000000000000000000000000000000000..e71f466e863472dc173e3d8bccf23ef46e7892c2 GIT binary patch literal 225500 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
gf7706tK##5K zlxDQUaAt?hns)^;6qFW_`h*&ke_egkrhedYd}5tQPAF~1ySxzttm5HM+v^Lmau7@v z%(Zv$-rI#Zz$|$xP~qqSe5tbpEm zFmqkRFHRPMp&Z^qHs+L!2OFBPC;@oIKL*!>N=^pe>e@1OaSYp|E@GSRIO+?Z$4|)F zR-c#TB!y=sD6|i_c2)dbQ=08gjU=5!A`a_xM?brfn1;hbon+(A{B(Ns5mp~LKrlkm z2hK`L^2huqlsCWS4|MxGvT~YDHJ>6c!`e>79w9$BKtXRj$D<$$fb)Xy%U`}=TcA_p z>-ApD_-L6(%K7- zKx|x#Uv@0=1kyZYWGZvN-IYHs6U8-?j+o=8v*ZLp>~+JEZYajg zl0HJ3nQHT)8mbKy6I%PU>gIx_8T&l<`>$Uggu1DBtCAfgf49 z&Spm+EEm*ZB$QZ!}9%*T+nh$P3q)q;krBmEZQej}9<~h%Ma_No}OAf)z{wu-icS z4V>0?S*t0=kE@ph2RhL_qOO_O8d7Q+Kj0vxyiJDDN4o@?(-+x!{IE)fhJ+Nakq)}q z3uW~>T?V$pmc@VB$jVjtWWXorslOwh5%2QGl3xCR*e#KIx7P<|Y&NJ(7sV+rywyx6 zHG|*=IDN>EB-lf?>hM9jKBuyeN4GR!H&^`|RgW}9Zjftb&doN|z=M|$W1v*PIt>Md zB@=W}n{vrDw@O@9J1asvocaQ04g7MVff#QaK2Y0XPzNCQ;-@V@wZggt#lli9da=y; z+HYJt7X`fztJ!im0C=8fjJE=5j*tByFI~*VZQ1#qW&w2~kA*0p^d4FIK}AOf}JjP@zz&eg#?9R=%(b1uX$EFRV%|&JJXe zW0dc4)%$Fd)?&x|o)&tW9BbyU30 zhtq!rd%ez2Y|{<0b63?T^>>QHXix8nA|PS0zh7`78vBJA z*Bv=bfGON(>1u5U4PUkSAH_=3e-uS+f&M=O65@Lb2athHSh``E3QlFRs}*iYn?EE}mw9GsU!Swbs>92~X#rk*L6nMLG>S zL5$&UH!T3?fO~zKII>HEXhVC_p5(e3t@xqGph%%K&*4&gbDEpBS;3Iz={j7ki*`bDrY_pSjJ@tzZ)0lY#hbf8= zEen$Q`j>WKuOp+~H-_-!-cWP7u#pPdB%zgrZXC2TET~>C+-j^X{xh*9#QIwF+Z&U4=71tlD+W0l_Ms5^dzzwvqe^v?mn6~#w=U4)Q; zglF=VVn;Be8Iv!V2OYa{&A*}@ilpkU6NR*E=0U3sF1lq76gjp~y}R)PEp{V`Oyhv- z<6tEOCS%Rr2`h3{kXGk)KCw;o72`#xwK99d`ru{-~C)VkX-^bsW(}G{`zcHr`&+_x4@@J+_)HL1gJItTS z`TdYJG%1+}UI1j1F6@*C!&Q?ZPkL4+ZBRU`c;8>~G#DNj>2fy1}FQ*X*wP9JvRFW5Qffgl(!lRATmK!(5vW?axb<@h%U;s*P8V zloU8#(nsBGBgH0i=lFPdv*nucA}Pm=XN> zr)a@KNwmn_>5c~)p674O%>;{maZ7fY5!Q4<1Pun5?U+nV*_ssscKFtyfFUy5+#TL^oNfRC&NrWTZtRj94B%``C1G=C)xeF`FvqSmyx}<`!@&rdI zA#X_=Ugd%B%U?(_;#D3t&{xM2{hbHAylR#Q6|}ExT`9OsLcML8?O^ND;vLZ7*0+t)#;Uz}PdYSorXASa7tb4cE^RhE$ARnMnJ+ z=KE?uLydqK5Nrb_QluL%o3k9K?o_BwLiWQ@_}h_QwmGV?gn%V&{`V;8t4Jo8N_pUn zTv*j`_(8*CXAtaVEWROQ3`kvv7cDWyH9)NZTYZbUZ9|cpqG)-C{rA}~hsb!v%R$y1 zO5$^gNFm~=!_*I$Ah%f=xsiDi9C`{Npd(pO)C3v4iG@}=F9KbD6x_n8_EVdiJG zwmcNO6rX+&=$VMR2>?st1#?uX-!lMWyBZqucRJC)SzFAk#5g#7`-Piq0DisDcxVq> zeO1YPuk6ID@bp%Y;xGxNfhZ4Ob!zOa2F$gLFq|9sH`L!DCl(lwFo0NRpZu#Z&j z=Q!IO1ZXXy_O~;KYCllAa;V4m@2C!6Fl~^Ppx!SUpNlT&4qZG6%{C>wQw}s$C`eOM z+BF&%-W~oQu%-=c^+iTa8}Ga++o7O?v}@`ks6pEBfy3abSD}?it}9~%(uSpN_&oj% zfFi0Z9xQ5R>AUmw<-p3dKh8z@~Ot##TR@~?B#-D(9o$eu$Yq&TBnARIAtM(D!+bIdT$TCj&VIF3% zz9zIDih1YNRuNjX*$S;UimjvO4AF+#M@ZCwOjT(Uem}sZ#onqz^8Z|WOm6Hz7~N1X z;z4bVRM{yS#929$ySP|;w`m;*2im)JE5mwd_2U}f*Yh5)(i77Mwfu7LV49voVUv1B^f^z$&B*k&y`~Ks{FKcuhuFM zd9V}1mKh*#f6i4*C2KfgxUw?QP3`4;jKqHd#GR{H(&)H{^H z5#v|8imw}=YiM*Xgxkdb*Plr!MP}1)q%dQf$o3+2J6lyqXJAreCv5qSqb75W%~k;~ zkmt`W|A09A(k&rrqlQbTWiH5O5ihej6-S&=WoOK&s3Ng}glk@G?A}CYew|M!4wujZ zuvs=pvRRg9d2?D&+TnA`VbR|GayV=8Zb+2zfbKIb?(ZG7C4=z<)nuzQ-yScl5VJWI zgSZLVDO^j>NQ95t3Oiw=k84H)8zSql9DCGQU%_T+VMenIo*@PlijgnqLA35=@&lK! z*^DLK5d(EjXDztp?_Y9=SS(8ApWOBMmcQeuqQhQnRHhF@A%cGv;J|(Uj(${}HscgD zyG|N%Yc@R48Fh+t`hW-pgvIHgT)D7-@9=szL8r|-)QJJX7_viGQ#-y0aRHvs z>V#T{%}a(L5isM-I_TEp+=YE6vv$f>NU&066)4<%P8(Vv7JIjd#b59LFh`<)dIg^_ zTl+>W$XQP0P`oPO4;)HY3J5PQk%ql>yAXr{<|t~fbOv&XeB-Rq#bIZC*)Ph?ET_rZ zDstz)t3TI*i8TOt`vm}Wyvq|g&N%wpFVKVuvT}})EA4^B;51P#gI^Eh;?V}y1J~g# z;hcW=6v^h&u>Y(&SR-dq7mJKJks{0vL<;*s4&cV-;7#+GcY9h_M}@q^jWTAOygA^{ zqysaS2E4VfMmXQ9fAubiWCieY^<>!hFfvP92aLJQPfCg9{@W* zi$DLzK@nqV2VUhj-(`K{sEfDys^W>q5658%?HI%Qi+YxPx5K-5XqnzyYcQLMCvqTM zqKihWKhUnU%1cTOsn!?9iQ|et1)IcoNkS1z?wJUD+3j>(2+%m-oa7d z2sK(IJmGcz^0`3l5dbfoB@LSDUXxYK8gPS9Y!$53ypYfgM2Lmfli*>l@94!_j+v_K!^&o7ccV7JSwaz>o%`sUV%H$D-YJ6h0_n$8Boeta$3pfy0 zp)4opS2_K%)c?!0@U(!u6tWGcXWZv+CeV}qNqDB1 z7$ag$PSKZR!)^NRmp|hM7DDHJ^1qYgOnO8ZY*lHhq=$25d7SZi{D+B^jUiMiWW380 z-PY~n!0`YVz0hg4jT@?9aP3vmGr)=qMw?Fg5TnxWXkFEmg(`I| z(uNWa|E%LPE4$l0ba5TtO9(X^O*V#rB~TTsg`>Y$`w7J1W-BVSm=Dc9PwC1bsAjpa z;e9^68U+|hoIuR8*!KzuC~1MRo2AvLeW=|@Da{Z)HOB?-^2U~vSI-)BB3acElWjDb z_)Qq<`>XXltHy6&u8SE^rpYdfjCkt8B*de`1dtJ)ph?a)hC}J>&rD{K>vTt|lQFE6 z;BX~N=qo_@KFJPb9kHv+WH-sqqo1aH=A|nE**1MZB2Vt0J`Nzmy*dz%$$#$#rkGA-1X4pI&F3FSq9u4jD! zdBaf;d*+i5z}ev_N}GsA3G&)wxArb?Y}0|yJevC3SF~@nxoh@wBT0tc1;Uo6);2g z7y-#FkWZvOxcAaIu#zEm+Rgt+mDSY?$(@74V1V)ad`$}*2M@c9IZa=Jp)}K>Hx^KO z#mEIn22UM6lh8${MRfpPIf)^mP5wS#Z23)(LHwADdd6bueyseZr5RQg!?J>hXou_} zG~1!-e>Mmt*#SNIVA+R}ad<+B@(r*`S2gH~akklH2VMJlVRcocoN47@N?&Ey%RyLz zNX>wBNvpadoW{@Xhiq$?%9!i=O6#sZXQK_zZu*55X!1!m%nhN!^G;$mXs-|Ja&=Rr zn|3dj#7ugXpZJ*nMC<%r&w8SyH!0)RnMvU*zo@ewIO2Z6zV&RYJv%aDj=CfEfRK`X z@1eQSl9k<$sK+_-UCpM~(VpcYe?XQtIjoqI@+EN5aYb7%1=T8a&&aU#8ZQw9f|==p zTdXsJODtkYejt~Am|vQz=7O9@!6HvDUY>7zCf%UDkt;sJ+t{%PMyI8DFj)G;JTH8& zkw&P%U?~dn9W15O^*8hv2HhAZ{CTvDknM+P$lOq#pB$r!&XNxnf$j?5005QGkCj|=_)RVKpdiP~ z2CdGpIz3C90x?})x+uu;FOWD*n`&q_qT#oLWh5+H7Aos>L+Qp!s`mWsP#U_9YgU7_ zJOLRqUiA}aEqIrgTWz4(fgK`B-Tn8~+NgGbPL;#o(*m|)0FD}b-lgYpSYIK-LxulH z^hI9%%MQzzd1rBU!2#}WHu!^XoJu<`Lhk z{Kh1JqmzNs1ugGA0kXBY=BNYebEr@74*c?^|GnFQS^;jr5Nxt5s5mNI7}&aXl|9oF zD@1hbhGOOKcG`2`%x@%1%9&u06S7^Ta(GDg_qk>YXV}QDu0D}%&ZGj3h0*4nM(qXN zW(IVn4gR~#)&cjbb;1r{h>lO!-mH1`*@}kN`bsv`)_MRWdLG58vRfo#REElg$)Q|x%jDE&x#=$iJTf2u9mZ#0!4nrA|ncb$#Gm5Ua=_q)g z#k+Y$bi-y_9h#+a?)W-Cja)I@Bs7DHWJ>Tr88;)-t+srF+;NLRKEmPYGD>Jb0VKjj zTR%{2VG0)OzMvx{W}DNB9UU`P)0W8UJtNwGw$>4%*dU`ikicjRlJrwXUT-(UIt?F1 zr@WdW1`wiC2n=7`;D&2Z>@K3HmjiiRJPukkJ}1#JQ|R6%ij|^6NH0moi9B3RukZNp z)1{a23}GUzvpv=Dg~4G*&G?4fm8O%N92zem?nb~}>|=thDf2YC{u zolwp+2cpH_0oC?9O1s9+4k|DJTTjud)fu_N*h}-510Di3h z#hFl;@iG626cYaG{}(p1$Zi%Juuhv_G8*zrc^_lM42uqpss?3i1MiBZjS?MsP8&Oz zY4iM&CEf8hc9^K+>dcS&!jkR~G)5PM;LkaSjG9PM-=;ehhQ`3D!N39Fm$EJ}5m-i! zN`;(TDOj6*9dty@NemyFW)9ya(ZmzF<*X!(&Xa4J!ozifobApG+>!geW$4TVnmAc1$&*J+&^~l()4oZEIJPF3I(M#w*lGxpw`diel~aw z8H^x4ZEiSO#}YvT*I;m_Fwut!4`;;zvWVh79-YS+n$zdZ;Nn2F??iJSxvB zI!jv+mFZ$=F#52wq(S0mT_RlDGlI==b$0VTv+G~d4LLCWKvq8idjA9Nj4`nTVe57G zUv3JlG9*IMX6LZ4IlWI_JZ`upqcX#Fi4Q)ZL8GSm6b?Zr_!r>T{pLW0z?QQ<_;RgShGqnuRD!Yel*m`Lt!pVO+Oi3iy>eX}9k zH^|3`w7YKb!BEC(rZu_lXEsXiaoM2RH?HIAK^7>{H>t8>B!)~eS;a^=CC6crJ-Q9S zT=w6sD{QTzw6|4M#cAV&il#yL)aR+XK!~H0j?w5yxj&$L2jU>#+itp=RkO!BH z8#Nzv4G@IwYmdVYxH!&(%U5m1bq9i)Pm7d2>rUl($hdkl1q8?&i~oD*v_`l8RdDLi zV@ST&MAq<*J@NPGwk~;wT+Cei>6d*DGv`Ms+F3%!3PNEsUgd$9EtX-r+nTzQ1$OWf zFJb6I1j(m7`I*FL744GEW9V;(eXrg16?FQr>=;vr3*8|Uw_wd1a#;P+MuM^F#N29^ z0&DW07Z89D{F&(77pf9NG=hTB&P`mKFht%l(zr6-rtfH-`2`>I4`0lj!2g95Gw$;b z1VmaBmj||dhgbjr@G<`YX_Fs*Ot5vkdHDLAR$rhaj0MasxIieaH)PYK=;j9o6;uaD zj1i$nUv#ZkM7#CHw$Tlx15k=pK%QR_DUS3-*3hR$T3@OHO$jUmOOyTnzZmOCL&aX2N7AF9e8X zscehvFd)Co3d!aPLMCceC{(`)Uim&Gq76Ox_jVXJMwI&UBBrCG)}aJfaVw;NbE$$8 z17b{p`V*7~L`T*+AiDi^555hO)`j&tpUwo_>jSA1t_~n%nCb+1+x@xymksX&I*##~ z4E+&Wu%yjDGiRh`BNJvIG$>kEpKk=6vAB}`lY9jEE+)UMQmi&l<};Hx{HQN%xM9tl zaXpR%&c-Wl(+@+Y1lTt#V7~JVeV)Heh_&K%CcANX`|(2*Kj7tU#b1uYx5EOLVod0D zSd*;N9nbO`8t`aCv?ePHV@tLD3q}`XM12<%07iTs|ABbhY{fHP<$)X*yv|SD=kK-| z9~ZUt$SiNYUps6cK&>XwAu+jN*U^f6*zTDoln`sx~*VaoKFtPSZI+ zUQ)bVS|15^93~H&dcF%igA7!@U#VM6u|glFn<9?@R$RpdfH2&WlK%|76B+c;LVfZJMOCG!(PusV@&Zny zxS#fnBl2afR2zW5&jqvMb2U758rRK z4Er28dy$zayB9*DG}FXos2%+IbADrIi?KKXgVo~V@0gcfFb}Kfdq!(b=Y%S5JS0JMODUQ8QxLJm}g{>AmfZU7Ck?p?LAGZmac<)BLnlz%r&bqO^ur`E6{e zx1X^e_<`1Ct3!Xdy*?c+N_n#P5K%0`Lslwcp|Y^p@Geih&QH9`FGyb^3!9FLS9x*< zA~(!xZBmXIukz`e{#BmdE-SYe0N&+cACAz{%@;C22Yj%Q*g-5p*E6L>9Dm{r9Y>|7494g2g4_o{1yD~Yk@R~?bCtDhV&JFGXp@xxQsM# z=3-=|q~<4Mo`K8ejqVUj&ws)mXoJnAg;MOf3%Za+3iATYZrrikiW212RQ!`lMILQH zDLCpnXSmusC?mQCb$4S>C}s)u5$yEX#T-x#a_vNf)lyMCo<|G;b0Bwqvdg&J)*zOh zFO~{J4PM%TWG0=#l+&zq?ep0%l4g>JA3hVt*Y%wV*H+YkvYqvw#0ukZR~<~ol$y;e zHe(;Hrngxkd-ll;`P5<8V3)7){#)a7k1-lSLhoWI6SSitxIEc`h|Gb6Tt+x+$a1UXrw1cV0qL@=*oy> zT8OXCkW_bB+lkxs9i)d3wqk4D*pocST8AMSj3VZxWT8;KB2@F1GRS&l_*@||307G* z6MYyF59+$r;ST7G#l}&0T)v&dzARwrY(Y_CGJ5m@+P53@8#J>Cs7^blyFfOV0m4)& z3WpqEn?CR=)Y^r#poC!WICGDiz*)Y2*SVs^g~KXd#id=C82ResB8PW9+PAu3b#}s@ zAG)#rY-S!1m`IqzVp!m6i*E#s0B|u?v_bBbi6g7)(&+9usH(x*@u3DSy@0vFH~Ziw z3Np2_AdcDmep0&GfGhwF&SKiK%`$?9!if>AG2y848nW4fE~hvs$HSO##7T-OEN(kh zo2x%S4In#$Uv50?xM;XwXQME4lgS=q%Xhr&ok|~aO>L7Mg8rFi9J)|rNE)Xh*rqcF z23sZxqQ8bTx&cByGv;Kjqj9vs5*+H^=LY+VXKP~#-cUtb zP6rDVMkQEYzpv&&U&WBs2`b!Yhv}0B>k`me27{U57Z7zclXVW}zh_i*381xpMNfa7 zpRR6am{qYE=8o2Z9FtuZ`u_bPJY+qnN+2u&IDq;%bFCrA!mpZ#r&R=-$ z)DFl5k_`bbnt0UrMecu?n5sHwUe&M`>1@?lX*597uv&*lvle$Z_LFFnK*Qtsg_>6= zUxHyQzaVR5RRpEKo$LK9KM}wo*^C((^dF+n{lKE%<@E*nsJ#NInF{?de)jI4Q&5Hk zNHtWX&PAf2BSpCKvXS@dJNFXxr zq*cXkLwMTx3*PBC5IcwI6rFtVq2krDWA+Y&>tf6@NHiEj zRQ;JYtyogKy(`+B6Y`UOL8hVV_)0sG4t|H-vw-{M|J)ZUX8by_s;1#;gs+Y-q@W zQ&-c`A=hqoKiy;t+LzSXL^CKI>qB}X&HPApo-rr5eZJ`8T5E&6R3X#E7?OGAZD0`B zW^+Sbe8X87Fh8)W=l4bm+2(PV`gbAy z9{<68{$?u4-E+%jD-c5*b_D&vyF4Jv2o8)Yf>jw`hpvK8M3p>kvu5v3#86_+Lm!7+ zul};=XR|;KrrM-O9UN(K-vwK~&QC1q<`0MB9@0@&*&n7y&>(SOnnU2_g0dJ<+lt9( zp|T?2A>ZuMql!C)j58f>mC!LTQu4}2N*eL&8P)jQHPB+D_KL^x)1EVYVN#UEO8!;e zcCf7&G+kDqavJqa`&ORtlmN8Y=MLwm=OcJoETC>8>T zxy_seVjOf(RZsx@y#rriimx`*ic;lJk_SOEthN~y6M!9PisrnUUNV|gm+EPR2(x|Y zHuP-;K(#L7ZSOi@KOgu=f7(yrtRP2HStWE`(w%0A2V8i$=9^tW>?TaRn9cM^*mR}g|2XynLVp-jEgG>NhUrqd2{nBZ6dC?b4^N!Qmb?z8UG1E?b@jibzOtnsTuj2GQm|fj4*9B9WuubGSpY?4lD=OBv>4wt(^wv;A z{4L)RLm*6N^tYbs#m6YP+v&)-nB4tR6hkUdh6MxFxQA;<}0+}wjgpPwg0T`?IZ)?%6=Hyp{Gkq zs(e;{Pk%;oeK_mEFfF?Xq~6yh%C*s;Y!oq~mcBt&-7JD;XP$*J0;_suwahiLqE|pU z<(e^(LVS2aPFQ-;|bF>2x zO}Y;wzuFJe^#H7(CZ`v2)-^N2w$tWbRbYzT_$LTaGQpAzliIlc)@ifLam9(l4z1ZM zIKE%ef`^;1Vs}&c;gnf}7>Zna_1 zTndOi7=a{t&iNox?3ZeC*zbr4Q(N_!lWZzdcsqMWm(fvo9N4j;d-ov5RqHImN*_sq zSNDl(9lvT0gaH3#n=uEXFM;QLtLtE1a-C*(mS0Cw`4S$guK zJ&R<DQ9O&pJ@W>Z^^ADswaKjIu<;iqlws-Mayap?N-%)X=SC9rWgt`^V<4 zT%Rf|s(aS)duWa~+zN!2Xzr%7%!GVge|CYlUhyh~R$CyG@bmZ&*_CaaDYXUf4#k2! zs?mIHHo|$)f+-1Z=2;-p$&@BUMnqD*%soKoQreaSFN<@9ZJ26Q%i0HxPfosE43=XZ zlJS%m4_65@H;jid6mQ(N_7T2+JFQ ze-j%F!?ON9e?uzSTg29yi*u4$fa|M-18dyA%xh|EMx~QKl}zpk^&rZNNTD=bDBE<0 zFimDw~XFj;u1vSdZdS;la7 zmi^AVy_^-)46>8Mt0>sRsIPm+qt0EhZfg}t8orNEEQ&D|B*d;&Us7WaiZpF`1b--v zQ(|4Mb$#iA(tGyO#eiEZYdUv**4smO%)PNcBgMezc_StgAVhcJ(s zAr_?@=&+!IO4%hm?+6Lbef5q}dqDF7fDpL4WL{W<5l79^HJ1jcg_nxf0_=PQE~c7R zFdy}eZ}VU1kx~P}%JR07uveY0oC4D2+4Ha;NuQ*ri-0iJRtyR2bORlQ`R7xbF!vSj z))CN<9bV<{7lnP&PJ#UFS9@?{bPj3v`tSv!FNsw|k97>y4pwjXBWY{CfLfPl8RUq& zU+kw-o!tLNK~59}!fAci?nM2`uCmN^@E+Tov2%fLm?dYZ6i zwV`TrYv^ogd#`ig@<)9l88(SL3&_1htX)(0HJ!)DNX0|GF?hzbi_)g7rFk*}0gy<}Wu0Hm>s#i4ia>4pYZ zrkL<92iAPIfw+dI6$vAWQMnPaw&#Wn{%4{^s~D;6lhtYp=1@E!#i5_6fKv5L9I8P- zH)w%!-fR0Xx;kMI&FdJD74UidjT91o?*9#G7Wla~f2ZzQW$%Z@6q!wOchEXwFx3si z^pR200(EknvDZ&4TvP-QUdoZ1Tx?0^RJ@S7tbc-G@ciF7%qVyxV@3FymW>>Vtr`W!%PC5bIJ z%e<#njPt6wDHfasO^!2Gn*;J7o*kanUY0mg!|7{BtY^vsh*bAl3lMDfX&t9rn1}0x zQbGAlCQH-QoU)7r_EY8Q*ojjOX}03 z5q}>EkK-54G$0XTdXqAM{g&aP8DEc@)osHmrRp>s9QuR(q0RFwtdLV=Z z8Nva)uxK1&LLSSdSo3{geG!fg12BdL1D=F^=P)BA(d*y`R!PM+cf^*zp_=_UXE+OL zP{sgk$i~gSq~UXw3h}#Glt%Rzi)GhN0+6z=h}>| z4R={?AUk4O!CC1Ubgi5;C);cDs#mNcl;J`!rv(!-YApuMRNq|h^75aTOa$h_PZPF= zn7xx={s}3gG!dmA)HZ!M<4*60RA^Op4WfD;Rm2SzCZ{oA2qPGl-D%lgd&RT-vUN9E zZUzk?&FvKL^JT?IwRbxx(6rwtA)(^*!-tT}>7BSpEbJP_z)~00_!{A7ydWlf|EKS1 zQKHpth>XB>RSe>!fGviI+^rkJ;cJ(lpD>@CFT|)r0%|P|!wG44+Xb#cJ{g8^2!~a? zBm*Q+%wdK6;ii<$!e&79{JRCHOxrx_0a@dmI9!V*>zk|dG~cPxOY7yr?GE<<(W%8P z$n!4a9*Lmn>>W-Evvt@O#hP!3K`bsyg)^@(X>w#2KHx)miyTcUFT#YXKv{u^S1;qe*18cJhHGg0(vet> zxxqW){Ev6pyi%vQaze4NCtd>Gx*9n~(-$np%~*Uqs94?GaM%ni$?GrJ@&|@JJTd(g z+vVaVU3b3hpW06JTD?-9(`w0x-2{sZlxeco4IlHL$bJa23lf!H$%-CQX3&H5R!2?# z?6%C5K4InB({!z7o_J0PwR6w&GUv0}CLI5 z{Ks7P)(^NcUsM%#vbMCN_28J` zYLHYgEVh~>>^6PieLmc~sKX*-(}rN2W(3)zkg-!b<5tPw+8nE;8hOIeUUs-y>RA{E zem9IchZ&Fl(;>0(0@>z9%fO}+tK2Qg;Z_Hgta~EWwL-u_Hpt=1mKsTH!7ig@B2MlZ z4afLiEj{TxeKDujIs|?97o+U{k1GX?Ek)yY|I~-n2qzRliLiDD^ao z^ll2;4Egf_u#An)u&aKew1U09$G|fU*y*Ude-F}lZN@g*944(vdr!;om0wC9JT5%2S9E1i3p zYeM$$&AO4@)@eh)?6g%tLRdjn$rS3NNK|LR8EP`Ev?e?D_s5iP)q?AV(%1oZ#=n17HJ)=sR`-Qdy*@uWj^n8*A| zE&zTRT48s~-^^~`-e^c9_waztR6Lr$4gFJI*kZ)1{Bjr4+6;dW*@ad+Ud}RrEx<8I zp`P;lAtwGaCh)18`B=V5&;UQ=p-X66Hwi zeEUHd`w+g>ema}1wT`_$eWOsxJYqxjl?~(Mkd{@?X*!77amg-t`(Sm2(h&K*w7B(E z`xRgBrhOSLB!~1H4)ZEX=IK=|Kb{4exaHhrvO>{6k3nXT9Q;j~A-^nba1Bd!fu@+T z#SdS&e6-yX`6?7LCLglN+;TajK5a0)Vap#J4w|4-j5Td~b(GoMk_j7a1__qpS(U)4*cE^H&llW&*2BHuD9{VYo$ehu zW=v@X(2%eIK7hW)8s8w5yYyCosP`3<6`ATzA5_3c=!6b3#C~f{uDWv%R-9ch&=u=4}e^;oxbrN&J#NfSHo@ zEq@@#6(92-90-Py2qsFLhTD@xw`$0#Dp5|VZfg-0r#YM>rMj+WRG4B$G>o6D02$%& zrSZbqY$#`(>MY%aDv23O`asKYTBpQaa&?t@bmUyj=r+&b?1WhbG2l|caIsElb!ws@ zHZgNVXFlr*SX`#Qcz7G@yUAd%;$6({By^N=_(3F#4F&How`6$PF#gw=K<+XO2#aM_ zOLbbN+akmfC)!#=GRuwYV4OA~Ct!Sgqzno6=nRm!9umCL0_21`I$4RFs=Xhz&k-3i z<^(V*ITL3|B5zqdwWfZ}|hVNtfP9mKp~R z+bC6RkCzIP8*R zAwp+bx=*mXOy2EWQ%(PgsdFDR)KHLPLTwF;d1(nU(YfO9)irCw?N>w$b=+D99o-9@ z?gwk~b4lH>0^ioFk#$&j4V?<<=G}_tY%_@*S9VO& zq!<*)f&Yn&*=8UCBD(;bKhRv0qF2uT3Q}YjHYJimI_TaVkVdwTJ-^+^I3vX};Rrhp zW8vvMlEguszAjRr)5=5-bKFQBwKeqAM%B|hdNgCY&;XnlO~k0S#(_lzwyMz>X|b)B zHYWZRIkW9bkskb|4~yy^BRWLw<b+QV6R1iGenhVVI?-O&Zm@e$cYb7K_ zvL~g5iB+3z{$X=4gqwWc#K(oE)}$8rC5Zm*deSE=_6IzVU)nxXJxm{ z91Y&;;=bnJVr!xTd2lyVAL` zLry&-VA#W)7}n_WPm-H8*FjC+P8|ika`2pGi6Q8@`)xb);8PtSWKZga9(B+J(gzs9v9Ny6js4G$BpIlT(S~`#^+&)EtADYn01cIa$3Y7e9Sr(sWP1#2aSfeM6OE~JU|TyZw)MSG zhh2(3bBqC{3MY+TB}=Gt))Qx-=uuFYsuQ)tKtpM}bse%wV3i;`Z^aOKjf;x6`D}y* z4QgkskVSd0%_>+!))sum0dr(jZ;mq#To_zoLJrD$H&r-PmBkCwEqTXcZ_X=l9?l1{ z*95#|2mP_xyPP3UDVSQ8RbKMQSc$ke1L4J9L$xk2K+&d%gezMZgK>2o${wg~SZ>4^ zu%s0o@N_@IqEw)_UU8c~Ac}15Ck|L;b&7htm?)N)(C6{XsR!I*~>FB};5Cg_C`*goVnWj+~r(N2|y)Arji-jsa_ z*@Ch1aIBtiXUY2<(cEGU z)`_S>jx!Kp#*T6wCapiE32>)jK2t$o?A{br-Jqys((iXK#`pTd>wNkJcok|c>5g|H zg7ZEfyjZ5>=av{|>`EHs3?K%nv|O4Cb8bb*azaDG(-){gu9n*dszk!)-lmjnFct+DWw!2$SIGQN13PP$rhe;Ot1=z4NCeM@C!Nb5E z5(IAfJ7oH%%WO_7VviRHG=BO0NxkHO{%#yBuF}`<<8Lr=E_>x4 zV?Zl5i|E9_Ws8zP>h_#xtI7ki1w_g2MGPgfW&VJ)J+UU7cze!--dt@J2X3O|35h4V2(NQ6yb)q6`UNNN!rOn>$4T!Nr5OK1&YuNe= z$sBy+gehruOqiQCEnnS5cpmQ#35pdKV??qf*BAq0Z71gW2S{fuUmPfPc)94MQN5YX z7FfBt3B+=hpTWwiK$vHh4LJ|1 z5UWE%IjCY-?C(@e5JZ)Y6d+-wHp#_E%`>eBe_u`l(klQ=jRdH<*`^PC%zv2W0cT0< zd^W$}#o|zo$dYadcwGj^YPuYsTALees=E^{Hpdyy^S5^spZ(vss`y#;XRkJM zP>P>uxY?h@QQyc`eFGG~Zl;;I&$J;~%voBL$6|%XmcN^(ft`suf^74)cOqL5Y^!hg|2tnr|jF zob0g6IB`0wPzRz!UdhzQf_zmy4_(yV4=q87>IenBO6(|VwdSE@ZNA*0Sc>aYL*}@8 zH!`OMEo&w@LEx0$;g-MQRernKq$*v6fX$#6X*Z@i*`>5x{ybo6?1EK1tkY(l=ITYG zJhdc@P2J|Q7?8P~w+~329~{EE+QtCDoTOZTL*8T|*?CzNqGd|-PPgw@`9$p-u3y|o zix-MA*c|lu45VPN)Dt-@NO8m<@cWZbG-+9(Xs8~I9HY63 zP!6I-6s95qdwp^?{3=gu)5m}t>^7a!Vhg4EEvfK%9t_0~2t9bJaLs0+j~Rh@$*Q_o zSxoNatJmr`Vu1g>6j=$7-pU*D0F4sMrRz}#rNMCwKxoOTBV`zz5Weaik!@LQTtMhDi^QeE?NGkD7)*-mh%tI=twkgrwmzpIDPU+?7tm~Te*F*D5DpeK&Zq1P<)LMPeEd2zBhSA@%iVAK}RUpxx z^@am4?=F-}|9SjG4ik2xQVTzRpG;3{f$!#ZemWI=w<`I%X(U$jp=ql)!OiqKKbasn z1Lr~bahpC++K$KZi|}Y#@G8Gu!yxw7lx9!r{Q3UhgB@t}=GXa&AM1Y^BW(48fcxNb zIG8=ZGRA>XJn7l#cVY*W#(KS2@~qQl%)emk!t6rAVSBAXgJQ9IG>FxDQpKJE=QV4) z18rn?D2b4tk=+b!XLkSGwVY7qyI?1N&p}+7!YF7I4N%NXR2KRvOn8-FP&}^$Yp0#KZ(4f4UHb8kBzEWB!59`SCo^DHq(1DO_`8|4N-M~5LXXkeVAR%_{gZbG@XO_D zl`?tY+U#9T?ZsljwJt_?QCh*P{Bq`Kud-eV$QBWBWrrU1uuLZN3k${Oc?l^Th`0RB zZfSC%c>^tu)$zrX5u}A8-GXi~*%sHf6FOK@2#1ikELc$#=fZ|Te1qN#kV1q>XN!~-X z5iYqVda;ADc~H{;J=^fFxe8dDQ&|xy4hp825Uq8bUF~BX)afqRjK6CQVvdo0#Huj( zr7ri*)*H5o>gLwEE1ye0h;_QZJShXt00961Nkl@x&$eJDYl|74}-uQ7Zk9nlg&L3TscgeJ|zIx6uS=2q2yK| zrXS}PG#rc}A;*l*`qSYe%~VF=HQ-*(P_lJf>_ViO5zCQ<&Wf7ZUFz`EzFpGI;Hc_@ zXpv%K1P(N-cJm-xgye;tJnI19tQ9pCBV2R@Y$!ILSwO3jYV*m~x(~_aNX+LuIm$rh z(dkvNI%D_TizByQHY0+uc@`-Op+GcrrRohP*l-+|(W7!q^!~DY;RWjyc!qi57cI^k z9ZErL{nWwX?+$>kJ9ksS5MrtJ1g^az_a{x$d|H;x6jZd_G1AaaP{XS zQKXyTa>Y8)*G&!yTKDcC5i^7PtRqP=qh`fC4|;r@(u5`5uq5KgCpaiw^UdQGDSjb^ z_kGgw_51oSh(;@S#$v38Eq`F`gpS_l13%V(`Jx3Hw*1|&_6UjQI5)Xro$e+IDrlh_ z_Qn@5o1-g-&jUNY>ZL%ix2AA$zc!~EoS*5k!4F475touMcAo{>F^x;`_)E%ij z0W`#}&(F>Jb&g?|Z@`y1K#U2g)2>DeY_Z~6S{;@e{|=u`{1QdVjsJc9%N(BRlCY!? z&}N@+@dUlAa$NCB59FAQ(i(jTJ#5~`<*%;pupqVC7-U2z-Vd~P7*w_z-MKjvOoRiE z*A481NxQVHh( zXPFlv)|v5ZWQu5>IRdg+AjFsu`VcZ|CSyn4b@+sdG#wr^jS}bRoI#yrut2Y{c!x4%$k3* zN;s)&A?(q-(h;VqO?T8c=99R%swUDn?>Ose^NEXPN~h3?^k#Yw{gc)#oRJI`E>dM{ zs~s2XNCWASpKWH6V6~^gH9vdvpCY!FsGnC~99HLVzXbOBiK#L(Lltsq?8F$hbhr*f ztRRVvXte<#G_RDj+2s1Efw`*8W7@H1(zMC^At6G+Q*ubHM$c5Sae!VuoOz7dS#1Z3 zb)PWUgbHB(iWCrk68bR&RUe~k361bz z8NC11RK3>8L>K`84(H~$qTtP{KhXLIFyAMG@>Cs))ulh9KT&l{iu*hv^x;jW=xJsA zh@z{5lJ86hB0CEX(w8rMe-4T_JA~ME#3(n1gdA398ro{VbkxnTe;e+ic;P|g%8D2Y znu+4*nk)BbxfL{LDYe!RCYy~SdncYM=RbN+XFagx4v*Arw5_?Oh>}0ijG@Rbq_;t6 zfxRa&K%H&XN8!q6!j3OTKFc-V(anxU4gq3*u>&1e>7vYEz3|xabH>cG`C)Uz$vd#& zd`?7Vo4@(l?Uqswahf@$7oNc{3?Vj}DN>=XBvvs*X$m@}8E4`iTm-Ljtf9;gR(j~T z97@NR+qYN>+0p2ia@Nyu$cEB)>}EDt`&SPdGDfbJ7^l%;IXIMBT3$ff%mECTA~#%O zI$%nQm*rv1cC7gTQ2FKxzSl23nF$<+>|}^YThXk_QhPoD-o8prnxcm3^5}0+mO;gC zolZixp||ETdht5ga~N@?;_9FEP1oZ(x(BK39g~gZVQXF$(x|A0O~-|fZ7@Ldc79Yz ze7`5Q32sM{X zy!i#bn7GA&CYFKaNk}+wRIV+V4ZhA#n^_3Qt}v1srO4O8%3N#Jbj;ob9adp+h-oH| z<~c?o=V{L|q2O>GjAAKuh!RF?Mz;$Pc1p(24Qu}NYEtHzOSBnyOx zgqa{(huVTj4;&6EFbPSJPPXAv8GP=t# z$W|_l3K8J&^*?gaBeJbe4!BvsofW_YcM2vA{IXkG^@3B~(q3QKWH#ytEh}&;;YT&C zqNEENPdW^T+rqVI5bIN4B9ml;KvNyFBWZE8=0rB(XR)xQK5R{#1!XWd?a?QQ#y=$r zK;K0dF87<5Td=O4N^gU@lX>+4koyCpf$j5~IUr*~2b#&R7{mJU7B`Y0mz=fDgoXdEi|hc%DBUQ{^vK(VFnF z2@(80KOJ5qC2lLUA#zV^X)&Ui?IjpFmLaZtPNCyAd6NBt61Y?om zRb2V5N<7&E11lENs(eSJR;mG&J^(6&Z$iDNIo+_@ zOir#8iiRLtErL$e3ls+-C4Ua96@`k-NI+#7-Hp6dnrZgBolCu0SIFpX02of<3!)Y$ z4>3~%cc9vBc4hRu$|r_t;Ap*D2U=&vCrnX?iz+T2+T!^GwFm#_N8M4vX`8G$jwi;K ze=p-NtJ=|5Yt37?YLJ2$2ZDP#Xp^m~Og7%cO^3btY0k34zJV1NrifOn|Cwut4N54j zU{0fLhGEP88GG}|32p8pfb2smE{@q)5W_DhTxi4m*<&^#hLmu2EmSct^o-cztK$+2 zq&YlN`rEpKbKuK1+W{EuTN`yU!pp1a4su|obP59^n4|IDV+Z<`;Z-1RJB3ohg|l0k zKfUujD~k^j9#kF9PRk`6YR|d8sk^ZYM{WQg^B>Mc;xnX5 zoc?dLxtF4s-I)Ye%C=EfgjJD!WHQu7Hv)?esBY|izR;41t}BD<0$@RS{H!1I51)^`_nvDKc&koW4JWZztLIv2S~xaRK=~LU)V!u-5q;u zmY1zT5CflP$m>eRck;|))iqyiHnPJ=Z2cn5?kvp8ZA(n!dX+_Ne1x4jB zqlVLoC@J5q>*1PFFjbBdVp4HrK1Xr9_Zb@kEUhmTNcFtt8@7D2nbpY4Aii#5($3;V zw&R*pk`}7&gsbkVaIcLD>edBAjtZae;>7pm1Dg40zem$j_yO5O=Y3sQoJ@rsAIYy;fg`jJ|#&fHPI3ZW%IJ18Eac3yvNx)BKzhQqLEt zF`$;=#_>L1elF#>c+~Fe{4_{*7+SJp`811?V%n5SAHoWV1T&Uo@cj})!sGZ!l;v4| zW3^u_cK!lqE%=y!n2pJAbddJ>E*xb3djE~Qt;Uid?pJF?&b(}{2g#_&VGEIHbwEan zV<0p5#uMhmsMXTnxaA*U5YUr{k`Lv@cA1@V01S%)w!sZznRHBk2~R{ z6A_z7s&xvcWCv}z75xMZI}HZWjJ#&6u#qpC22+RHTX*D4_$oO=1Pi_jc^Ek6r{Ql4JLm(D_Ao9=j@FN5vK;+oQY@tqRfY4+1! zQr^s_BnB*L!%tMq=5{OUGF?bTa`*!hkka-XkiGjlZMN|umPE*fP|V~o1%EE#iwP^=Zqum znA01t^NHEIVVO^EX2N-OjAp^h%$Q=`<7rk&dwpVSf)s;w32n?|tWdw@@2>Z#t>Tt{ z;A8&tOHl*>n+41f5}Ta1FVn{y7A&b5+9Y%X2#~GHV5pL^&F6Deb|`y&B9#eocE!1U zs5Dg2In21vACSfHoK`I9hWq@1`^BE)iF>sTt(+xn!;}F(-7&B@% z91cEHQ69FOSQ(kgidoomv*GRG!B?c7rkwmRPw|7$9ITCtKi!S~x~Ghr8Nv_<}ZSUJl%VG-%}JPI<6-2xpDTCWpl_ zXl2pMI-iW2WQ?B;x9PhFZLxZq(LpiXSr42z?D-@}JE3lizvqN(RmomoHh7MDg7!{_ z^@1$4^;vZ=tP`Ilp{eBy%%^smG|W3WDn=p@#MluGW54^1YPMmtsy)sKHq>&u6@Ngr zXT}Xhnrk=4OvlmaPRqo`#V^I$#j+CQs#t*uDMpk|=zxJehvD#(cgg?E^yl%@4rMa>j=C9KdO&ftF#@mi!Qp8ef>W{C2(LU1a+s{JO8zs{ z^=pmPcHrFxO#3{4TQ-jDXvnVWNw()N!nOvTk~uaYZ-&SX&6b{ti~4Y7?vWxd*hd}n zHZ5?Gsj)V>)@ICJmkvZj1;f?)T;kQMEP=wv>K!-G$leTOTTx%Z4kQQQZNgEdiE@9M z*J}_97DMkk5{D4D4d>-0-I!9^TE%G@9TMrOYC-^NUyx!oZ2D%0 zZTCT%>>~g;?t9cXp64$=h_v9fumO6h@TRY3QIPR2Pdw94Yh&pfv!oA{{&s9w*g0%F z>Whn>8&Z^E9e&iXj4W=4l;Wt4P8%+Fbf=(d;i@_&kH7iQmkWcu?N@mK2*{o63soaB zW_%pKeBp^9q}+;XtRZ%R#JqE?BHiKo)oXRCBN9-`VZ&&4ItSj6JEy#sbXYJ`nkI|N zHrJ3k243JTSbS~>Hq4V+cQLom8M6^9Qn*I=$|*Rxa$IJ9a%F9%ThZ?-13xi#1XqYU zt9K+7EjL!Nb@T#iz_a{>T#LtAB8;GfIKd1`T&umfAeP!DMj9k!R7m*?I{-HCx|C;4 z=s==S*g6=w45b~|EA2OEwa(&(^jC^=Kjt5J96wzEtHWkcEoJlHteVcrSL!YK$OA-*EoE&v}^7*P}r^JGaa4pwrMCsLMUrf%c7|h9t9K|M_ zeJ)qK2p*iJL@T0O?>L(BPO3X1>)ha_Rcu`kXo+*w9dd{uJj%T;Vi6!=>d=aDEr}$f zu0A+ymuzlYTl-Snh04sNCEdIj7n@QrH82Wq!Oyi7yvoA~DAK*40|Di7Y0;<9nXtWx zp~@<`TrAqPS;Q)#XA487U`cX)teu_5iC<0c$w@ zf>E5P2IIpSvm>N2L&|aT!%VKFzzFjaC6H9q7dG5*{SqzG$q`95;<|vlSDi|zq_!m3 zpe@-3Xm-&g*V%~X`)Use9GLA{1q7Pt0q(0Lns_b66x2p!NIV3o7rNQTFIe*pOVWYP zO}!*iL=|iV6BWh?WXx!(dQLg<`)+d>&AxldOVTWJ0^#RmZU@0L;pa5tWBvmoe|*e8FqakIm%nTtRq$i^UwEAl zY!e~Cb=q*te_*e(AqX4fD%*NTH=JIOmR zj?#fx`l$RJezC$vP-w3mb1FV(s&+_~ewhc>!=0}OC3}Vx^&*OB_4G1(=ppftJF4i{@(;{2Rsp=riLcH9bJJO_3oGh`FOKijMeYRE=D z;u>XS?eJsk9(ETHvE>h=kY62%1rGcOh2FO98k4va)? z7ly)=hL}wQn{1o)z!OWPAg~!*=B&F{CS-EVHp@92PC4t2m^9|?_TX&J(1wslItJP` zlfo*$7>agO36YwojbGY{(%$IUTp?V0@x#dvKny=4*izNcC6k1UTSH`8*sBBK;x5LL z3qcGc(rpPT5f@b#b<4w8aX>H$3+|jX0hVj=%k&$h==NAI&mf|7CbW?^&IMO`A#dK9 zC7ii@9zQR$7ohYFpT~b7QBsby6=!Gq_O4XHNja{N=M?}mP~>~j#YCZK1~4;&8)Igo z=wq?#p5><{42~~Vn#`e)9g9o?-`M(xSKhDuxUg1?RvrdtUKb(&r{Rid;@Jvz(dqdM z-jsPLKoh~CmM-`_{)1QiM7H^pI@hDV@HiM%i~VnucH(jT#LxY|@p=5m;igyljblDs zJUFM_VQTHi9A>?CcQw%u0Lk*(!EC`(?n|(%5Z)6r9 zmzdfXD(2MvbLnDAF=MW)&%-Ei-f;DcONK_2eqv5ceJyP!VdH#aN_IJ4+ykVmQa2+@ z7OtykB!xeG-EkcPH3*&qwu#BBECiYr0le_v9s;LgG~+h?a0G*Tk;Bg|b(qz1Oya1% zC!oS13l3M=HmRjj2oE1NE0mPdg-6|au!i-rS-4>atv4a}*=HGY;*5dz25j|r-_%#} zkJPLbRT1{k!K?+Y;nS;pqPB{k`~QQpo_Li{uXHKYdO`_k;_(BpVcF&7VGLVgs&RcD zKq_%!ywHd>; zdy3{oH{1Saw~!2FNT>)3fV#Llb0s(1kHeNkg5-eUOu4g?3QQPp!jf3{oUwRCEUR_S zk&;2woE5a%d_Ktm{Or{;t>x*48|_)G(;ZGt4K`E6LOsk$+mtE&fHYN0x}ztaYwPqL zS>zbnldMa#UCdOiKoB#Hxi}5U+%NWOzI~ko_hCK%ffsqUrW5l!kHfpVKK*C5NTF{8)QgBKyb#ld;Kio&B^xc^oicj2fw3Zik znCuQkr8px-e(1eE5aVn&wZuns0_HGYp+Ib{*J;CCHsr8C0x0=MX@f}t%SCz;9oMCnxZjRYG>QO zq&uI}bRq|(+!3}36RCW|fpw_pNzbpE24wN)!uV4$Pl6Ag`P_9Fs56q&0JR85ed87vq@U0)3wMO94!4mXIh?lkXyFwe$j3d-)O)@@-PgD7~VT!LO74gC?T%_R>6x z36tabvuIK0TE3hyVu$HKpTXIfViv}~FM`VE-E2oi!Zl6h$z%?d{OcomT4_IP*XjopQ7`^vu~U3t*c*@MHNG7m+@=aoO2<-+n+0}1@hraq$ggJgzb`Jg9v<@^#zQV$iHEQoTDIupg;Dds!$nofiD6f+ ze1mH~gZ}+jdEh>O_|I3jqX88Mk~_Ak`XVKqv7rTufSf_psDM6g!3wWUcG#zw5UT7+ zCQJ}%!2T{I+FHDd;8*hnuCEw~cd7{B%O589YH>wHewT;8GZ7zxspNaIz^#~Z*uajn z656Nm84q{bU(Fey$@C)WEMjeKJ&!;^%6C2tLK^7!#LV6}h&r-TE6j89( z2VUpX*Ln(rk{#`E-Rl$X@f3qI#D)dFlKU)5*I1E^t*!K~%8I3xOM%hin;<;R+M2^l zwO7ClJT=q~NUlGc(u`J{7hA9uM!Oh_Tm|pMkkD!)r0KRgw7?l6OX({b-0}C~^j(I7znGvdn9QMu>;r5b0& z$|OBmn+(fsy~&6iZNM29^r%3njCg6)he~y_#iN|-WQPhnwH#(FsY7?3;Iaf-%6^txt4uNeiKl>s6|=XFjAI z3d!iJ-|h2GShfw@^nrEatZkd__&olN*BNn}zWGLq)nJC{1Mm5V^iiq{-0Fehc7w@Wx+4$?uW;j4iZZ`=OV3FoR%=T<^O#d%17%^X>%hADq)b*a~=4( zCNS(*a5EWcg2SkmR$;&*h_g&W9nt9A6sTQiq70GZg*zMbNasv9o0HkBdB(a`%IFAw zgTs%lcVmG@0L1Q>G+SY_+q#;tP2Y{4e6x2oVNPSdLin+PV%+#;e#3(^dnFFQSWv@n ziW)dVI+I!7mwq61LRKxv^5-1;H$=qHffjI$v=*a@MZpU-oCuYBLdBP&4dfQB0+bE{ z?=Nn|Tw~qlZW#p!mUu(8d20=N|8l>G26HYr>f6a6>V|3y247Cr{cFZNA&LdSgU~{x zELXatVK1-CqJNTmUUn!QO$SwL6$OWVW8!hK%Y2YjJ8fWz^X9ezP`<(h)TdW7IwV<1 zG<+4xG)R)zY+yZdu_IE7=pZ9#WUtd>NUVvo7Bq{+ROUM|*@rL208vOAVvW|Btyb}! ze#z2ZSE}(rsoe4n0TE}vFc?h5FNPKZyqab!pK(<4sj&?o5P?Vqy&QUZn9>5`G@5P- zWn^{qil{WT#_CiCc#0e4`v{f{X;erX<}>$W2dr*m7A) zZXIX)USh3`byX}MLE@>`2|rj%JCHzAJKCtz#^b05*4A)<>znrfACPi>N>nkQ$6*!t zNb@}E+X@!KI~mbUD!E=V+(WEsxEhhe$}ZA;+e8Fmu0u4zWI$-q;alZHEbVTC-vM2a z_z?Vpbf_pYFG!+X<&oz;Y7!yy6|WD4G~HNDZTOHg;`GwXXTE^@yq8x@A7s60O9n>4${L5?c_|* zU^YdzWM@I7db6`X}d2B~284Ov1_V{zT*?@p5+ z=Phube?apue%`xvLW`}*yPXN#S8N1WP>xPIA{Z(qw+&{?+a=5P{O}>9)U#7sSar^u zzZ7?{oP%SKbEM#{0+_>skOFd??3d&v(|WhcD4~jGi*8P%hhxFQo&oqxE0_wnifpPu zZQ3}*^=f6i&Xm348&8$E3=wNs%88383&t8U^iw*D`Oe|}UcdwIaqn?@dBw54FqHxB@Gvww&gdnK8n8g?zw zp}wxF{}_V{z24!881qG>brGA@U>C?6^6Qbir&neDFgW)hqvjl;RusVUGh0b9>kO;AO6Rf@NJfoJ9zuAgE6~tpw@|xBOxnsid0PtV#Eiz zBZ$?-%9EYst9;^d{I)q}bm%vjcrJF@!?acrdoX4jj5HJIrv;@AjxZ&8i%HSVA~QI> zpOjgqit3Q%`k5eKt2y0_1@|;aWx@f=*of?CF%6T_HQ#xN+H+pPB24pvDb3jO%@}Je zmIO(uz?cjf7#f~%Nfrch$jGsJ*P1VMS{bAA=Mc7DryJ5iCxb212Tbb}&?O%+_l*|; z$7m2UZJo6L3~~#T>yc_;kehTb0N^26&8&t}LPtb3៭r`-F6m`9CU2j^kZP+) z;=}i&NH!nyA85UMTrdE{`XtP0=8eU2S~Tw!dsWXoAR@|_Msj`NW(U{Pqfd26?$xY4 z8eyJmra2c+GZEm#Dr~x;wSHj-kooW`4?jSMXZ>ym%-uX(COhB{9}K??qrcwPtRxuK zs_Ip(oH`TU&Zkv>^6EKlFnoZmaDXVaYfeyXtCZ!cT$N^W_#BLI#BCyLZJjo3neRmxz?J#4USd@r$1i+e|3qsrv&CVJ!Nb;ujHVsQ z#^xhWz2ShwY1uDUJ#;|~vKZpOEYQ;n7qloC>j3fi-krpiLv|%+)|9$@EL1!YA@SSF}nz$oo zbJYz8W-R6^@WYr!biC~#JMPEwUl>6}r&|;WS`JAaeYeVXmgK}5qvIaOgMvsdLN=n*@p50eqbQ)q)}Ws&iIs-AFG%Ij zu9;_*vPgj82$3ugMj>kPRX$xnC7%=BQc{0Q`;d^Wb${dAJn(uBybf#`(5z!9Oc$Wq zAj~o{*1Y1V!}n(7N7FoRo8Ax|ZNAuDNHHx2kZ$)mZKy%`dt&?Cs}G>a79!592U&Wu zLzh3}U0$xf*Zq3}VjR!7d_o!M`W!Jv+O_uszutcnidZvnn%FTWnlVNm_Gf()jO`uSDp3jW(@5tWeWnJp&`${Y;?LV=>m>++)g5vG(xtO*=U3{~P|5bi_K_@Rf zM$C@+sRu!spIi()EMsod_ z@}y!RRY(M?mimd+Iz3ai`+P5Wr+Z+BvX^9!L=}4VpED;p1DMl<316ARk|?SUKnxSz zDdG@FMq4+WRq@PoQbs=^$C3E|y8VBA%3u14C9TLIW1GI=`@%LyE%L>@>wO&{ai7R*={jobInN8a*r_#bS#$Ib~BF05GGO5?O=Q065d)`bA|u zTmC^^>~`>wM-EF9l*T279Y8ktf@xp6{54b?hL3r)&Q;V*{_c7PF$CPE@4f-JfHr3s zX>dh~XvQu7fHE357~DV$hisKq@F5xxGr}cIjf5YLrM)4ADSwyK53iT;#Zy$aaWht0 zF)SDU{WTCC@S)}f-6|{|c%q~NaIM9tzzHAnkl^B5^UZRhxlk!0BiyNql$75Cr8Cy_ z^Z2*()dd^eEyh!ay(r@hf$GjsY8}R5Zzi^Een<^lo&~b=>CwcfA(*hva#Req<6v4j z>$Bm>lMT!1vM{f~1k=Gv;|f*fN_H`#YkKuOW+ioG(==crFq zv)gHnHs^vuTO&Lt>k=2qStwOA6|&$D;rq%1q9~3XkS@d%GLjV3NL92BF?J86*4t&YMoNGzI`nEi~_XQV&_z&UmA5}YJs@Jfe?YE3lkIXR|T>3w9_3@C1-iUMTw z&6tsp{c@UZ?su4YSMyY*E$Ust^j)-59}X1RK5ve)EHNEelV;`Gg$VITKFf0jxvf8u z8hAzqgF}NucogCeSA*IrT|0uzD<_A;W8gdeR{v#dkDoP#8Q-ZDKllIfDq4&p4Uhxi7?}iai}8^U4dG)o z(TypbL8gwxc%;Lczm>6$O5=Q__l|&uvnFrTj?2Kc7_)@hkYF49K&Zh7*{|~x(v+O_ z#0!MndX=%*XvIbtkl7J*LO=X@Cni*s7Emn7O)ppY>RFSC|ELHLH4?s1(ws$y3OgLQ zZge;&b<*Pq(b3FJ0W}?Th?O~7^bSt~Pdc)0(|0Iw5fI;>?wtJJW~QbjxX4t(YiNC$0m_WJNcM$h71-t4X%b|j1C zb$&XHlAn1LCWO(<=q~8JPFPGs!ont^H3kqZX~mWGb@rD9Obw^w)+#=apQyc9Vk5iM z95byQaE21qqeap2f9I-vE{tpL=4FV|w2eN;6o zcfn-{{mUi6%O@NAbMlKb+GU_@`qrAU1~v1vLasisqz!Vmkf^p}WWjfI9Hwyrm^bn) z2`KPcpu)FG<5~J^{~MpjPj(<{zS%E+$E*C}C6EuNY@U@Y7Gdr=%m~Spy|9BXW}M)k ziS|1N;Cy`J7mLW9VM9||Fk!$XiUHL;LQ2~hlG$d^{#g}nHNlP!l~CE9sk#kDwFQ7? zf$9el*Z??r2DAe+)^X^!Q2sCkjTz6AoggT zle(lEru0VY8PhyrPV&?uqvSq+$H)8wRO3@Kanu9rwBe}qbfOS(HTY%2eg5GGgww!# zLr=UQSMzs562)?Yyo|U(JCvTuz%y!Vp673f(d8z8Q^S;oLEvFo^sn;7kzQ6nbo|`^ zhJ=wUE&$-^#SW|bj{E%0Y~z*WY1*PdQbJ6@#d=d(?eG!Qv;nEP=4wfIugceY!)CK3 zI=?dX$PG%(j-r}bqnJzFM=O*@C$+ttlbdxm5;)3ZOb-ufG%BCZ;G(s^R)k(5I7zJ^uFEmRQ_3ROQ z7E-Q@HheAK>=SbaXdYHXEv$~3{&O<$QWjBwNU4rHU!@EcZVp3lUNB7)oqph7)124nHQ@77%dFGMO$8JI|UyS%aP381l{5@@C@O8@K!&5@((DL`$4MwbYzes{!3!Uv}7>n9}MC=y_84uFkDlPP^>N zJBt6#r4UBg%VE$4fB&ERe*a6e#WOe0u)<6KnqP_oOag z;Y`B+1Cn*uob3=&5?x(BbjgRR`rhoMSbPk;T)8?cn8$Jh%@J3~@KXQWbxl3`x>5A9 z9CKNqRD17Q@3J1Dncr#5PueAYB49BM$&P3NZ6h3uP-*Ses_o&%Epc3g>}Yh!&ITvx zav8&S?xWM@A^hKj9D^OmrpGd6x8NS_qbWvn-S(j8|i><;9*8MAi<`r;<9 zzWDWG`GPK(d_VjJa&C}tpMT(eK7AmXm)TqXTmA#D@*62mxaAMXFp+H>9ZosuKiEOo zu$6{_1F{MA8V&nZgvd^a8P2`3dLnI(t#6D&P{p{}VK%0j0AC0pjcn9jR(!nGuk0oz z=4nPExQ>_4`(16z!w*O`q5 z`VCUSs;h}s$?uhx|H`4)2Hx^Fd|yuA#Dsk~gJ~w*n^MMZF~w`<;C@QkJ04wtyeOz| z(Ba^hl~KxTr=5)4R8yS&XHm$>x5@XEz4D8Od2_Zy%CPKsbb#r7sN*1(9^7dF7#86C zywW$=>@fnh7UZ~G*lvn0)nR|Qt#?4cROw+>?C?D6i5A+0STMS5?Ohd?5{y#QG#PXh zaG!s0250k8Imwb8cp4PB_&QK};n+vn*8J&fX8g0oe|NF{Sa^)Rq34#2ny*wsbwX2` z5mJO=BY4S@LAgyIBw!dEDR}|OBkb~8*Sw@cx|9)>&H0i9f$9)a-n`I2>Q<;26xBs$ z2-Za(kY zvvEZ0>`}P$V4?8eoB49>;36KrkE*d3)GlYr_XWcquBXxL1ax4@GC>>P{r8R8qIML3 z*?$yo zB+E$h`}zmge1kGmYB^o|AUbhr96X9rO?!IHFOnZ<4qq4>L~#KlLV)Zf`m4zmxVY$z zUEwxIF0m$6{3G97Ume{C>;EKN&@byS+nNkq z{K2xx6^{0@Q2?w{8zNqjh=AeheEpK0mHZIn)jIp@5S7EE0~l3@v0B9W@1T-4g~_OE z&2xCwKF1zx;P){3KR2^1y!Fy+V^#6{2>A8>8?_gUF3k`Z{8@gY_7i)J29;&s+zRv= zYSn_N&?-X#JYrHYF^*zF`A_kZNob8UVD=CLPiz=02tF4c;M??JsbtCF70rd#yaC1j zzNxR>)4$Ob6$z-JST!`VA*B9Id2-Jpprh9}WG4~8yaH~z0Wr2--EBBHl)=M8sd=FV zhbSLr!M@uNlyqlNE_s$EG8HkUc->`*ZV(Yi*-6RY|{rG$1m*lg?s(RkTHt}5D|r< z$Q>!pC^oP`&lm`BAJUGG9S*|Qb|gGFTR!F}7TD~))c51cWf^cfQDy^c@p z^?`mg-26w>)v4k%DGi7cN69oU zWKl!STDk6c9G{Tzz>|>h%FPM6vgzg&C|R+KI$i8m1VeG zY59K=i^4v`Ve^}p9jIhH75jHH>KB!NwK>9pIZ)3d$5K5fK})1sD{j{;xD&1C2m5Zv zEfZ>+((*-bbkqroF#VYSLJptS-4S-X&q$((k}P$oY(9o7YApUuZ6!Iz6k?m)KY`le`ax)E^YkvuWRvFD$4@0r5_L7v+ zo{SpZMvSgD8$j=#WSt9Nd^0Uep*p^GpBa%vaC-N4*4xK^eeE+u(B}p-V;WmBqi{5>)jLCJ@w{;uv;dSlRJkeIyRSbi^ zV3<6iUd-PROMtwlqA?R|AD4#cs(iL5q`z77jqeN93LDFoxaeq(`a(Q;(3ej2I`Qn` zMMa1rLXpy~t9YC35Ef0n;DCvMTSL}NG!TB&8gyrHD2#1)`0cC=A%m}HuCu+q?2-uH zag;BY9=t+k;1)AN*SWl5B&zn?6+0RUnjX0Mt#27{TXdwL-C$(dQ>GXPg|fzAQ$y`fhB z=NF&v^5wixw?3s6*#x{YlMG0>Jha1Q# z?>6%wZ8k^Rhb;3A9l?iQM;hT%6v@o!shL(G8*C&xTEba3Oljb&vQm)!hq(Nsx}p!& zVp$LXFAC9pS@A`?amidzLY?xzf#Eg_0DBEc#-~D(hl&-WZ1U z3ZX@Iifi6*RI1|1`nwtT|K`jZX?JF$fb$UU2ANJ+rw>9KMnTs>Q!KHK8y~KPc@;u{ zuaj_6H9Dtg#q?iW{Q2wsi_tiaic$T;4%OBO;a(vi*}50gm5eNULcdd;eI6lARO=l9 zPg5x`4#}xIR~ID9lswN6E}v3D2d!A5SJ^Axh2qf==}@r9Sn)#3XV?)CP|?HC`fv|+ z$SaM-(B#i(Q28eSFCL5+XKKE~Y%|derL8VWal0NmMP&-`%c0-pTX-p4oSbcsC zy~U#9%Taor*`XM#Ae(Ah!WW|%nEQmy(v@Ok|7gC+)`g9kEm4IWU^ND4HNtik_NU6KasdY=mYlJ^z;+?a04ZfNso zBkdONmPtUu|Lr5Cx#a<}N(&iInCRM0jF!Y-sdMuFSfs_BD!zFOf*_8II3Hr*JwIO{la9=*7k2?)tw^D5tv%3b^5@ZUdX}3n4K5* z$NYousW9t9o#~oyNF^C9yJMTkP@5{l)!cNkH)9maN3MW*>Xx^YhV}jEZf0C(uv`9) z(%(FX`p6*CtTCD1%)75(o>z?*wVtI+DH-+_>{1~T#AMFdiv>Za^0DJ=j%UwanT|?F z^2LVw+)GQkA<9vecf+)EFK~<5F?j< z3~-9Ye+sseIh-Db4+m{g2w$fm-)fs;bTi`DyWOxeCf-_sUApyZa|GsdOG`oc?CI}G zF1f8Kf|Uo=Eq`}tQ2FBkyM@K*yfV|&?1q*0;NMe`TJSo5;aR@p^Z02CKG-6a4Z@oh zRAm8rRPkdh!+`6O7YJ-$s9r`H%DbJXkm0~W!F?tb$IJ&hlEG;N@VFR5PgI&t4 z5tEm_j`Sc4R#a4UWEWoQz!|2B?7&5tCER*Cv81E9SJ3+$HXCkNVLF%;W}G0SkyO{& z#hj$JbN-j({DonbZ3EXnAPy2l%vqsz9I$zeX>ek<=XS_AuXs!>SxLnPt%7vB?;E-x z6SBU#;HEy|FiLC=GeU&V;L)0r; zZ9oS?!_ZP`HlZ-L%M9rfP$e4?=sGsCLg^=BPu{ug^@(I+TrsBh`UyG`uz=BjUndH$ z71D(YLllUn$X%Q>k8{9V6P+O@m?cf1mzOS15_BrU%sqIT(dXm%#F3b0xugw`{nIjYJ9E8mbBCB={6| zp6r0n8IxRF97UKyBXy!&h^1+N8CKPCh9K0Zgp%JnV63ef2&PHR5KDU}M5QW`lp4vmT z46{hWqoRXnyv`@)RK0-l=NMoYQ9{6q7$dfPheU*o0{DQa`$|;R5In|!6Xup|7jU;? zImHd7ztJk!-s^neRenR}sk*S3<-*yp*k8}`3$OC&!E~?kiMUR8{|hwG)6nw9mz3~@ zKC38Or3Gq;#i0&w;+$8+$ODIQm7M1H1g{Rc5Dx>KFdnd{e+554HFSQTFJR*3@H#*3 z?-j3hnsqaKeV}zA6f7BA>Fcd4Gtm*VzF4s zB9o+wVsAF*@bZ0EebM**Kleq`&3Dlp&SA4RMLiUmB$+H$5Jb=yV~!cC-mcf{oU`}y zR8_7OKjs{B{CN7DL$)lM`^Z^V8;H!P898t>O-Y9)4_~UJCjh%27TP#dSezQ%Oi>P- z7wNE4^r#|Ab(r#}lRUw>!;Cpqr{l8A2|$DgV|jjar#BG~1*_=83}8b)&=g^BRR2i^ zjtmQF5y5|xAfF)7bwxEF-zE8f3xf8dY~k4*9)Ip2ZIGdu2-2l07K zh#e?xM(NZNG@~oW!+P!D_m}WaEJfJwLe0?vAmC)U^qhD|dZio_J&YnvI(LgyU^MkS zI*gFrAwh##b^R_{?Syv+X=SE;xEih-rZ{8(S$Gi|U1Q zW&t+XQU>`Ucy|wQtdtG(-o&zT_WfNJ~ zF(Wt{L#e{a(H5=Mv;Oa0}@iN=+=4HT1~N@U0D1q50v?7 zpOXdoV$sF`txisHwF{5kpG3vk;u=~5Vj>E0#-M8p`Wh;KelCeim$U+N$5dxL_d8D0 z8Bw>b4qB?;YVu_iV3`*-zz6p_%y~c! z<2Y4l{4y@JJ$TYr*)l8NolrzEMoz;~HLA^xDPql3&l1jA4MxzAH#^;}v<(|xn4*|A z0ig}ZLdKCWT$=5;jLCNNRLxRawio5cfy9=YLr*c(kB6Iv`TG2|H7seEx;^VRk~xd& znblT+FfPo+jQm;?!z9_W$Vj33B`G}!01x{j{daX1iB!NNA+oUYYCFESzkGJpTE(yJ zPvmgIukGIsKh5m~c>_K78=`eV(g+D26PZKaTl!hTZn;*-W_gx7kj2C?fmz*+E;@sL zlpTONr=fS@MdAO|>6HMGa^^vXK>#2rq}ni^o>J1l=#sjZPdxS;j$T*%-cNjQf7=Yp z)&~X)>ol$S-ahfzzul8g`?3RAaKc_+LBRe;Tf z0@4K{Q4nH^kyK&MAs!eWNfk(hAh-HLuMM6lV~)-YHQFFukCPb?(M&tVSlB`QsJ&o{ zgJ=MQpC_E4SZU2?kA+ri71^|CKfi*p$vR%`<}jCF8WBnOdp^ChC%m^?LD!wZ#)Dke zKfI)r?5Mp=Ym)3;oxJrVtkw*s^bI>UV{npH*iA^dSu}Q9vH}p!s-C{#a06^B@$2)WQEUp<>1p%;hvwuKtq^cUL zwbsNfsmz>GcD9CY@MzirdiO`iEa`~JYyd7wV|2M%JwgUz`UO)2UM0hQRgfwc*x zO(|jX1K{Xq4|^Oyfrj7=5_(~Ep^R(^63Ri?GB7)%_Taz zrU6JXqIKyR5;pUUict=!a_*fi@ozEv_K5f857!vP7;v3G05m+x9Vw(AX?P+xl*9w- zVU{=)gEFC#ITzJ8tBMC5B1(!Bi9(qz6$LpM98|{}lg&oS0R-}FMHB?){IbR`{-zm+Q8wG&tWYuz#^@&m^SFE{u zN6jF&6`Cc=wPCWnZ_ee;=BdX6?6Kbv0Gl1$jcUt_B8SPkakBNEg=?G)H9l|c%fT{) z*IDj_Y#mET!OjvmK_GxtKAH)Xt$@n$gqFIK2y`B5wvhwf28KUZIv7Yc-?sszkmoq) z+$yefm{Eh})yIg?4@gc-Km#V5QAX2V(3|k(5N@(rjba?!hN+L=_4q|cgdxsz3V4#a zDXAmlK_2sHcE1ynIe+V!PiaQ3i$Po~;=O$O2jz_yaNB+%2j+q>6F~#oj@G{jftUcU zc7~R`>Ya2~qd2P7Rd+L|1?U}Hy`ve$QuH()xVkyJLn$1FA0G@`Ftyrh69FLgiaDLl z2WtLNjq?$WfjO%iV~a)cgvJoge_Eg)O=+9q_hQ#;8`BdD&fW7QQ8pt z@f}K~z5AssNaff;J<7LNMuR4tQQcs1T=Xm|MjD>yl9&U5o*(Bm!C)MEdHIFdMvQ59 z->d3OIu9_50jIe7_douppxa0J^3AhOSBC}3+JSv$%e+X{p{gM|!#bmQibCJ-zO5tQvqLF1W$8S0@^E+zRbSw}#aHe+5p-X3Fj+v*5FYYrz ze9H655MOO%r6+_qJn5AE5kvF$te>S}wr0mV$7Gs0rv>DZM4YCx7xo^2)`S1d5dg@! zuhyR~*cc+J9LSpj)|#KC!_bkicnb{`#UV=h1m=(t<)W+M3*AH?&hDXvJ{guCogzmp zkBjRxUF=YaSo6DAQlf|s$Rk35Eixz6%NSo_D3V)a?sAN@qtKy&W|**ERx?~3KMt#a zlku?0#!-hP%56%?2l?I>%G|G71nP7Fs+>|Ql5Tug?83W(0k>%uFet4@-=JfLiLAuQ zN|QKjP%7DaXKeZD6^qzvF(xwSY-oC9$Gz&!ttH$*(EQCOn(}{HIzFU0f$u3G8 z&bQOJG_7EG?B56o*1~rL8>X^@_{P`sPn@PRKA->M=L}|6*EeGd$;owSKga~zM>m^k z$(`ba-%kJ2{CTQ%O@c6aP)+HCHGla~l=SF?;>MaB1YhUh0nofqBH2M*9Yuzy!@*c9 z3iR2;c8Wv8kpgp8$o?XRy&6?`jaNSyxDGOwDB)T&Vcz5iphz3)T9qHpjO=2tFEv&? zup>(2y3mY)2f&jw;I`qESG=kYm&wD3a<0V4@j%D7ZNg_MM`-1+FHF1BO_mhs>d*Z3?YJ77*yH3*QuZ|g%{&qIF9`eJ0U*~+*qniUq!&b5YO z=n(e_ZL26jDE)&)iJg^3CXkK5(|$pUlpf^<84+&b>2OQzvJHq9OfzF{OsnF9CzQe# zeL@Jd*PwNU4A6#~YO>ohTC{D73C-pRqVlGYP!r7u)%wX%RAynq02ySoV6%;{szC#5 zx4}k->?Q;Wh(V&6j4Jz~BNeURp+c5@jm* zN6!sl`zc~VwV@ZYKRRmL@v;N?xj)cx$2xIAZQH|PIpQaHQAL-U9%h``ynD?!z4t?RuAwfaiWg?K>WYzxR|b z*ilg1hH4>Knk$V|NEvaCwb**Mi)j4Jqjwj(>XU!A*1B1~@S+f#Zb}j+YmP&0hKd^% zFC87VZn(}8PLH!?Xz#?zWZZJx>2^G)?u<%4d(8^X5xG{ADj1p+s*emv+Ie9F#2Hi6 zOkrhzFBp>$)`F-iBt>=p@)a3Yw2d;!J4$dYY z-0JopT94*}Mn*X6fmXPvr6W4LP%6(FKNXq zJS;TKpvY+I{y3vG4&F+8;;|D`CJT>U>fU6>Jvvlc_-}abH>=nQ%g~^2v1cYdPs0Qf zDoSVft57MVhDZ7JgWoQq!>Fh~Ag?Xyi}V)P=?%l8qA(Dv4Twj1Fs1KSXk^>$M`&?~ z7DZ{++66jYjN^n_ZnVp8%75=x42;80nHw*QW?u7z=l*hhoE~cltyC8>>M-H{OQXx_ z-46luC3_3U1zUb9#e{O?4WU$a|WQ}#Y_&knX(}S$DR#E3ST;~r+??fo^ zn-t_QOa`Sf45Vz2<)jM0br#PugoZlgJ7`Tk zL@m3#paSyD0P9t7atv~tw!T*c~(y~%GehEehNR|U2b?F7O zvsqvjxL1OYsWdkmIeO zG*OT5<(Jv(cjk6j;lNJ)*N^OwSG_xxnVB0WKVzMuU;HF^MB3rDGW30n{|FVdKhnY>X*!;EqY3t{N&*z_Z0CK;drVGBezp&;D z*69s7Ot>2~CL#*;A@cUxuuf<9=8|JHMBeEfl#_aFL;XN9LhQlkpsA~~HUG9QtyyqF zL$;Z&=2qjY{eZc+7f4QNtsBXMg6xj$7ajLrL&6}+9E~bl2eK}Gn~UfyUeX0JZaq!R zm*E-lL7zEctQ5X`r4g;FWZjY5A5Rsug6~6!(kHu&O#c2O3@)7 znzxN%Z8o1H4V2uEt8u~04x8@79l;dG@|6)4kCmC$2%__Ftp4p)7(TO&*ops&HjMTfgz8tIvt0>v&fK_rz5w*d(tcPDPqHvb> z#P{~;>sVdO=kwpzU2*N5rqv5LQN`)t{IZ!?_fE8Tt~mw;@ppObH@BtXXBA_M9hDUQ z^57bs^llgF6RD33po$l2KOF|TqdM0Cs3El5XdJX!BImSL@$$&$h&gGVsScw0vy|ma zsTJ9}&eEPNhVjIdG9LRkYFk_n#m~AQ$Tgg8q%c_kl#qeV|2N;y3ro6iy?~AhDNoLB zl5T{Bd2zLUkxw;af!t3_s!mJlO{}YA<-pwb1b_PlTKta;l*s^~tGxBcr4F%dPgnIM`99 zLU+bVIt&9PauNq!IVQmHS4uHsf(1T-RLDo6ef(_nNhPca7ndc8D7B?MQF^wG*AE@p za5Cl3AMi%8LFudBFqg&rkVu;>{e@I{d2Rg#5d-L~+fhB0FZe8li`jgnI(}3RDf4I6 zu-oNXyvx%f-s^^t0%{r5)L4>h4Qkshw|(>chicHvqkS8Hd_@iu9{aZ!C^0bAj9r5A z&v&0MVQMJb5SU5h(NS^R=#tP1tE*%7e6I~_yc~w~5e15)fja}V$-d0* zh#}%p?pQM~qS>m<#j?tek*&k6x1!d96d$;4U)a-T2M0SFkt_rY)@k?4f3Gi=HAa+R zRogAM=7||FV#4D`VW&!25a%&PP*x<$pW#0nHYBQq0g@dqCgzn~p!JS(e*ZCp&@5)c zfW`n8qA5?V-wH_BqRna3itF5Qnn=girKb4UUbRlL=|GgVF&sDq-*JEB!y(Ln$9LZ# zrs0$(^g8^nBTxDRCh$a$$C&ft0zCn@y^u>?1Z6LyO3 zQ8HnnZzUCnby*BG)HX&GN1-MV5!EIhy=%yWUvSE7cdqk?i&{3b?_Sc1W5)M&-iX`gcCL>7JA*=sVVySR*nl1c+W|u>z8XB7&;Mv=M4#h=jT~$@B=deI#kTCXzD0MlU3<8uTHk0j+hKa3@0XTzysP~hh zo4lDuPWTl$W-RIK8QWs&01bUtW`_x~?B@sr6+^4`VX4rX!#F3XzU5+weDz^4Aucpa5q8%pn@tKosEZEIT$3uO=mR@kz z<2EwG$7kT7(0V^~4}zu|;DydG`;5p?a-XpO(sn2uO1A#e8{M`qgqfT5lrNTec=O_b z>sH+*897bG2k$z8Q#Ed;7HW`_lF$UCX{#B9I zLYi?<5uf2ke_?{+7>22&`s3z@p575NWMID+8I8dT64{UF_sC(wZu326u#?1~LLm3W zNjEx=)Uj(1sUZ0w0`3*P8a!{a*w~{JX&8YaEs$(Xg1bSm0Dal~mHuR$1Ja401kG0U zWf|unDQ7Y^W~g5)jd5V6!=amw6GIWu6X15Wq#PNEfTc;IDh8L|ai$CeqNF-A%@n`2R;CpV&DF#mr+t zqj?rkdqX~icS+9^K*&)8c6K&Ad=}-C*n81oseFn#&9)|AB0?btrOnAJtm87jLslw0 zXi2{nDS=*R4=ZLSthnNtE!*0M^^32IYF6j8r`dfz7t9hR+hBZ3gDR|NO~0~Wg%1xQ z!cB@`=H8jojIbXyAb1)Fusf@8$Uq)z4rj}8cy{OL1ca|v$U=6Hm8W0VWW z5U%DpTa@%ViZ~m13py`mwZ2BIk2dqJP_73y7>H4*~Jj!rJZsg)Q=>OEa-Uo;m!$ zBWpuSRrtr?Z7Al)I-QXN)t^H=XtMa2?7*Guu;Agc<}2jUf68afX>lgbao!>|Z|d3L zs=++bz>%AK_HJWI6qHHLEafLEy?PWwnu4s!qyH@ZZms=7jI@O(jPy8s&(Zn?1f-OK z25jwxXcR{-w#B-r6T~P(AhlPO{kAFceQk*cC6TY5i#u*YGJB`*JQp1ijK?tPL^7S9n6z=uNrJ?PN1Qu)_X^@83Xo8G{!8DBrl3PvkJ;UPfn8Tk%YW4nnq% za>H%=bo=bRzVN;zCufMFd|dkh5vOT|1a517M@Plkyy*ZKq&VZ5>1CvgWl1aE=HC%x z!fCqVd;1e_^B<5qE8&lWbF+~ZWQ-|o6p$PSJ7WAzMN2opyVFODuo>6Y*6wD{vLQu< z$qg1Ig_*Sb5s~3uzNk5|8Kn+LLYDL)(`Qa`gPg-T(`a7sQ82xNx}FuU`gAehpaeSB-GV;Ex2zt z5`qM{nr}4we#iI0=M+Zej(& z1KpL?A;NF`95V{YJr5`xOt%X8T8(kBtgX8Z*f?k<6;RdI@DAGRW;O%TtF!}c@RuD1 z3u>s2H$TcREa~F57y7xXAda1!@L&$$j}&10XELokctGVip``_-t#*-GM}f`o(uN)j zYVQCv?3S0)6SXIt^M@~VGDhe@)~xz)^SUrBM1*}ViHlB(Zl`*0+(4&%c1(Gl&bZEh zcmZ;m-;g5>{Y0m&eQ1m1G{A$WBZmd+bhSm@oQ(s(FBcj82}4%lphH61gN}yNbVX~$ z6w1w?sn#B%)zdNIoIU`20ZEwsY6X-wQF9m}Ve$bjXNt4WWS<8J1FGboR-fSWjhpg!>m!iuVA(TB^D!YJgEaojeDv| z(?iCfzQ34UF$TIw*N0`WJgtxcDvp|q28D|Wde#i*UcNlfUUMTc9aX$M3g?AK`;&Y5 z@{2-MKb6}%)_ldYJY46K!fb`WaH`O=(9oNoZRCXrIiTLG8sjmc_JlD515)TNCY}2U z6#>-<1*Jbx3p=bD3X2{y{{(=0`9fUst-*24Z9`5Wz3G7%cm>g zhP@U)xFnbqJB8HbfP{#>78kwo=X3--4XfVK`pjXmRbUQf z81<7PNr@^I4N9id5d1aNw)#8PO$QI*K?kJtleohO%w@+N>->{jM zLv-y}f?fJFh9t8N0HVz=1o3gobZqb46*|ml4U9;&`IasE6@eVx zI5fql(Moyv%c!#T24z&p1CQ@;gmux-^o1N}lt4z)nlHG_Z-hxUc;}_C!I{t`^Xzfv?I+Jt~hDDFgxZ_}6`-3RL z@X|XXHGAFMlv1u5$Dw*QC|N&aychVHBE6Mne2U~IWG3NZw@$_K*=_EX(}b6;AFVC^ z*s~FL@Co?ap=n9nrseYiKs`k?)djSUFP8?F3~Aa1rmLdUI=snQ%mpCgY#& zFtm`VI7|fN;c%4zuXWm1^WXFDLERaiB@Y)?PPfRPAx3OzK(mBrEtCM7+1>5=*lK{D9guBMK;)Z**|{ z;*3k{44AA+_vhpkPFn5PRv-gV05%AZ5JedvWF)2y0fk)eSkkK#1_^^V-s7Te8`^*V?Drx>vHeVuwo$ibcr!fH}_C z(`J8Ob243=-HW*;t;~-}i_cXEJxz9@kvu@l5m+4UL2=%S&pQCPD0o2BjpUe+{DK$?d4wRmT`(g5;Hz3+fY-s&7m*j=yxCn)$+RWtk%ZyIc zNItORU{e80tx34m(b~%%YH)~&=t3I~G(|v)PJLM@R|?Ug=5)u;Dol_gc`w;qg`;#>pppXGz3Z>DTnMO*tsV>TZa?FEl^Q zj17$uHq#h9`B%MTn;%9UPNed--SPKg2d;*UQsF@(btb-PmI%Cr@a0#Gtz2fbgT*5A6B~S#!_MX+|+9 zT_lrTB$40H%^p5P(=kP(8H;@w9UK+3pPBl=BpEAMB*WW zbm5K(-H0R+va~XaD_GgMja#C5u2ue(2qxOIA&myAJsjs1!bZuJo>MgZ?d)_y zbu`qoa9&V5VTo2dX2VL!N(x?S#7G834Lcs?j**AKFF^;#3RkqhU@wGUMGE5G&$!I*I8SdliYTSDW`(pkJgE*) z2Wxog)CW>r$UFr^NMHr#%2C+Az=*c zF0t`Bf4=^0hwjVQ#J}(Vx2=bli4|c1X)i2^&*WZaJ6LyI<}2i{mRywjLacGj5-}nL zVhGInFzTuf7-9RD`RXe197J~E@6E1r!Ta(D>&BAiBdWt)R!R(77mtpu%D-Qx7O*XelE$qT7GD;!vFb{W(;wtY-mi_m&O@HMrKAb z%DtPi#^i9g=3}MV`DgR67=aij^e(z|LW(eoHRm02<1Y5kRM_cv5LETpzYKCTq4ds< zEXIt-{)HTeS*--gvNhp5cp#bHMrRLMtGlC5N5n%^X4%n8JClQXS&-EtH&VW^SN(>( zc*G*nFGLIQ$ty8dHyc{&?g%Rz10C+AZN_e}irF~RM}HU{P8v_D-76MOQ`+!@Qgurf z5wj%7jc<6Co4?ra?GvRv0f>e>1YycFE}hgg=|*&57ZcY=m5v1T9p*YJI4$C~ec3QM zL1uD%A!GO@nw%;eL3YZh7_$=Qn2R|f12d`Xmvq6a-VjX~Ck{Tf19q{-h#kqGE{o`l zbj{`L>H-NyPw|Ysu3lXvOB^JOwj#%cg1x8mo>_$}lV0sEIsD2cFn_DMp{C-2H##_h z2Qx6*>`+GO1$!-c?mXDHurYYa+-I@DF!tgsu*d$z`AWHuIoSbX9W6L9{?ea5RDJAs zqg=96eb_q}taqJ%$I~)HO5gCk{mClaT!ZIC=GDjYUwG9!`qq8Gx=vT?8h6x2-Nk+X zgp4-j!IeTmZOxc7pqX7*`~WNMC>W(h34iv<)-;8v9N3@GYc)}#d6>mu^M;dOmZA)6 zUZlBLiqS6*!g8>^_LK1^BUKNIGRq=>-E@=eCg_y8Lb^xo*G1ln~ z_ws#!aRz+MgKNx_)^5Y=K3tTUWnyZ7Lj<<^A~UlQf^kDkG)!T{XbZM%&5T78K;lb9 zPUAA=7uUQF=>I;m5@a`}jM@Qa{&0OsgBBdcpw_L1-PbEC{{V?>HF%e6hB_wLpCvrS z&npOv&pmoEf7G<7Fyah58LTa#>9CtuoNh6u7*lIcARK=}RQsf_t%`{xym)r5I@wJX zFy_-yiOqKH75E(r??<^@Fb#?4BR87;VLt!RN3@`QsJ(nZ%!_~2LXKny0~#@bBkR=I9S zeo)1%uI9NvP_P}sdq@S92a?!MYRwVMX|&5WCmN*`PX4G}VM)a{kE~Q^U^rpMZTrHU zBw$^*d19p2A`Dn5#R;c;#oVjMr2_B^Hz1)~{>7YTY?0#FVNu^9U!yf%y*TOn$gU-`XTc7wU_liYTpg+iJ0t=Bx8prk#ib_A2V?}_HK^3{bj0cb{>zN zo%<=DZFV$f5Aw^+yo7_#W~D|)uUKCk9%Dh{+x zUlJY~WIvgu(h=fTk>>y3tJBa+FGy9n_7%XGSBUw=f+9I=I%w9GP}r(L;KkMjpGP+{ zS7&;57UaElMBcOw^2(R-AKTRzRv?QJmBSKbXLvkgG$id z=0Fv)d~fDCMVymfUHE20JlqXj~9Sk1s-AdIsDUN8DId-;!2{#v2Ti*G3t$F}}l5@i)t6 z7E?sZe}f9K+D0Gt>8-JwsXhC@6V5&78L1}7;rKfLhT0f-HpdY#bI$juj8)?t7&?`=2R*@qVQgpPI z5#%S$gt|yElGrI$hxcTDM+b);YktFdx*E%F#+u&{5OJB`Y;REPwxS`MLv6F@<&-Cb z8;32?fHu|T6q}WO0RZOoLMeO}j6I$FbHGps4X>lkHROZ#`TX~INA^r|SkU@mkGuZN z@_nF7MI8$}quLvyh0Fy+wms~uYDn>A@H0cW zTJL^N&1r#bfQHc22o(oLs7y}jrraPRjv~Ih#FjDRNafElA)xp((SA^_dAH}R`Bb%Y zp!;4{h+1;X6BVT$9o^^OQy4P!*bTIyJ&;y3~}G_6K4CH-$b&^fK$Ggbo?zjT|G zxJN@T_b2KVA;iP)qYXMZe4^R2Lr^837wOeONe}A=NG*jigrZ@{kMiwnMFOZ4XH+w?yw1P- zvnKtN0<-J<8_vcw>KLxi;@Iuy9(cLe;@7s1#%JX~qPGu7Fjp#+Km4|?icOay8R z^SM7Tr;geai8zKNsEAd-(W~BF=%_0BQND4?XS^z(C%ZcH`3eag!E;vF!OkWOeX^?s z=eO)&vagk7PRm?xCv1rJcezJZOtC`>Xnh~&WjGeR(WvGfwZYF{UOcm1D6*m%D)cE; zM01oT#5eic6oeJMfU}4VBr{EnSo7IggUQ5>(tbSl)qlU*D%ReH*KquAwH_+Y2Rg}7kFtKN*KEpxSMi;AgWI#B7{`NEXC3zK$8EK^a+ zW(QP2=?UlxNNFf$&?p-cElzF%Wi99u(U$~qf@Ypn8yo9qvwU@JzUvHNZ@8CVnEQg; z_U#Oft?Ryc2gVN2jcz=&BS(gY7L( z3#_qO)Lu8lyyBEsobw0fwBnpA6d0!VUfBu8Qbz|pnsP_!&(F*nl~-M#bJD_tJ;t|F>h=OaZk89waPUq8A_c~Yqei^donbCeAz z8j@}YNRqo`ujN3EePKPg71zF@bY60`74*dUU=0Pek6elI)gX0xD;=6AXbtvW?GjBs z&*A!^MMyTi7%!u%UEsiJ+8Al9BG9^gK0jI1uq(LC?-nLiopB`lcb*8GrTh$oi>SRL z#pcko7-{TGH^1a!3@CN81Ant;GZ2H0?y?7VZNtR#C|qP0I+xNialD&7s=wl6DaCf}!ud5CMi zS{$c*ct-Uv%AXdLemUA3Tzt57>MH~%iGIdmpSaV(D|cdqvv&()h(3F@1IQsaqJx#h z5p(2?erWL;pcFK13{`k+k#X42>TpQei!mb9h;x2-TN5{qTR687!vf$yk8Z(chS)k} zbs)Tw{OmE@(;S1j@#<7|oO1VznoJH`h#f|$Ek6A6E!t(uXl8GH#VMccK)>KRGvc)w zo_U>rw<;c3(hv%<`qdLNn9HznIecz)Lkh1$>)w4RI;9zyKk&VM+Qu@fpM^v{$~PY6 zX1-S)r83ilgpC~`89Cg1kJj|z(9&i8@cCA<%SM;4^29l0gmtJxjm}L7GwTcvTaW>G za)ytfh8P1*`Q)4SN1l10M;di4t5ImBR#23gE&;I84O!og^Ve;*OMcIhqY zj2G^H5c6;k2;f@p=4c=jQ&!@ulRTI_sPsiKl~@eaP$6$E5kvSq8K@+&rUs@*LsLGV zf!!bHbaI;&5#&)AAl5>6_)_*odwrpq-T8nP*;U6NO#=)HHB-<7Bsm#nTDBgd@@w|0 z%o^@%#ZuUB91f|YF(Jo`&tL@UlG-~uKM_KF9{Hmvv;Ef?jwb|x_DE)qn7D73bcUR! zSy*I$zl?((>ib@Y69V0EH|y%7GXnWM`14BJkmPV46P?Q2W(1Kt=oYtKJ+MV_?$6 zOhU^kX>Ia>lG3}#ib+mq6HT$TijWf(1FGvI1D!6L-PNr6d|Taq zR19+(SsxrgCfjV5DG)o*?ZD{OJfC*=qf$=!tKPr?>%(8Xl)t)w^?6?hv7G*nVmJ9c z`FpOJal*1&$h!RTq$_C3KjuVif7va`e~Z<0_v(uf4c{p-a#hGX_WDFf0WlJK^hj2- z-WJI~a3Ek}u&_bu{NtrcrVb7eLowTph|*s8dj08ZLOA#L_6a!>i}J|m*MxuH|1Yfh zING<`=22$&kPbRHDA!3WyD|{%O4d%XdkY6x}ozH8{@8)`YMUF4O*oCZ&%b_??D7({ccGANU%0JFnb$QN7fp3JPYb&^y zFYl~FPiXCKdxyWjm}T;#3rL8=Ol-^z$P|#Uuc7qa87AbO^Wfs;p@Uv>e*VotZwn5O zNCA5?wdo4ZU(%keileWKr1DC{N|B*C1BQt_xZ92?Eto*HY_^c3&R(7-T*{uV1@)!BPqt3(&QZjp$=N9kGuwUYB|n8gj?$Ci`g%mKcj%` z6|Ah(Sz)s~d(}HqO!&3^jTC1~Q|!(>5{>v(zo97D9Dd>R^>0#LWAd4jJnXLX@7U@C ze?I;f{;~e=`1|=U&#u?r-0FjQDHeb=F3<5r(nv#!vcI5ZJlFUOulkK=c_4+|bQ9US zq7#B!U)Y&ok4Uu7tv(PtEzk9yeyX7fNnYkRl)ibO80T@_E8g+D7I%TrjEC7p6Q)FQ zZ#B0BF$#HD52PZ-fLba>NF13~@+K2wu=Wid6MFBEIj0V3L1kNgke1#!e=O}~B$u0e z;_31_LK}ZSRZoaKaX*I3DWPVnf1yK!8jP{Jn{NbWb1}1Ts zcb$K;8OqrY8^*W3yeQBtNUbvuJEJ^WrZ~wKI_PLn*bnv@IV`B5K{&XwUA)^ce>6al z0E5kT%Oz(;D?`B9;k&6az7&AFw3hy|19Tj`wHKVH54Wt3A>cGIh=&(fhXibMS}j0| z#*lQG-mvEL0nT|DO?S0n`euioM0LA8lZ=E+LP*HI<^UjDj@C1pY1)f_#>>cQweSJ3ta@T=l?Jrk4Q26=ex7Gnkmx<;pOg!tFmMs`xl0d z&y&yGXv4Bq=Q@er&B%~bmA5iqj?o3jt8#E3HKU10<^w2p94Z`=Cy|I}7`xi$FgoBQ zekdMxX=k6I#h5V1#j1PDRS)Cx;Pax(t~$$(W!N3{Q6##PuCYa_#ZiIJ3rqV*?}UHO zgrp%m46VQ4vAP~k^Y0j=cZ5hRly2LX!_)vt4pE2Nz5M#I5VScM6vU2%553#1JZOm? z<%sNUz36)q87k3?2efY34Rbo%Mx|RMD>wMU=i)yol@(^wWtBpSehAV2p77e_n@b;- z8xK}pbqN1$t9bY zI{GH$xIk)awZ|GN6AvCa1pwzdI)H~|^mu=&hP~~!jB!Cm>||z$xk2hF2ZgM*q^pRI z^;1MR`9?TTAH4j6<_fD>?yuO=%PXOyEe?(E9zIm>I}jrWryLtMpz+c#X-74E!T0t_ z8I83wEJEpYYWBCJ$UOr7Loew4z!?IhUn=I+AJTuhE*USQ? zh3<3FVi_wyfPC5lXlt+e3$;ZXY7=vd@cb#SHt#**G;RL7i`{q5%+q1|;yV=IyI^$) zjCmWh8&M%5`g`dwhrqbsSLDE1(b-5i%$|9(z3?zZXYxit&zH}|vepCFFS`+5D6&z~ zWzB*^OjveqQ7)jOfUVQT7F&QQw_-e;^2H|kJm6@%up)=2SAP=o$w*L}WJ+{Ljgex) zV23=p+-8?xDqIe9Mwk+-N^Ybjo$<2JoffRph+}BU3IYJ^!SvyeHIlss7MaZJg~Pdy zYMK`%8fs1xe zistV!n8=m(D6_wRb!fHh{;q}XYK@)q8y>j(Iv$3V$w&*sSkmq13;eRrk#OviE__e% z+uclc06)tOa`F{)dAv;c_qm@=Q$2LG#ML>|n5|=J7XGy&2JWkuX}lJL=EQD#oBy!L zT6Q2nffVa<6G&k)k)#>z<;lAoX`PN;B!73V+2^eUamLx1Z`3zz)#%Z+;1o~#_i^2 zUk`ZqxO4!*9O8{@@JyjqIkeQpo(VgU;pa0bz2wwyMpK=K($%^&Zpb@GH@#y?-?rd3 zOpQ4pF?39kjy?ZQv)HQ|!p$ z<#2-L?9zi4>!(n&Wp9GA280#lPGM1gp7uAK4wD2h3gPU&$S_}zGl4;-r z=jnqRHm{b!F<}BDL*M2<5JSLTKQJYlDbnxfgwl({FmgwZF`+je%J(+ZxwVh(3+Psf zX0#v?n*^Brnru#U)Op;tZzlnyNMWlOd~(Yc#MZi83dZ}Pwaag=qY&FBAX#T!Jyy52 zf_XpTS?I|oyCUt4j*iC;3OJ3;quE~Tg9hwb5n@kS&WdIOj?06cpj++Kf|R*81E{PP zG+L9AJB=3GHY%;r{bwj@Sdh)5{Br0#havoI>12$l0!HmdhsyLj<$ORY`k4KaYRu0& zicdj;K*DTY3#ry~I^lc!+u!q6A2{V`gd`=0Qnx{foQiSHB-mYv&1rGmv2pFgoSn^% zK80=_9W9T}(>qT2?49nKub9la;pmPbh?hm6!R?25>DgShIrktjiSTUsF|SfWWaRDp z^20-1>kx+ben2p*;Kdg=Z6=~^>hXYu`JM8`+CR43%yhmW7TSj>PeccH>&=bX^fUD( z){_qUfM{15>3>SG+#SuI1s5qr76w5p8wKYq6dPOT?+W7lMEp11$ zN>$yR9#GcN$|tI$V#aFp+GsFibwxgzVGrxnhKf1Z_p4p(6)SWE&AD~E-H)9HC4FHsz2Z z%fpdH!2@^A7ffjxbCH^`PVW%p2>_?*VzUt#L}l>>mcXcIB_qj>>fJF}gAco$;g|Si zHa9t(e749xKiTJfIok0oH@fR4by34IokRbCT4lg!gpn>ddckJ1;A6+sO1Igg*k6Ak zTUeK7lp2nEl53NNP4MEoLr{@Hd4U7+S0DpwH_eFx`|kUvY3?FofaUA}pRa#8?9GC9 z^K((Kql`l-qW!>QXOzN>#oVgPpm+y$>cQW`l8%Ij3WR`oFQ3lgf7Kg)JI&T)HQcsO z?1>fRtKMu#e#08y9YYQVSEOEl9CX5;pXFx5^lx4$ zY}v#oa2R-*KQPtBdLZC5jZA7SD*cQYqE|uEu8=Z$vJLU(EHJ$gIg55QT<1S9)f*n= zmk%#>Q=g}It4JG~84ZdlQJWlOFLp>3NC3z0u{dt6gISe`T527x^3<7{4#_ddp%XYaP2 zR@}BPbE1ZI+ML_n%O_s-VG8=;PRfe^+X)6+UGcsBg%nA3y=~ukU;etYWiEIXuXBa8kC8 zUw$XMkQ=0zdhR!$Db}{*f)Cr9hRN8FoP-IUP02b&vA;Sh&^e>NZH#_kRKw8Bh@lo$ zNiYYT|5Df)Gd?OJM!3E5FAzpng1$89bCq+Q(Q?-RIEJxJP5`qah$p%}TvZzi`LrYOAbI3qyi1vLs7`)(B?>;y2 z$PHBv0uPcD48ztTao?3aQT?;u_fMQBZs;kU@U$waHM+af7wsEUooIR9iXA4Vm5F@k zgxQjj6@VovONN@6V1S6K*CSDfbn%nJQz=HjJmz#lGk8-LHMMN0eRc)%V_#7k2mX)! zjvP*S?oT}S8w;_Wg;;&khmDR0Pf~YHV|6dT@MdX_M?KK1-XPA8x=BJm!FgWW{#A978oo{6z7~uw(e-R85Qw;QeZcS z)&^Wu{d>~dX1KvRTgzM(gm~nb&1+6>zY|bj_IYPq=idN;=BN8)K4R}!8wG{e`FCG) zOFDZ;NX^xRIqgV$@^}m7bc~L_c#%Sgj{bji^^OQNIN1Y6qt?2wxzNEG-DkUBufO~N zf0S>uEOBpv^dFp4un?rj+Xm&)P&@POztcL&v{6<;(SBDx@41}J^J=p*bu$Q4iI&AK zDu$F%o3c6^%x&>C7)vo>#no^^g*J7(&A&lznCHyNzJz14E)cg~!yLQ(?L0F zPN+RYDq6mTt5XW~_e7zbAk#ax{KXW@kNAz;v+GrIT)a(=HTn#N^j%(@InMr)L!%#; zs+3cv*N`p@b$u}9xCDU1y87WmLWNi{07%Afd^fM~1nMxk6x^iwPiqCI>Eef#9FGBb zHI>4Q>->k)9z}8HMyEGYjKFpN!!E4_wQZPjf^7deBN?{VT;ScIE~&+3eX>qxXORhV z;aBrH7a_`E7no?&-3cKv1jInI#-p}CRcS572nV~Z<8h$z!r@^`&!Y=4!-ui}@HYRB zS6%To|A7D=LbS^Hz*hfhL-rHaOy8$J*8hRh3LfPP0STA+1MBvQ>-;-Pqh{l=e`C!T z&%5Bo&);L6t_Zkeod^xfenwtytYT+d=VPWL(WA_NNVeE8r;O8~tCWSm&II$5_Cf7B znZ1qCdNm7-{=5f=D-9-2G5Ztn$l0* zin5OQ++NW1ov`_xceNU_|WHfygh-h~|T|6@8A=QqTNU+88zKlt!8Qj9)d zkSH)l{I@~haITCoqLqqCm~JF@eXvu=LJ4g!w??cl87nmumr3CX7e5TiG})0ta~xDHysT&TKwp2wx^m&nsAczdx})Q4o1TmpMPxplaW|C3 zY{zq-53TcTLp2Q%WuHI!CKR!tSjVbP2?+K(5F;lO&Spyv!|}cE^@-977Obd&gaksM zWc7@}?r!rc(ZLH!&<5f>hShGvUOBu!&e(?20hRfJFi+EkYbwqVpI&s;b$Wvg51Ef3 zD-7yDiV;9G7xR79m5=j;gpRyCzI}tH{To|-;Pc7BZ|STKr9)uhv=RT033J`N`qg2e zjPugWkklx%sb)KPhE_s*Mf*TcMYK>BLNm5be<)R;r|D_~ei1)*E2=W&uuO=!+0b~$ zoHjhlFZ*}NQydlUw%31wBEB*A{PXeu;2-$kyqK(ADTgmQBve2FUDfjLo1I&i`Gca| z5HY0%y|SQTK{6=maz)nsVyh37w7CxI82iAzPSk)f<_BU)4r7ryN0($-MJc1b_RRzO zIOkz;beZ3sD&1Pgb^gQ8;2dYP+;N)Dn2a2tOXoWO?)#lx@dM1TzYe*9MPCSNuYJec z{7-yuBfu=ifV3xv;Z@*m=|O+7^6>OdvO>+MmTV&4LP}{HH}DfZU+o~5KrT6rPu1QW z%$_7B^kmgpWTwYvhmvIU=ltfFx01uQi9^U7W?*Jzvs#kf5UvCpKCU(^FbomQ;O=M$ z$u2_kV>$}@bnB<6;ZQbQoeO?4IA%@@zVR1S`P8g{I zMw+I2K<~xy&V=N70h}`+4meE4kaFiFf1mjMqkLn{Z`k)2E;D)O6n);kJ=V{azCoh6 zd-=4=mNB2lZ1>yt7nH{!rv$nbOz5WJnar4vdE?11vD(ahuS;~ti#;G=$tOtgN9O`M z&@wmXjh9pzMS(7WVvMU6xEIFdHH1~AZ)mmQnIBfkzaS$;!96+vnQSS|(C!zS;7raE zNTn`C@x9a}$U&R<^<;XQmvy@fN;h}cPRh0DxN}m%rCe((nz6hT6epPVx!)k;$ju;G ztxU})nr3Q#pwmE*`4gkNQznS!n=0N|U}ZmZa+pyP=NfCiV5=KR2QhgE3BaGHaz~P} zuJ*bajhy)}nz2w3&iIEMCw#sBgV`8xtyT0y$AH$x8iYA(5#grO5)B|~h zdX&;gbB;(p^AqDunv>&YO=>YO8eKv_q#JLF6Ofp@vAP&V?cauH`Nn2L#aCtOU+M{R zpWML(m3lOua<{`W`9t061F4H4^$SZn+X8Qb-3x4u$M3JkrsgpHam*A;} zhSL-s3R~Q9b+e66OK;_7Cld}jO*l@zh_*^KJzr#jOeF`UP#$E}=2prsCnTT{AGPi3 zbROl~XD|{?21I;se>uwv0PcluwJFdG>pZ<#^;^6e{@y-~rd)g`!o_~Hi0B4Wjo~68 z3wD&!9ufAsSUA{f77$Of@X*YSg2;5Zyi?3LP3w|h9m!CN1rVuWsHcu4a$&s?=79m8c3Hc5U6u7jl>ol?-V19>B369Imn)=104<7thfiIX|>s z-^?^{PAlG*Kd{veAE!TD;jej{F3L5(IXo$taIXcmldT1VTaUEtK~LXN3J2NG^29bV zpZzjh;-1YVYG}A^U)T)#eU^s{;GSrB)f-6(okg8A5M;hlcO&s72k;N;9D@s)siT>V z)@)2rhn038mUGRlSTGC`kB7d#hEvAw=N~L08AkN+NU=CfC}|bM%=s4Voa;P)H2=`K z!S!M9-dsAK?dAnbN5!+;u+^7+@0%C3>h{R;ibgs}%mZ1{8K+DZ#c3ioDEt^uKuYnK z9t?We>m98Rc83^E$^j3EKwz~v($Qed4#EV~4+Ouo;wYGX;S3tw?iI;#g8(uL*b}IZ18k4mdDNK6%3|fC9cb$ zwt~5y@F+K&@@f_h*@n|2E1R2TRIGZw0L)Q#V6gyv(aW7w!nV>V9$fR)7d$c7kZ zoKH+C!9VV?2dr5wjan8s~EN#nhgXk6GAjrm5LNyn6G-rquibKB@ZLo&liWD^m$cTZs2@R zwj|837*WjQXHW|x%Xb?0SyyX&R!m8cIqf3{Ck7dIa(?#MZ+5ZaP<&_}!hk8Jn!+!N z7!$8Sg8_H@oIaC^Kr#4noz76I-*71)+lUbm7d*=im-*c~MkY}Xrdcxj?!`ONfQVQ9 zndLpD8L2lv?2oKH>EE{6ebBECF(4p#kuo`49wRRo7(t^o&GG0CNLCuVPMv)eYtBaP zX0(BPsRD3dV(}SB^bE*gb@n~Xi)sOk#w%@+WE3iX7~Qbb$sly!kEPE)PzJG3A0X3E zk>v8IqdnD5CAz42%vWYLDnXD!P;~nW=hb4+%iutF0>k2u!=s_L3?^2KQSGgG_!TMH z!?DZR?YzT`W>(FL1r_F+!o+yZka3ycd~*VkYLO5jAF88+uY{2H-+0glQ8agZ>G8+n zQBVyRSvBLr#pfs|%fJu=Ngc_Ou1^2!sY0sfb-EzMWGt8B|C~Pi5vW7311LA4+3%N7 z!N1cw1)vh)=_>`ZO-C}?BL5Q!Rxxi7yCsH*q(vGsQqF$R(q7_>qxh1~bWr~UOH64Y z)z%JnVg0INbC`TyKq@g8>xRv>2;(dIMwpTWlfkp%1?llXI3c9u5D7rbh}!;iY@7f8 zf~+tC?p74=v+{FPJj!rQRer|Eni-v=DA;l@<(e7UE4kZTB=VV%@pf?-BZU{1bU}`E zhE))diWaRa?#n@cCKE<1I{B6@h744D9@!5X&Am1#Mt1jNrFLEN-QXt*O(ho9rSmAa z10DaD5p9ygm^#?LUjM=Heg)puoKZ!beK^tp5%Y3340#Z;B!wymB-<+g<;d^w40DCvUpd?eY zJj2BHm{LaR!Jmb+F`Ds71ETLk1Z5o;WA8|zA+p0bLHubsUvi^GXFV|RMG>s}<~+pc zx6e#+w(`I^zvD8$VXI^jd_AijJQc?bXwhrs!_N=RdC5`nTFoR8P-ZtDCfi?H&r3ka zAzVQ~IY3uHvP)@dX6|UpcrFkbj0rO&o~uK$bb1A`Qh!-{%itPex@_&9_JY{WP~b&4 zj)rpC)V~^t&$#cOj3sRn<^>bEae>KNWXcy8XA=r!Vn~oRzl3)SFZ)c&Fluxn1)YTd=0VZA4R#;UP+hk5(&>;~<^Yb-sGX zs(gCQDn((Q(~KMm)t)RPMf;()4Yh3uY4w~Ler{6hb7xveH^^I&2~@YA4C0&|=7Q}_ zIS-7PAyJZEyRBa`4vAK<%3miY?rC16A@k9?g#?I;p8<5~IAMz~C%%yS9ehCE(Qz>y ziLBXmhQ=Rrz2Pzu4=_vpf$UJA{cI{kcp}jqA>dg^IFPD+GukreP&-+bjgS>}JKgpP zT=`#(YE1~sJlRrqf(Hlg9Tf$kr^77p=s^8Kj@hzm!tnFqMhX~~>O-;FS~X@%142h{ z0ZOLoCS<9-;AsIf_wtELeRHpQwMVz@8!dONQ*!3SbH8EDZ)ncEFvd@seABG)iWr7? zDurhFBgHoy@|=7?sY|Z3CzJ)C1DAu-ZV$U#CIa6^4LVgI~B@OiX>N=BC-vNkz7bMQnVW%16(fl3powL&IZ%o$(qt?1DBmVNjtT{F;HjTq&qA8}Gd~PE+wAY~iaR-p zf4%;Mdzv-IVAneIW!ysr0Z)S@ZH^Ly!>(dnst}8N@@K{jo}X*xv45HN?TRT?+_vB} z+Z4tcni8qN5n&)UF`*hvmct1(ut*V8RVWYNl@(@N#btg+N41=jU;aMl^g_IC-&m(l zGby|q#AL(g){#yV6gD$~f;4IsvN4pBwVY<~6(-+A%=9(?{~rCKIx3gBs44zArthUV zaey68z%)FoPScg0KuA86a*lh7sD-u%1y8K`-G7eYHg0N)tdKN}6(yG`XuUMZhNbjk z7n4Hmf%A05!zzBx4K6=6xzfU-cX7P=6)dF|QC&)~K_+?~6@{se1wlxet_~}t0ENfE z|9mi9fAjAhgVf3+xi8qFqL6X6SW3?1S@+hTZHPq)Y~IV1z|u zP?7O5^%=Eu!x9#1XxPyD2&+*CAeyOyY-G35T7^7>lBtw=*mH&y4|eR2{Tui4X+!D> zuUhfFefkBg4Dz^hlYei2IhC@7W|#WYt8I^swLz`sOoN^bpC4W4-~1w~sbV!-A9X^6 z>r6?UuTIF&uyf7tJ|CjZ|7?ZKgd7)?#*17!ojI-eMzjKE0_pSxHOL;QLw-m?7v%Fs zto&^2{bKnZi+6J(D~KjewR}ct@|NO7cAftKvs9!%VZKeBcegI$3?rLXgO&2AY@?$M zyfhkmYpCrGIR*nt{JT(pX0|!73xt;p-4x`aAQA3vKSmIi(kzt%_}m{3Kb5{=iDxg) z1_7fwD^zm;uGfC(G`RLfmY5PU7Aj+34f821M@#8otwlVy27i ze%}2o)Y(E^(7}c%Rfj!E?wBD55RDURr@(hJ(g1D$XUMs_wT@@G<5h2_@}Kb7Z;0}` z5zVbNpoWp}A)1~9In~U(R5g{p*~Rk063!6ko*TY+bxq3Ph`Lpar!V;t)xIP34CP}0 z(QF|o5)+M0+6*l~Eo4%1nHix!(@+i-pay^8@S+X>|5(-te#)k&~MZDjQ0F(#^HK zASY4GgeAxfc{iN}VVbY!-+qZ{b53D_EC__Tw$_l-jAU`UN^t{#%lz&Gb3`ScWr(Gb z0vBKDyH)e7awhX)(q%eL6LKI-k!;wVLc*hDT;>mC$MxmoL}Ep@!TLJABZq7e0EDvW zVEch3T`fe1hKu5v3)kQ4>hBqdSPfPatiTKYjAwcnEP8^pJvy*Se_cm)=FFmkDbI){ z8kKp0bVo4`5gjj{g#xts!@7iO8(H}eC*Q!2y&-}0>10ehUA6%o_wtLsW2Z)ghI-VU zJj=t_YmYLOCzM(Vz|%FKc3?Oi-lB4EfTh?`Y;q#|MJQ=hZ8DxB!f#7OePkdEKUaW^zP7Jjx)6pR(ukMN|<9p%|<7VHrI_7-rV?J zT7&B(^!#{kjc!tGHql#ioL#F#kFMu9zl=T$H1rCO!B9rZZlY)DPK21CkFd6ZOh_}d zqqh0r_tuRe^@Io!yAc=k_mpifR}YbmM4}m@WO!z~;8V`LlbJYH$Zdhoqxt_1W`VM$ z2WKFq7hH_$7^8Xa$KZ4>$9=;D;N_TMipogHNS&R84%_?wY1#?}yDV6zGm5dcq==pp z@kueARBPTc5mzpkjM(Xa?nMHRhT{9z1bvTr^VVwp8OC1`W1ImH519uJxNZ7IAzW>69scJjA zd7N=ZGF3BztIV57p*W*Y^C2%(Ji~&O{ZZH_udihKB3)*vv$^u#-0#Wlp91D z&`-ahG$YgBt(~sPkM?Dd+X&maZ3Y$Cb6{E{ad1zhY%jk&xvnOpK+Bolx_97OlX4K4 z?NFT3f@~09sC>rkz^yn+4YlKN$viRRgh%2ySNU3 z7tzHc7b8$Pd{S~+X$pjD{-AYPh^?eS*sI<#)d|m?7T3@HW^~*^9TvV?d%G{%?zqhF0O*-S<`t_sS!j&;+G<^Z)auO& z4*8`?k3by^ZBVQ`GY4FT=`g=Sg+V|7jJ;R-hB?ZQ?1}H~6Q#Xy>Z=nWGUme|JK|MG zCd!&S6xbtYYKa(ipw&Li7+LJ(!|WsY+7kIf^Fi9LKe1I=t8ifc*uSkJefXu9V#a086vZqwNL-OWb#{3)tLoE36t0Rut?$pOmgDh0QN?UCyU?@e5mu z`4|IG^*fu_90uEQbdKg?oQM>x)7AeOpU>owU~3gydf+_0+uEGniwOw`)_rhje=(FG zcxOIrQw-jMXsg4!PwQR6WEQ}OKhtGR&kjpxow|_6{sqyDM;FZXTiT8(WPcVcU>4tt z4j&qNA|{`#=2>)*MK|LFikTk>pxXl(euFwZr7^c4l+FuBDVj1R9aMFg@7Ki{v|HUU zW3eJ)b>!!L`2!MjM{}sSZT}|#V9s<$jsUF}uJiAB?t=;_k(+Q>Q9PSr!O#5$8Q$rz z*J6v2xy`FVAGH+|WSz`*c*Qw?m@wsqU)!G!g>WWwhO!c5jV)0RFP9A|a-|;BFK%+a+ph;m2DcOeq-K&Wd7?hJ@LhJ#dvcm}} zpr>j!4F59hbHRp}Q;-2tP5J(IO!H*IK!a0ub2)V-GW_7uf0sQ+&4eFzV_r>(semna zqcJL;Hrn_2_Mz^>QUve&mwWh3X?B}xfN(w;8zyq90N&L5D4b+xu!RBSQJ z?&X&sa6c_fst^BZw{6rEb|-?E|M+G9m~n$9@kY-}}JXE1MFT{3J9%;q;$ z+=oi*g-L}vtbx*Zd~bgvKtkE-FsywlgQN7mgLP32b4spuuAzESC74?d7l3pm0mBZc zAs7q|sQU)8ITQedYjd1%w)y9E{tcYr40J?^jNaMWSLqwB>31uNxj(M+ht1%W-Z`<5 zi=*Q2W*0ICxqEk;L&rSFg^J4X}Snl(I&;oz6+crHVDoI-IU zOOJ7|v`-w?_c4xkt51Bs{=}LuzV~XYz}y|x_}>1e3$>X;KJu4AaF>!A;H5;d=Hmx_Pkd`t+}bn)F3eC4w3On~LPS$A7f)N{XA|6bng$gbU6snn z_*Q2SgOu9FT(N^$n_LIC95|J^J}%wvi&J?S%@`yxMEmR)|KF{3_is`@feRh;&7X@X z!{_O37z4KMYIB7wiBTuP*>(QS*9PI7J5tYB(uF@e&sg(dsydgvlRDj#wMbemKPNf1=!j$4`=KC#Fo@LofB}|7$K~xR0?Mfsqg+AIpcZy z8j-F?U2YC1D=doV%CA#G#SZjn!(FoWWMvNkr+l$Ok^x`EVA!5SDIXqj-3pND40{Hd|TeFp848$h-Ym=5`hms{<^?o?)DJP)++tX)06otx+ z@QJyriySPhOZ%|G2H4UAYko6kRTqDUs!=Vlid<(orf9&DMW|93wcF4QRDFEFC*4erp-dh`LI|Xp-a|N>>=C54l`!bJKhT$E2Y7%2j#9`-HKFu^9OzT?GOwLsg<;-J zedHnQVq>LxgRH7&!w1!F&S|w`$F0F9W8Y~5K4anu$DE@PCm!c))PhuSdDG-s$#`hWNs(^e~dw;&BEO(8`-re z-{OVK{O0fmshr7aiCcZ*I)C_F;`k*dPA#-rPz(Py{}Wq%*rH3A)8?Ny$CDpUG`5uZ zPpqv3AQ^1@Mni7Q8<<*Vuf4#=6zmaB5${pSR%`3xu2(%~-Y ziWmZ}^Y2*F1b@V>B(;Y4IYJy1dL>qZE`F%1flw&F6$ECOcq9jDs$-%}5SM zb`*;`Qd~(_ZRm+&US|y2p*p7-u>`WpVsc^HDKnCI%~#0cyaaZfGdSp#V074-z~5)J z(57U?T#DVGyxk7I3oi53=&)m+A_X@)ITna}EvmnKjXd@{&Qrpg#~fDTRh|>S%mlJQ z>54j6_@D0v|8MAMI8W~ed#;ee`?){t@TOMjZT`*YtRxR)V|vm5Oj<1pEraRilFyAv zoG3oW69it{j#>*Z)Q}8{FE-<*MB;n<+nte_3IFss;fI~00R_o^rmSgR^?|rf7qjwx z`K?&mj@$N)Q?C91KcD}?$LSw2F;CXe|fMokR)S?<=pk?C^VemMc4^?p#bH#?Yy z(Hj^2|T|~uSb_GfJ3{<43->Dge&sJyN?tn^wit{vl@Gi z2kMTLk{1FzNTR_Gs<<{&D09)VBbkB3=RE_cy;(O|j7IxH4FwC%DE(y~OA%7zYv2cH zURPYMYwRG$w86np0fmulA+Fi)NYlH~t8hJ@ZLlA!`(9*P7aWxAMLvXa-ok8wh+ zX0_zOR!_t*vgiq!Ke5G`+7{DBi8K)qZEm%K0%jIWtu^nhn9%}tU~lsuxbL5cJa~bB-TzNk2WD*ds&`h{DE_iU3lkFq0H(C! zJiX(-PdHES*y{`D{D$ZJ8`kMUtM8cu>Lsnf8ePCNrxm{~{{wTH@!RrWcx75N-^(}7 z`3kvl${zW67--(YL$=|zed97;{lIYnq&;}%X59S}=xFY2LPiMTtC;z6vcUoXjKMJ$ zckKlel#MYNzn=K`YS5J~h!m*2SAIl_8EYgoqe^-<$gnk_2TL1F{Jv8p4&6ch$|aX-*X!<>py`pD_$1-3X#D{g#lU#~y$vHX(E`;kDsSE$yF)}f72Hq2?dp!FGBr*M~- z94`%}RmyBLfy_%9pALGyilxUs=9BX9n-hcc#PDqG8=udA0|5Sh{R>OF@B;ZC=l=uu z!tfe(6D6_AJLjt{4d8wG2QKr6WBoD#6do>$BB0xlt+XtUtEFg(!7u}O>|a>YO14vC z9>VAI-#px`b=qq|3{-Wi^3#jt3m6YQ*#Z6YtD)O+q5XWs;Kg@Kaa*y+9gp(u4z^pp zJ4IErQZYU>vk*7_wtYew$FUm(kN{bQ=s!!3NR?I5v)moB5d25h28CQq7)uD1i{3fe zo1nGmPMmXE%)pQMz4+&9yA^W7ODP-{_Q?;xY|7haLZ?$+F{O-JcBB-MIyX~{!H3n# zrl2kV3DW_hVaId9TCTXv?+z~ro>N61W5C<|n_EXnm0LUMv6uM`BQqp9n~Lj<44>8- z&eI2^N1*TtP`cU(4hz&AL?!g`&}+R~w)c$MPR2AlVM}+=r|JY{j>x%G>s;_`ZR{2Z z72Z9%S@}56@-Wr%6E%s2MmT5;b$0W`w6 z0caiWXpmyYUU#hdV$VPjBH-v+iC<`#g*XnW>ilN!TF=2E`XXH?@ z)yd~8BrH^*RA}$pQM7d7rHGJZ!Oz_25S$O)$eYHF>ikzb~!BQq5CDpil<|;mYOyo)w_jY z7s=5GOx`en4Do{F{T?xS_#O2nh(bBSvL`2dW2B3r;>X|P!FBS3CV{yljuG47IGMc( z0CX%^G*7YW{5pT&I{)UCHfhRNCkO}@$VPFUPwU};CO7@Qf7;?)EEp-y}YAy#di%e2;iT<&5_X<(?rgBO;%nPj%| zQgcTr<`{9ry%MhA8aU?Q=0Ly{Ff0l z-U$I(Y`|P8;?s;p0=fd`WgPc%F@f+@sr}Hr@map1%z06t2ciJncg7$n4gr8)yh;IN zN+@LtkMeD7Mt+`wtW+aje3?zq%UO@|B?E%TTey*{BpJQ?IYpzlB%6ybA6~G{ zutB&#-FqeOlZRBJsT_hCq>(wZ_2zi6hJ-CtujEg8{XvCOw?e8ahvP%J|3v9<3l50} z`Pp7(6Tr-l+IEjVozjfIpZ_n~qv4bpmn!A3j49OxrZ5fPGKh^69A@iiHnW;gTSN|r z*4wDdv#kY%+7RN5SBq4OgoV ziuI-9K+ePZy#(FqnI;JA^VRYr4EoQmf1=H+vFpaL2LB|%w{#kC2t1s{11#_BEly_1$ zUc`NfMu*O3Gs_%aa<}aZ^n$v9%rR!%ZeoLshIM-1)y|_EK`^2yn}vb;Rh`CEDr>HqP886Mzm+m zXS>wyh~d9bD%WFs)BWT$842q09-J{fcvXgr_rK>)pcnQ-O+zswhHz7 z?>u;^Uu&xfrhKP+@QP<)yS~>Am-&kC?Ju0Bi@{jcLu;sqSl}jh308g2UM=UanC&{N zE;NNGEjUkakf~*k6S9rGPWft>d^Qg=SvK&pf0i3$%@0HiIU<~>7*c8gxbR6&Ui{Bb zDZ2@v)Wdt-k%L@c&CxWB=w|@Nnj?efh&yw@x)^jTs4dwc$^^)6b{fTJLdDiSQ2P@J z(+>vGUU%HKFZ-Sfj#9U3Kev2y9~g~%XrLlmY3?Siy|W~C5DmbTB199Pl5*o!Xgs`I zo6~}+%~19Z9dC8O70A$W#2zR{fv~SIddwGP^#%g#IU606T6tfl*?ea+sO+? z!EDEZOlLXlOjW!_?N2*jDBu+=3jiOd-vPk7ryaFDm`E7yMpFosW){a(uwUDMaGn3a z_x2YgYyW!wX}=DAc=*r$LTk;!lo+fdjC1ZA9{bHd#L+;H3T6%3DCjy*?^ey5+iD<_ zMwf^lx-Jh5?g*8QbS@YJ<-UI+N75<3o{zyE2?>wF1*Dk>2lKy-{Y1rSj1h5f7xO(%5vY$t{Q&O&uPW?_BZ6JOA|WUE0kXC!XbqjDIl9$rj*^vD^^vX zZNaPakfr#X*uju>F&j(fPPk_u8>Rzj?d6+V)#!1UO0NB2`izRKqtx=IA_ZQ|>i*O%vZz^{rb$Q;&I}_HO0EJsZrd;9aIzW2@U5cI zE#qb4)6f%AfLqqIPS`L&@zE90TqM*zi1d&xFFprBDmcUoEI?wnsR2LPcR%4RBphZl z-MU@ci!j=DGI)}j4^gGnUC~8=lxtCDU-j-Lg|B+^qDu}7ENo`f&I@ohR|GmM5b{~` z8$9JN|yfSQo|HakbSQ6=)!R5VSCnHld@s&&_7`BS*UqCaPKW*g5=Cf>`Z4 zmUwpe)*2}FXG_T2o)kDKvQLnj|NZm_2h-E}q1b0cUz1qRH`EZ;x=3une zhjH7J3puHwAhYZ=aSfcNvt5FdcVmK1#hT+gGq0rsL#_izVC=6_`AsDuv9CjL)kk$<^X_8DH<(He%2}WR-^X-)# z4APPilLr}{4tPktkfN+-)Q!AsT@J>R4n+R_1ya|q`HIW@1}WV|k`au;j%RakwbGy1 zYr!dBATvMFRfGMX#Ez|Z6uj*6K3e6AX(rWlz@rtMr#C3pptk5DI6%6S4fDJp^Z;eS z^AKcLGK@{5T^=+dt)&`-&CaH@r|W%^(REv|SY{55HyD+>H)DQT_Zq81aIEUH&p9-A zIUewxP_^Dz*YYzRytP=IvIC1jW{*2y^CG!w44bL$=Nr4@1VtIl zX)!30@Hr{ri~qer9*}k>BU_P~<6?r%2M76K=y>L~pqREx=al9;b2}lrQJ&{554Xu0 zcBHV_;dr&l{u?H9)78sg(g~!Mo-rrJqSCr#g%qMEvr(ASY8!5`%80*=%=Lx~EEzi8 zD3(h)W3oy{M`{WQu@VP=KmF#LB*h7_7lg_KMsBP++}G)f$9~5aZAKCabF^07P^=o8 zX|Fpqidh|>yg8=&lVRfQao@izZ@{pA(B*d@YS)d?sit-reA-PKw|K8JH=Yy2!X zNX<$X$^-ZPi<`AZXKB?m5za6hm4WVe_p_1p#FEUC+aRKJnjqhsxQl;JrMFLu z<-yD6C)zYCqtmq7`-{Htw5jxGNoVE(KBWcM`45PedYymAT*(l-&Khb{$VwQi{WvtG zkk$pK&h}LYwX$PW>D*LwJr)$o@87+<)%WEZ-~F%!aEPTXKfbRBAtI!xW0Wq(#a~fy z5h1ctHrvoA@3ds0v7{^ZNqdtPBR@mSA~X!;khub}Lv}RH7)&W%AYBb?{=;r1qx7A! zO0&V>9FFWD9bW9rCZ8WEs4d`On0!01q}YA0)71sCnyCT}_wvhTMC0I3JsZQY;!&t6 z(q&Z4{{B@T$ej>rOBFND4&ms%ic}*nz9Usw`lNuzu_QB=9UKV|3`pyl5ofFQb+mwy z&P5L20Rh+3Klqu$jyhFlw3s<8?QKk4+XkgO#~DlNrWxW~`hEEWa@Y|2iC=UCpTdHG zfTy81vKiU%v|>eFhk53;L1xK&vple*Gj?-+RojfpgW!cb=6do)PYPVK7BSaK>4vO5ZTG zaWTmmfL{%z4+jAG3dO?=LkF-NWJ@D_$bn~c-GeBaB4TJ?(B_>Nb;{}jPRQY86!>=^ zvWrHW3|kiQf^>Ms6foVc8r!MZr9FFPDuq2S2{`3h5VO9oJfB({r2}mLNgt$xR@o-f zG0D@6hbA2+22-(`{(!~7BTyI|V?f4?0>W$VRBQ~UQ>Hmzs>7w1H0$O%s{y03TWm_j z>zmWtIdp#5{yRZJJpOK*6(zG55Zn`%eFJ_DiKV5+r#7Y_q{Ow{$auVMUx+c{%`#3T z@O;%f9{b7F+&rH)Ak7YQ6Z(DqfTvX4DNDYSx(S)Ds*|Qok@Q3fq3Kc_Mvoe5i=B3I*0+gKYt4QhEP+MN&FozkdftW zqs~pk=RHX{saes<;Y&e-G?#rdpRZ)>)1B7yAtPDgkTKH*8)8O9wA$S*Bc+VmR_}EA zd(LQ~qqJh0B*qH^ru?shCZoZ#4Bw)1e`x#mx}l^Op8MT8Y|gyn2?~xW zx8VUPB;~fLm#HtcSyY4$il$x$9YgcsPb*7+#JCg|8x&Pvc)MAXSF_}3mXKFbTv%9B zH7e-M+iMQ)dAlocMbH#)S`&kXWK~axhW#mAtnIa-kty$48H=Mm^1%UVKL)#pVLa^U zVm1a@=G=k&c3y-_Iz!Z2rs^dZ$4RBE>Y7w&Q?7<#i|vcWG6z~1;WDt6Rhz+MRb#?l zg^%u#yQYR}%)nLvmnxDct2a~Q&Xzi-7~eI&L-y5d?N2@c&!(Z_dyl^8h0Ch~4@fxY zcYL=`6VLHr;Jccr39*f!q2lm3C)2~A_B#nPWZL`4GAwL zAJCj_1bHP7FC)wK1NZU?*Sb}MS-T3a6VCbMGv#BlX#meNp2@@Mffw3ra4NgOQ$7LU z`M`+nn?HxhnZXHLH5t6MUbW2-pI-;Y)=Y6mLyHXH(GOsGF_cU8&4^a&G;=O4{qDBAD; zEL06^=n1f664U8X?hKmhFSCeWe8X$AtK+Pl#+qU|iDpW*cC&>`_R}_-W}ut+?tq($ zK6uJ2er*Y2?Zr4_!4X4lhCTCQ?oA9Ig@F}YCuHoDKIqA%ztHyzIXx@uMJ~q=Q~FPd zW`eN8U;}&(#9{IZ20+1oCmkpXH_`<~ebjD(%P|;liDJPNBVbUcsFN{9^Y5A1?2gz6P*-|Rq1)|IIXKRbOF_^JCUeZ$;N*s&jsM)^)}+b6;jQ42k* zI;zpzt96AG&uvEP03_VXDvC&z@Icoy_X zsGY2{Czf=@oEDV6V#CAb2ek(%^;B!4^@fymK?g6~=+j4pg4yrZshHq*hM1F^pDnV) zsm8R6&;4P-t=(``alw`K+;|feQc7inNAB>^2ri&j{uyz&WjCOfSp&;t32A$k6+wjZ zJi1qnVr=O`8DFijZ95Lk_~A}?lwXkFjSSxO{lxZoRjQtqx(1MLoJ|n+D16Y5LZ;ch zd?8iQaS0`O5REMy3eB2zJiFx{t8!HWonX3gnYP}r^_OFxM-58r4X^${Z5!rvcJ`J! zC@O?!$O2#8A`ap@kp`~wAKop<7GK@rnmPB`>J#tF9{_+y`NDPn-HL=vtQQgU#>#F< zD_S1-v;>hF=+?gDR8~Cqn=$j~L`s2V^`S2SpLMAikW1+?-vH>$c?sO~KNl(6GnyG?s-p-7VM&o) zjd3VHsuZXH<|aUPm#j8g-*B2QoC}57goTSSV=`oq!OoNOpVkKPgk8aoXjvxOOWQH5 zDooh$Lbpm=>#d~Si?^*lk@{r5UI|+jKK`^ghS@v7Y^H%^!OCTkWh)XhGx%m|MVvQ(nE8*X0H@jBqm3OeMJ9?mWFa z3>T0bhIR`i8&|~Bbg^Gvsa3O8>O6FHIG0v1TZm4yp?hgBv=0048<3(scBK~1Ky6-u z%2+HJ3`Swj8{~H{!J(=?4w4uHEB1p1xug#c(VY7ug%K1*nymS|7|V*b9&b=Uj4qoT zPneR@!m9DoXZt+SSW6fGeBR<7l;ql zSF`&e-}^GZdGeqJg*^1w{?@kRS-v5R^|6215T0`(4uLHgr!}Pb3wx!<5ta47AQp#A z6g3Q-F^v88`b5q%QULTwH4Fye9UJ2Nd2EBEM)AmBP;K%ZZ@$`A| zJro@UX6*S_c)nb@Ok>cUM*WZMeBAKdu}Ufv%Qi$-z5Sa&dz++ zas@g0#lhaE`M#*F0BQD_jrQC~bu~r2j~ND=a4_F0M6wV`gtX@HgN;k-buuIeF1YTM zbFR462cG+E9z+?6%Pc`=g}YlV=z$F%r+_IPXCckt1ulx>uBArRivT(+FHy=y*gTAR zVVe+Ap#n0otF76n$fLT?hjE$M>m{5vl58{XzW@Yv~P77z9xkNgFBZK=uwI22TLtuBM9&c3+hImHDQ z9p;J=ez;5ACtoGnTF=IuYUqXVldPt3;IqqkkwpRN%>lHJ(ShC3(NnhyDO$%i3@Nqg z1x4M6Sv%-J%ypp*3@O{A$M+JxAb*~rVaA>T1JPtvLKU=GfVYZ| z(?9&#h`BSR8M(^rlJKZt30`L1JE+trXb!2|8Ioa=nPASYIZ%Mwlx95lhporSj4I!K zkS(g|W&R*MW1Sl9Z1^5DrxTm$2(ig83+2nY^kz2U@3@yw_j6;$#4qnKS*Y0X+=vfU z+>>BJ{mAAA>|TL56GDq|IMB*@m|c@tQKawgl_`shSr*B0mHUHPNZHRg5omNN$ofbZcRx^dl{_mwpWZJSat+V&1n@wl;EOjngo~;*Fv$NAt zIYTMi_a+pgn zqt=EFWU{en!Hu4fZR2Y_l6a6AS&WX_*&WtU-NOp#1`&#t)~v9j6^9Pwujk)jTtKyC zyJ`?tMar`|KJ&umg+@xXE>z}5T=?IE!AOSjbLdLHCAu9ic$8m|ivtC^tHUH&=)!^M zA??*O-kfn)tvlj{D3pM1yJVqBj!@7l*MdBp#2#W8R%gDD6_<*oX5_<20tHy03Ibzc zW#*SnIVA;}tO7TOU;6C2pa@%H9P+Xv3ISHdWJrlR;Q=yN1RE7w^rb)Hc^2-hs+P3- zFjI?MRhZP~vV7nS;sN;v$@fa(FDWLJwjg%qJLi}k3tx;qB|NwEE0|}!;gmV6A%Fkq z*qfb)&xE$*+V}Ji;`-b`~;YDsSXysV}M3+dH$K5!GlU3WBe-piCD?}DF?h?1%aYu^)os; zuo)jd1e88GG$em7#jwhLT!Um%+@n{Rv~yWaiA{!9H!BedMBSCReA$8cauyrFSXd2W zqrER}?ttXhHB*|AszpOjD{|Z+MwhzB%lu}CK0C)bo$=fscwheTK&Z)JDp8`fUSwve zFVU%op``84c=S*hYI?1U92#oKnCAsD*PPPts0KH3=C|7ZSkY5=NS1KcZ0l?CzptVD zkC~5k1^(PB-KHxxulB_t)m%=nPBipDUQznIN`KV<7G%Z<+sEOoi3d{63C~h7PqrpE znbA(5wf_q_o_ycSrbWfLIuv#N(v|33EME9WpJy>f;)&P+pdw)y-{yES5<|0rI{%Z5 zRE5V`0n>%>=->1I;>##`tS~3kZYp&9gK~Zpw4~wCWqz{_-K-*vhCM$4tYi@Q+H!iwWiUayuFdx^2iQWu&T# zd8m!JZijFA}`XGmzN8+mRE?&TNO{D#Z?hP@WN&3}07j5+wGl?T7Fwh0Xc z9|X2S`X)CVHzfzpUrrD>3g+(nFD#8Xe`%Wuy*8(5-nLI{^UH&pbb&qhJ7~`?yP4vf z?&vTe#q(fo44Z~x`50n0i6Ei$Ne#rACs2$sNc(GDvI@I-ly5s^x$&rA4tSKi9|*#9 z*)2AQUXFvp(q5R;87Y3-p!T1hCJ0c~f0`~%31xwF@?oKjK#w^6los^uPw&R_Y@~`X zBY<$G<|(QGDGEzo^%bXN6K8I{l6Bel1ODCZkd-lE^s3WCyYNIQBo^$DZ{vHSyHufP1W zQ(Q}tAwT;eJE#>WbqK1L`g*uLbicS?Rk`*J?i*$2poFU0tHt7|6@)eBw1U~$Vd!1f zRxCDyK~aQ+nkOV~hGfv0I2kN>#`r20Q!w0u`FlN4dvel{)5r}*OJQ~>UG#n#cM37u z>eF02_?(}GU3SeCVdv#_FTXgCJ?9VKnDWG_ZAXGCpN^w&j@TV6G{( zNY~wMku%tb;YPArs9voT^Olc}4sJ`2`{C|6=x+eL65{tV@swREs+cspI8rjJK_aE? zj=zQ`SJL1In%GHFxHCT`*+rWU3vAr>r4Op!vpn2zj>a3Wl9*1uIE|X{)2hdT0?7_xegQ`q;^#F9(+@1@T~VNFQ(a|cBPu;(0cRV(^D`H zpHp@*d?pFI#|~F?E0nhSK+fzGUsavO%hwYtFm}(X&XsgIrHs@GiwREcVC8?xtHDnv zFDh6-DP#W0YBJ6^=Qk+1GvlfjKANu~*<}a@ZLI+Tt{Y?5LVZEX6VB6{ksc; z^}CMQrr42$XIo%2EaHSUUwlnTY`f;G#WXjZ&8O>G?l?^pCKCSTd2*UAko^+ZK!U`) z@^<4h+6l+S#rFMdt1&sGuVJ+yE}e<94bHR0Rs-XLB%Y{n|*|20bpm$`{EngRp+6i zb_+6!lW#adS$?@CK3}PJxuJMbE96M+e=zj4S)n1^cqrQ~kGb7l&m&8ERX%i@Es*Oi zy{tBauA(2L`dyEm>?Wl+cFgG=^azvMn6L~rKNd3^3hw0-!oX8V7Stud-l*8*N^rB( zO=^a|EmWx50X>;b&C?DOkvy7T>Wu3(?tU=8rbg8=XGg(>q5v;M!i`U2;K+99uGs6% z?NP@3;pD{_Dd2R^=6;RX_YGU*<)|PuRkAwdM4uki-Obkf?w!wGcjPFWAax)T3d?A6 zcr~d@dX}e=Jm_r~W5n0v3WnQi|m2Algk`V7P(yem4C5Jsj!?G+gllvKtWs++i}`)q)&y45b70#XaP zj3;#rt)kgOu6@U5?Q&?ENu2CJ0Gd@LFB^I(F4dz|o5E;@YTh4;;h8XIn5e@$hM$Yt zKP_@n3m1%N)99Oy4!U-Twb4TA(2@ZoKl9{=>$reP;oB?|qtMTft*aI0T%F$7B|O8|D?;1mgcI$Q0>khJmQ zZ@m)>PaWTu1J6U^0f`)srhB3Ts**pO=^!DBW*tu8!H^P4dl?C1H5%h;-RTH5JDR=u z#R=FP;s$vX6}xb{$JcU@o#*UpS8xlzPeAWnKdK0OqVp^5J@_ngB>$f3^$zCDv+&yc zj+6Y@0;#r|+2~6Ui`%$I<&$sLF`0XlUEVPU6rUT&1hG0+U3>ZAzD&q4;kn-sCNs=* zHlr|o)0niE9dr|vb;2TPN6Oi|JMJ%5*|h2>F=Ik?Iw<#&m_S4o)_kS7)x?HV$~HfJ z$CA!?q%QzhbaW$99LuVJY}Q7yJ`p@C)qVhwO}{3=p~R|Mw?a=e;}C?ZAv*wLl)~1g za_5U99GWwTI5LXh3}7(S=o&#pLo84xEq0qZ76{JOz9V7h=@*eoOTH^Yim8u_RryM? zHM(tI_I-dDU(T*$G4c+ed9hVn!DM?w28+BfH>~aIpLKYP4F=d_zvHMQW5mXcD7;)< zz_z`7W}pH4ZTsc`F4#-x5h=``(Y)0=9_8k2hhcXzXtr#Lcn}7;&%Rg(X8F%CYXI#9-uIz-JmcVa#t?* z{NKbnT#!<_0v)SSHeVRVWIIyO|K^-$O0y|>8!b=bgiz^8wbg_i76jbvStb+R0UX#3 zMhKtZ?v~K*rrZijpdlM8ria6bTClnVHFSJc&2M%ehLgkJy=sjCR#D!)f}}`_m*Zo< zo81Y!nqS+0uvL-~^mA1G(&dzP=p5YH>?19{*0jNRV80xmOflhm`y1E!!ww=2tNH%P zD$?fGI}&A?n=TnNN)m#eO$rlc%!pB3{EX-RKn^FgP6CKNGdF7YZdgny{=UKCRecIw zY}%w6j*~GZl7i(pShvf$+YV7#sa~cdLNS(%0*bVct6d7E7lSUlU-A;sDR!aTTG5P? zuFH2k?frLjJjxBHOd2>b_c#0Zt3g=B53(FG?)xv$wfYK)EX&Lxv2xEnruA@#h_ZX! z*ShFP68QzW2~?k-vM|;D<9k+=aP--XIu~VeXkD-(&o+Axw)ny+%hYwj4$*oS zls>%u^n2tuV-F)rImU!uyUl`G(GQ63gbf`5_OpAz&NHJk@)-AxZi3XVJVhLug`GS{SW&jX9D9I%78=juX_bkb_z$zrfkyW)m zlpb6LX|gG5I4%#YW|bN-bZ+?M`j*xk*7=I9uHLC|9y0kQB-1vrc>vf2q-sH}=@X0D zkVqL%)jw&O^)OIpv?_<>&;5p1ePG(j34eued~ct|AYpo$gnzQIb|F&hC}8FJsyB#Y zDQ%4oHEC9gJGCAL>fSmJS|oqg8PdqextUn*P|$CxPJ*&9Y>*fy$9G4yIp!MtQ4!B_ zGwbYc@6dFpjW3Ze_|C=P5(M$wAGpp5U#~yyvMM;?psO+bydJP(zQgRBhD@0|rt}Xy z_lLU&$i2DOpKG()Gp|iTuw`5feaES-e$lu%3yVKT6(_Y(b;5+Y#VfxQ_45dyoGidB zTID-Ox)gO$T)vih7!`&tz~XA1GqbpvaD_nA{bK(&3N zVYl`lskg%&K(j$TKkjLZp0#~)AOeXbHYuOS?E z;jG9ADkoO{JP)>#T`3J&CHG(zuF2~sPHg8U8=@drAVCn#SJkP z_%0=445Z`s2D9E6!Z|@K5)#R1EyaWhGm3@YlTNunE}LGRAE=}ObPMG#I0M)L8`Mu| z{-Wh`KZHV5V@4Y!OTXgqPgiS5gGLUA#FUa5Uo}?6%i3ZcuB_6J2T63pG5Gi8vBw9T zLoy3^)3H?e{6-?F6eb(so@}$*LDBg;ZslQ+!~;mH!xukiQZlY&9t0~2xCm<)AM!cn ze)7YsVEdui)&ZAn0a9$$o#{pF`2o~u^BHo)x#5d3(pJc>-j+XdT+G)iLC(19AXPCf z#!4v$skAOdHlNA&_LrsQNh}zDR(-X&4;tTfMXTL(AU{Qz|2^|XmpChF4vtIPa4(-0 zB=j;^Re9J8Voz2$tUe&k;ej0KQahy?eJA~PN)*&RReGYL4zZlNCKf=jA?>gb8iV86;aznhqPtgYw9#p^SFWYe4qmXJewLF#YD0j2 zCaq1f3ChM7XCpzD=kCDJk<#RBq^;5aF2;y8UP1O6pO=cFu2p3UcABMTQ@3A{O`X0@ zSIpb$BohF5)o<4xY3~TyaAjMgdG3^k0W8ctTq3?~jv4%(oJH{RkhoD=jo{rh#O$B^u zrV77UWz#e#8q~I4QSEtVgFCPD2QM(;g|uq6_PNRHhd6p^FB_i!gliNgqc%vF16A6L zOVpu$RCG#or)&{ch)-|VWlN&X^eErB%x|pRY+xlgptfoWg9CQx;2|7ZLW*bmEMg;& zC6@Ap9QvVsuD)?X2!6Rp@CV3d+APUi@dj+Urf2#tsT z5hoV}BDjGt#biW+ju?SfyH%kpYsP3cMr-52-sEm z+u9PdPFTJwza^dVXzXI-Xl%!vW8#Fy)SV9gyygMGV6CM})`}9^0MkYFYLg2y71jJA zvx_DT)-GX#FLIbrQ^u06pk;goaB>>3=3m^*CfaQkTP;rPn5^?0GXj|n3bu`QNST3T z;#zvuf`IImzqA`LlR?r$A4uVf+8(IA;92gdiJyyxh$k~bZ3wgF18q-(+m!2)ybIPL ztikic(lodFL`a0?O8a(dyBL5Hu*nYHXQ}l`YjY!9Xr8JW4pTuH0ld{GTB>*yG1aKh z7mTSOH<=5T_ChiNrS=pH${jJDO=bS_J<8AVf*5KQyRF@!nOSj#To3r?1y%AqQ);Pb z{euNrU5~fd^5f^NlXB2?i3ck>QAjr2-60mMj%apdu6jx3$ zS|L9m7WvNuRI+;4!wTet3ai-b6N|ZN$`gighaTjp+>Zmv);o6Nn4dZ|9kmQriR@J# zJ8dUu=^$z@d@;2q+S}7Ei4CDAFe;Pq$AasRp{24p^fjd!kJ4~9x+v+09I)rO*j(of zakpa}?2{#3A#*?;_M8LdaKW5b7tbj}Sqvc9!OrT0X=u;=0cFTn=apAy>~Mi^hI>~_Z0I;Je=g_f7dY~GWuUgG9 zBtX-&fPiYnzRpq)Rr2WHH0bfrRnElsY221Gb&b z4|zJP%I-p&Lcf%PMkH(*agi^~i5vJ;Z%|^P0(o?JDXLOd?piQ(hh=rzQ$;@DJaT&;iUFUZnkuLVw((}L^#8#M-*=4aVFgpQbU3KOpLZ+2*&kwU>azvJbWEz%8C_l8ncAstPO0lAx% z`!pF$!g&OT$`{0%JQjDds*8&1lVRdNaE;mq6ivY9!`!bvP2@;j&FeBxJUMhXP0(CU94w4l-^*O8m`#G(CXj<=#*>ofw&0r<|9?kw9 zS%b~j9^Vb&wwieEobnm#ba8gqNDXXO)f?1!2uSOP8FE7MJ-{!KLHJ)qtKaL6bN={m zv%O(8AM=X;kFCG`v}D=3N6|(EK_tmYk};UfqS%|o^Kd>K4)=2Z{mVW4I1ih>D5{u@ zK{ApggCK(Yq4m}y=RRk$?X_xE)f_W3UV3l6y%ckxm<__Lwb6>m1gYF(T$2>us-Y-o zq2n5?73H<#LzLF>ZksRID_iD!pnQacay&dNs3~NeIM`(b=6F!RGJIq7?;NnrkZnk= z%zzd=)GiN90yZ8Djzd+Op86VVW25OV%-TIbI*`RGFS-sB{xNQN7=Ai3hkKRkVkKVu|1insTdib#|&i3J9HV6?M+8?esf6PD4QS~R*i5=Pd zBz`UE?PLDw>3RH|r_CaU(?N_8$rwGT7lvIMzlY=vIBis)4^Wcb>6C5$%!;lxXVfz2 zp`1Z>NPi+WkqirOY2>jJng~XzAD@k%dk|0Pnh?I}cL?QO74_Wz6XpR?v}#PH>cdkS zY`#74sx~^$wl*%t(s#rjfs-9n4pQ?!k@|$K{Jy~C%?hc-P>F=vqQk4Vw1V!^508OP z7V#R8@G<{`onrpL$NWz$)7=Y+j%I`L18bIZ?G2s>;~{z3yD1WZxbBbeHp_VBw6OCP z3@Ns$qL5WE)IQ;?>^#&N(Y3guTIdz^LCZHfxN`$B)gamM?}vH&OB=V53J+a0X8emQ{SwQSdM{Az`x1p=UQm?5LxdQ1GP1r zVEaCSR9M-NXr2^9Fig1nVF1H2>D>GFyaoDL{ji(}iLZ(u61tdW@}^5#f%|iv&~5e zIjKYan18xEFlSjdbBdD{UbI7LMs`^<1&Ap|+K;4SpC=+k%j7n1wX5C7_7hp2$TCVuD z|Bta4lUd&!c%6R;|MUY3?mly@=CZ&8d{obK8nZT0d#QO~A(i8d3eFU+?iKuMR-jEz zP`IT#V&*JSj6-!y(q4TSL{0aGe?UYQFT?HGan3l57i*<2*mWkXC<|Koz%K+{0x?9C z#?GPi19Mz2LwE{&i4u$;HHEiHyF(-csExC1!g=2zPW^L0q_BN_HN=>`<#x>js=e3& zCGk>_Af~&TkprEZ)Ay#dAa%B@+5mIvHfS5kd8(8oxFO!R*=@cnXNdL#=M!f-&AzSE6L#|@J8n1A!YHv<_t4lm?tK4&K_)`vZ$59LuH-;BVb5M)K9JqcFZ>Sw!d{<<@xNUKEUI&iG+vb8NwycU7qmWnjZ$Y7 zCBA+~@d}6vQ&u}LCRa*S#It*x{IcwJkr1~YPy|2=ZzcEv(ZyrK{+=2490n(Y_XJUl z7N0Dwgis7xv1)V7L@MU=u+&UtXiSFd!ypy8IS*4vxP1oUr}z29^Y{bI(Fh&;H^Rod zZN{|gR&Bn$0IK%<>1*|{j1N;{hr^jObn0!++)^jUl*%`1GTwjPef_h5dKe7yb{I+j zjotN(clqVtGlv;5C43$K_H_)*4x#$N(Ubu(W`lxyk1A8f3gwlsvm4*TFETtp#^ix1 zefT<9rU!_x-=H8g&N~(eJ|TLbS)AN?Wx-*4l(_PJZrIKzBq-%PHCY&(T#rTeu{C4Kn6(xoEo=xi zdF~E7FRq*Sx#5fod@DA0t@t|rc0^<=?8uuTLX0W6frVamqK!J0y*_c)pX1~vT& zF{|Z7@S^Cb6)|Y^pj@Ro#teal!O>{0DYA>sl9w5}a!oxPRfxJMh%0h4-_qUv@;e&l zv}2f&uItoI(;yLHD;{&6Le5LnFJV#<1##GaV&aHBic6y9?Ut; zC_yt206qKf89ysA&eGmUm@k!}TnJ>YNCQFPurV&AQya5{dXR;%Os}ZnYBo3d-z5y5 z??FPop&>~jV^la&!4E6&)*4dEn1ht=YRfHDDTd3zq-cQbzorV2hcopUs-*R9M2w)e zq(Hgf!mrhB@Si(m_b!)&=kW#ku?goUOhsrc)Cf^P0fnKl$k<97o4Qq$AX|MZm1%2I zeMS?y3Fqo!g4Z3@>@5OdaOe<^b%SE~4oO~-Hmdb{*;mnh>vEWJSeL7>0M0o>jr%HB zHGHBGYxb=#?HjT4l7|MGgdzrZ->oxH>T3AK4L2}CEp!g#hWfcRGH>>}VXY^g$1mzX zOe~cH^DX3dtHVm0J%;4NwWAUnd>+41GjCAYGRtQ_K$v44KV&E0S!(HMQI|2VXmz+( z@?cPuBM*n0g~DhN6@x3Zp^y4M=#gHO4%qn{1lpIJGZ8y-|00961NklIw<);-gY ztN7eVU92o|wBlIx-~8ZDmSK^*o=Nik91t8S7`YkjD5ZB040zT9NDUnmY6}J@Q9mO% z?yLndR=>Q-G$QR^m9pkM3TOi0nh!x<>EabP{Mv3f(%WVmqM%2o;-@4A9R?)c3SdaU zZfq=BfVe4VuWtV#QQq_TV=183i-%qTSUj|9C@LZ?6 z+5a=@LUUEQ0RXtH=kdieDghz*xv80om~3Z#V>`bL#@kVj1JdyT*16gRqypMb4)4nO z85#=#Ga{YMu7uEM@=JQnAJ#2SK7WjAqov+WF(Ks%Te0D1V1;v{K!#mt!@o(+uPIEX z2EXK4^osfNP@+-Z)B*6&pPi*u+Kv?uv_7!5t2-_|>iOSzHiU0Cr?9_w*&y1Q+%L5N zQyES}yjzXvELMAV>?75dFS zy-f26e~~Lc^aiq;=LTD?BQt?dlv&~IFd(%r(HA7_nJcfGmtVw{NWq`8`$Zdj@WsXr z2-MEG3*XBpMs#fQ&ngJYFJ&Bzi48ndWWK0jVvGT;E5S0^pJjm{nlWLD2w=C$^yReY zH8Vegxga0TGUE(qHoTXtH))4>G2QS!zwnrUUhrlU2x7%8oi<JLAlrn(H;Z=4K<8eCw#Y5gEEc!}7MHj6m>Z z3nLs%3UQGGw(`fHo9ygmT{9fM$0aDnnM@`1bMpXC$e8^c(f{OSm%^BV$XkkRuN!39 zFWPZ1ue~V^R@aiLb5o(mxnOg+R99PY)n9k}ODOzDPox_h^-M&cUpp_w94 z2D)d9Ey;O_4X>pGDeb`27s%UQoB8@MbjSjtP>xDKlu{pT8l6!JXdaZqdxl@p|2);3 zf_294jfOo7uhkC>Yr~3ViUt~R!M{%Tlun_6QgfQJWwxG(cQ= zS#sof!<_CoeK96H<{#WR=TKM6^?=MNDrkGK;dKXMGIs=<(GVUPNs-E)mp9h${oiPv zFv~67v7KM&RtzPZ0g5@ry|G(f_U;(-Tsaft?11(l3a3(0aMlCs?ZZ6I3`*=0O!7Tb z>{h(W90w8nkV|ofe6?yn@kpOIs$h>9_x!{45v=NGv;cg}KkaY}eo)OWwjJGbi~*@n zzF)E_zB$8W@YtFkIO@4|O+x-hI%o zOQiM+)WZ&4#k0ykiZRSfzT3fAkg}qMAD9}~=iBBBwA|a8^~nMkWn?a7hwkOk~U1m)NJ&yEk-*aSF_dw)k848gOwNXM2?BPn1f& zq+!tI>TqlGV~B>EhXFhIV26y03dOiK7kRP5tX?5#=#_$uyyOu@51^ajpsMnf@0|j? z;%z$$tqzEa}i<$DV!Z$mBwi!-6>{0gm#@F!+VzK~gRp0CggK%W|Z}DJyoxi;cB3wA| z>C}gkRX^_#nJJ{{>C88G7EbIEnRM12vLv*@p<_b6gxN5!<9YlBW}p^oe5m&sZlm%o z3pGI&?MyOcwt?K2Cve8}b^J0Iq1j=5!|UWTQoLvB^bD(pQ>Pg5=lB=)`v1aSIVgY3 zpNs;q44E9hAJp22vqiT`%fa=dxLI~cdo^qEkbSdqMp2B;Dm?szY%kXQ15!C(oe~t7 zL~$0aU0y}HkY+QE>Q!}X4Y#!7d3+i3Xtkj$3!h*6|K*2=F88ZqA7CeX)B}owl^x1s z{(&|BfLw^jAuU*l^Fz)#t!Qd2R66=a{1%2?NK}Cs4c;3wuB)X8Fmx;QoMT9s3O<1g zyhtr^uf5UHa9}el`pFn~6C_3~?Z9--erA-m`#RQM)0g(mc77SG{=UFjJk*upf&iaD zV81>N?brFotoO;_8pT|Ly!}+!lm0rKyq8Jt5#9cL_DhG^?3`63gXHBFE-RxLBNRE! zpQ~Z78$#6?7O|D*I1eISgY_9yfVz|*OgOvQPqhNzW^mgH;E8}}ohrT4KIWfLP+XM5 zW^Hucq)qw`@sX(wky11J2kxzU6+akQyohS6=%E^mfLYkBQD7&BN73&z*kqMUPVnqiU+0mh5uMT zM?LVkb;F2t!{oQEThzSF|Rl-GRLeE#wulNN#Vl>Gv)!XPp_go`fS(J_Y`F$psO z928-y{AsVR(5HsjN!A#qsI+|1p47R?j zixd!8@;yM;SLlHhEKhs2BQpYD)b4oXS%s(NE_FG!fa&?L>XM4j4 zvSVmt9`g_6z(@-flnTreES5sTtNgZoJ_L;&9q}=LLKM7p`oNm+J_Mp4Ou<&9mL7vp zrI^Xuzz+wrjX3LY7d@&D@!bz|pnKw+UeaD)nCk4pEcq$D%L`{ZY%rM}TFHI(Un^}N zOrNemmx0Nbe&E1RlGpwL#q2iAtR|Bp0v&!K#aNN-(3-4eCf0gf<`KM*G~kPgKmW)4 z56CtIAZ8pQY%wZBVa7WuAB5O)v0$iMy89tQ47ZsOY(}mY;$&>6*$x@$G#>K@q~lQl zOt;T1O!%m*WWJ8Su}&YxkU5a!VV~phg+g`qaVa7qifslBI-|t`$j&~-h}0A0K71ub zO!emapVsT3zvjX6P&b(4j9VgBo71QsSt(aDiqq`KVujn=2B22aISsP-|9ow<1B+Ra z!!}xL@U=RnXmH8y2lRM#GdTJz~!J^hSsKw6fx|S0!G|3 z?dP*~j8DIycotM6s8mNqbWp2F?cZD@AwJusDX~ zgMA9_-Z(89G{tOi(hIVcrUz58VO6!wM<$p{^o<=O9K5y@*{GDmH!6iPtx*3==;T&D^wCI=J1;1DA z*#~Ah%=o$d7b(w~m&TeO%*wWlv$cwwRbIRxx(%C~S6$VEx!#Vos*2y*AHIL3*EI_L zKIi{}DAL?C4SRi}6;<)g7&R|r)JVjYFWo~V7TeiDP>Umm8lg4~0wt8n@kZ;G$aQqp zLXAUtSeXDo4aJ~TLRMR$J<7W@XB6(1fBtp+jnmcf0ng(Xe!c$}9`jEC9nV8q92~yJ zlf3>|sOh*_H*gX#~jsyNtYm(GiuhvVCrVS?IHP|Wk# zS3J)aZ0&_?F#6R84z_lcA)Z6?Zrr9FaIka@OcN+9j5w-v1U!88@Thd3HPv@U%Jnm8 zFwTl7L)2it^ikf6f zTu5nztRfnE8b7CmN%~w|P`g(xiVQ^s#_b=V*^mTaG)xp0e;PFKz`HO%n-pYLdp!90 zXLFcMWe&TzO}%b@XJ5zPc%Sq!<0ieM^usUBIW2fs&X!n_nW15qrehf8rI3xoJ`Oj+ zC0ET#Mm37C2pJrARB+Jt1)}AES@;y zWBv;t^G|3t5o3fD{ETMiv)SLowv~%h4E9kM!{9F&fF_i_d)MhXCw;{KmR7LXJW$cZ zXFW};Wn>gPd^;$vz2~2pQpQ?8AR+0TX1q=lgWCH86bZo!`<{PdD_@Al?m-%RKznO^ z?t$@3Q*+b}_xux>cwmbLE5Y$zH`=ZDiZ$P%$N(Uqm5w#v{oIh|goiH?3<_(9Yxq!R zNAz!V(srrnvt3*ZFX5nzjYJ8;lN{pDX~7OshdmjwNz_>VfByZA81p>-z*Xv%|LuAF z!8^PRhMV#G{Vzi{s&yDoyd&piI%jo`?ncSh9z5!ct^+9>jL6QPMGTAHcX=8FR4=S_A%Ut;ef0-)NN=;t6Mh51u`L2H}g9G0Jvl6 zD<1O?yRivjjRR>xNxCFXp9^6c*d_pqHx2SZf>qrnAc|5br*8{ahc;<>$=E_Wl+nWc z4$}RE9kVlGr>Uq}9bnBYZ20SkvuPMy^|nLAsK)k~UGUTz6e2|5qvD@)3=IQ92<#G~ z-sgzRj4>fuM-;7d%F2=nR8=q210VGtSSO>M;7S|leLe>* zGBjk%KA@hXx|_f_V3_qTG6C6A6qCNo7jhKDH$$!oQ<|YEfc}mLK8=pcg8~sIx|Hdj zg`(Mh&{|F4Y_9f-RvYfQc%P(*XC01iZ_&iQySWahnFFja>;MT_2@}@J4)UxN`?YRx za7%uPohSfycW&k-#r=!~d>#KXAu?STu9Wew_T^!QxHxCYlOB0 zfhi^&AUYw!3cto#$+f1$$nNI?*U9PHEM4BRNYZ*n0u=4hQ4#<9{{OMc?1rU190zN? zB4x$O$~K+D(*r{Z&Ne68hZPfLb-bI4usKUYZMZ7b;SG~~mT;tDI!7og82-)KjFJkI zRR=lTa8y>?GjM4!4T4F-!-;?IcY=Vv240$QRvs|)h#EuJYwIo14q-h0dEvRjjtOr~ zkT{E%1YbT)31Kg>A%$YX$}ztY{3WOB65iQ?kxZ_r*!1_Xp!7TYDf@J2)Zh}7!ohj<7)hS%(&=tgTdzlbLnce2o#HdwtpE$bt2%{Nd2iW?!|RI0UiSkT(Ug z&6H0;vc*1%0Z5}j=u%D!qM1u53cv=pzabwc*WXxIG8_yToxm|CF9X7@hY#sl@GX$e z=d3&4<%!x!ZfLE#jzM`c%BF9q*daKQo!VJP9*fqZ!oa8n;3a=EyZtE#Q+orYBdc)aHOuF#f>2@jGd19Fgp2sho>A*Yw zrym{nlE@wa(?(+tekN!QDI-K;=xZj^lqTS`i`SsLmSpLZj8S?5QO*oQlA#!dYMqAA zi*NrNCYFhdLb5K8I@3rb@Cq#O)nE`XDCogomQ7+k$7_q^+3Ldt` zI?No%U&$q+x+a@9uwcl(c9cS=Lm}BSKh0~2nw#dGj4mp%WGHaddtql5y?atsEEV{Q z5_Y@f?p|1MP4c4eV63f7Ew}Rv%G}`o+nlv2f(;{=FZMk#n_1`Xzb5$1-?x1obu$4l zf3_5}6Cso;N*0{C1+>#YcQELwwTNKPT#>`2$rfa2zgin})YggRiw))wkX>X{pr5{% zN*`UKtZVdc`7?=RkomriF||m<+DAk%7q8{!n9fZu8Qk}a&vLE>c#29jy=IiK7^66w z4h|!QknAZH-88tYelcpjNI@qo_wE}K#X@)4pDay+J^nhA)0VYV=%p+mO$tW-D82A|S|)MaT6t9}nuD_*WJt_}xkToxSVjT)MF zIi(faeY6G*hoj-jTloWJT2vFZx}6KU6y1pE9F?3o3=;#g+t|!0`Cybrfb3 zH`=mbVm`A`u#JJcd6)Hsb{TeG(?dnp(Eh(NO^>>vP6b=}IR#GCDMLqXlaAkm3l4X|35s5Upio7r>3VBgMNvV9qT9npr_B z*PM%$Os$Y2j=n)^Oqzjlp&d}#UF4!Pul(A_AdxTf#EccPXOCfc9UMXJBdRn!?1C9gHn{^x2F7OPQ%yBTCP>U)^9T=9| z(H48>s>(3_j6s?_J2%vJ!^iwjtBytYq(-6j?nB2E6CU#?Ugf77&xzThbtL?EDJ$nu zHbnOPn#v8DEr;U@A(2S&<)TLKC=DW#w^NR^S68~9D(2b?lDWgycH$%a#Pj%#SNY`v z$*p`jyyn^tql&*S=dN>ruy z-|QE_nm_E!6g9p1{H>#6ojy%F^hOQ3TsgzKYL?XH9(BWB&5pnG(tMTQM)+9~BP9^1 zv_?@(!(;w*b`>=uJ5ryq*DptuG@m=_h8YV2x>JiIlKnd&(3qps#Z`>O6eq0t2Ld!R zh*s^B5w(7^H=q~IJgr`p#-tpN3Ax_9ix_i?F^p3*Y{GO|6tFywLAR8*&m4%e4r>&{ zPGPK)kR09;^%77NFK=8@@G25Wf7GoCSnFtm(k~6p=#btk#dr#_sr_(P)Q5dGDNkj0P>#bqYclF(Gp7~ZS#c+% zKEEpODJ+Y|1j|^nGz8X>w1&t0iFbK9BnCSpoRnd@pIf?PnI3o^zZ`kEhQX0&5#hP! zM)y_~E~koGPJ@rA2fOMY4!fi^LrXE4(}aq`;u^2iX$h}N8nGfF*?x^E#;oIBSLAC0 z!?*ijg0(klv!QbjK3iciuv4>kz5tu|&^_R{oh`xEX2Vwgp!6BTlTQW55CnHLCMcqt zy9R&+qxTPoY7ORjDNf#XFm{0*)08r5yIJQ+QEHFv^5?UOwzd8@dYhL-I%fgrdpH-bnZ9Qkg%P`wl&sYz)YtcxfhBHJ+1gifs^L?9dgJVv;mJ^hcy0i}>i8I%RP;X|jp zrvz~79z0vPkS2J&^wdI!mb}W*3wq2Swh>osWpOq|ihNdAWwC~s+=vhK#EWmu-7f%G z^$!FrRw2myE5?8m7LMdd%pP8J6Nf&H5 znk;IX!8oLl2J0FL-6^-61HrRCA(0fn8swcs-h8%8;6$FyhTc@t-}M@V=FW2Bo&&Ox zI5cQJ>KjYGTSv>nLLG06!#SDO6Em)9k1V;m91c#QDz-a?2 z4CiPwvy2ONjB|*G`iymgLtg-7Zwbee5{bniK9ai+Y^?_y06X)LvafojaKkRUv9zXwE+$ZuJHq+j{^}%)VQeV zRnh)FH^k5RFXOatNIAKCBM*$La+Jw`2X-j>wl!rPOJuYoBs!{|#!avCkLmg$8)BG& zHYz<1X2w8Gvk?I9QN+zW`O8l+JJcd~N<~%9i7i!^?%<4?e#PI(+(;l6 z%*~vPzBeulZgf^IO4H*Z)F7TUD>o-#`hl%{2t79~q5&mPq$b=`7WWFg0n9k9vr=a& z8ey`|AIK~WI$BFeDd4D5rt6X zYhr!T2PoEv6Xyj&_%a-Rz%8OAhdSnE>S~oUb4x3Zv_a0l%yZAU=bwII-O_?K)eC#C z+j`iIWx}T|%zH|5nXP^a5`!jjgK)wVF;ILasOc~PmXyOfPyyiU_#1ouLPtRkCnV}z z^Cz6y6KEbN(VIvHN7}roNrBIN$t%i1>wm!{b6RoW4P|3jhuaQJu0uLdbMXsb0c<*y zQzzp{9TTDHhyi-S59`uTEN0&!6VrA2z%o6c*deV8_W--hHsgQnq1KygjR?Di3tUA* z(%?Q~0mJE9lv-BpF$S~Rv1GwO2u=ZNGTP*sA2Fa_9@w%#k)CTXnF2Z%jEtMbVCjTv zq1eEH$GfpL`MHd!WL+Za5FHY&$lgH#DvTSN5sn06AHpP)#AhhAmTCqU=g?1Cw|~Bwve@9neR@46ZTmuU_y$=+(Mp@staYXLB>IW+)htq`5_s4u@5l))~lnnHoJv5T2C0&Jms0HVzVmb`*) zrOJMmL#h(dfE<-gO?)#VK`QMN2MRclzEbp@^coXdPgc=n|CvNNcAJTyEQ9VZ0x+ez zRkuo}D{Y4~23nx1l2w)RVCg=j;{kG_)#^-`+6AXEiLG4TjgsaxxOT=*V@A77*;g?F-*RaD$yW2~Mb(JHb2N`Onkbsk3Y=4fw@j3s47CI-R zaJTa}mV7rD<@7{lr$D_?Ukp1)5Ke^}HDGpR5=;L-V;t zha%>5^(tm~yGA=Nqc+18&yVRiL`?sfh`irJ{= z7fTr1H?-7v!Gti7XjEPCZXFlGAk>IFqpG~4dUk~$&fZn?`>G=(i6#Qb-rb1BH=w?8 zxd%i~GAvF0at%lgQiapgj#TCxx_3AHIe4h=b@L*@!?#432|`^4oUG^l-S)ow_w)yb zfvBX5`J!AMN-x&UCDfp`{$3IKR}{nNf-zd6;eRh@6P%R^X#olE_9ARls>36JsuS#W zL++d_ly+cE52T)<+n)!mL`0gE=p~pXvoF7ZYI{h%K3?3L#+Aq@sK*P-x>MEAj>F&jW-~x%zw8oaa zno#tx3YXAU%CoN_TEa*NQH@PRr&)bIpO-bptny%iy)UsZxgUF~rpzyhkw&XowB#^8 zzd9+c6?UEWo~=`%P|Y+|RxlEd1)j$ru1TAj(mXZ$nm_A~ZUsehIQ_!@au2-Oc5(Bw zOlFA8Cz*Xs>-q4rydf(j%_HPrr3;SFSNox()#0=@QH~gUIIC zAkCW?r+TJhlj`hY<~&)jb5dF>3xR7P4*&UvBeZ6kT2ItD5&ph)vKFhs!Dl^jMiv6} z%*x+LF{K@dWKOJT6FH^tOu}mM>>zg-XLDB4G%r*Gmq(7(~9O}mf z?{h;A$}btAQnG)L+iQ&3A-mza+8hUERZN)dG^*`xzG1YpAXc5@WUM1?md$B}#JdZS zBr+Vzd_pRJ$hK(Jx%E7}W?LXn6F3$>V0l<{&yC1&!n=HV^(W;lj9D`G)nKGc8{B1F z$6SmxKT!G!>$~tinF1$~;Wd7E2on z2G2w9a@N^Y^36Wypp5FBm2{w0>TZa3L|2fXmhRYE$B6^^8g1Jvw(}3>bVusR2?fvN z*SF$@huBVrQj=&;uY_R^rvqojLvMualsONXGd*%;#p4gVVJ3|_E}+j zohG;)u~`L9y6T7nWs9h-+zo=_VWz`Q6(d#G@RpYCt$7o5;C;Su7%yDy-pe2cT4>h+ z8Qe~13DH|B`#~%wi#|h)aHt}M2{kZ;Wv`nn!C{_GToBY2n=d3^qq*1oe zZTJS)e2C5}gEU>r4Z)s8>gghMCM!=}x@Mc4eNN6!;(5`mNGb-QS3^=NWP-}#fQP=wF0__8{1TD5 zr2@dFG~4f`b2H!j1_>F@dH^$vP|}2r;(mUiP0foe7Of1klBk;ON?Hm@G_DI)_BguK z=d}2&OXsN)IQL3+SP6XBr>)mGc+_n7guN<5R|izK{OGx#sNs?@7H^KpR}k#nyBnT4TJ&lU z@(S0mogG!6Z<>%$L%lF#7}mnep#86`bOf@su0JCHJ4j6c7_L4)>H`Ge>28*}0&k0--`1TBfB_GJfwhPSWs2V(sR z=8~@(EBG&9Cd2Nk?0z1oCwyz&POZt;sfB83|!dzNc{ zKte@Q?28ZS9arz{Vr71sdWM9yF_>Tz;UXmDIU;c!lP-_{81fEUwmMk!h>-`=ox#U< zsNdbJxXpmg?4&P2mDe4+drt>6ihpgYIKgj5V&GDS$)=iLYmK9$=OU z*I<^oG4hPKnM?C<3y;ojVth8C?QFyzA{nb)a+7x>*RD!h51|~)YT>)-LD1yLHG;i2 z{>;s^COR(%OHr50Eh$vb3^gkgS5r4~1c)}pZ*(-fSvjyG2A{!2xSd}p?Zj3r+ab&* z@(Kto;wo5EC3M#4Fb6w|j)d$igJ=%|@&<~-QFaJtW=yHsVs4QAhD48Iazvv(GP8N{ zO-K&-uo|!ZL@lRxDN>g6u;Y;YeQxM@03e-F_SOTUdGqin!7qqc`HdWAOUf${p33%G zcID$>xL$mM=va;7qV6A+E3v+h{>-TCwHb3>Sn zEMWiRGtXA_ap0_61KN#8toak_;+E;o_ZlCUgP@yzdd5*#$be0klZJ3VmcQ^kegS}6 znX_YgpmYwMrGWpj`~}&rq>!-XKLbul45xaPUl4}R$4ge(J1r=kS|dUt3m)?i+@}wp zp{T0=ul4^8rTd+hh0d@jvYLM0{x^Sr$^aM4DrTB+^;>#i&7XW1>;D1fk*llVMUMo( zOm1nlY?g<;ql%UrKIVTwynl&7budl_P0^Kk=yqfnDu&%UeV7N*U^vR#PB|#3L(?j#N-v1-b3?hY z9g??FXsldQNI>9?*$s!&f|TU{O0PwV7mUpoPlyh01q6e#qE{vqXcdPS-sJ`PDJjyl z^=ekqJ8Dk@8Zx?`EKNePfmpNe+hqx2Gaa+5&(!_MN>OTQeJKMtd{JKd+h8ySyEn z{H|+hs4%frg~2%{X0SfdD`a!8*6og^y?5eVDwJmoZCr z?3IV}H8Wn7`F3WXmmT#mPq>QR%q8{pD!+{$Oc>zz``>=Cvd#a3bVZ9L@kwb+(>YUw zo5Qc{Ls1WU_;ewp8hI5+^h!!8|C|D-j{d?NZ|KhCklp!M zU(`elyAc|l4neRBPtPZ+={1Jnv^sRGJs=2I*nTu9jA+1VjH`n_Om(m(nYt&ncEyqx z9~_r{V5$mdvf11P9%g{k?94LF1~~s1#-dZArUMb*^jd`cl6PL(gF4Un_l}s`t3jlS zGa(kSlB&+xiDmuZ?rWb)cAJZpY@HQhP9=WUy5XLGput#-kRP7ne>aEA0+P)bCx?2M z{=i;ec%6UTzwD@Q?3Kh15ux5?GpCH|4ho`N@Ac)~yt-%rh>!Wh1X#3Q_?Z8J)@ip* z?3)zHs|g|>GAoc1!CKk9|?t@Kx3hq6X^E{Xc!t(qs%KWgsc9AM|LIk8!bOzo=dfD_W9^fHKJmvHBtBC5S|@mF$}1QnvcVnFr<#|bwjAC zl(|W1*FfQ>z6Nez-HL-ax|w~Nc^_vuf)ZH(aVFL+^-so|2bpq#ou61XDQ4V2Dz$u# zvgt8$kP>^WBVFW!p_pv0@ZFJFf;n}-wN<7cnl1TWpZGdv8!G?y&NJ8^+)mo6X!gVX zN8L^DhouYqaWKnEYuoyLNe|%t{%ihOE?6KOhzk9TwLMgE6ho1$KKbzle+F*zlVDB3iaSOz*Hw}XWXdg(kQ+cYm%6brRHWOpXHy5GqDEb|JAm#ExKkbJnX&}uAu%CER)O*)c^5B~h{nZfpU zPkso`sr#O4r5kc{^NU!-A4wSavo3Z(uh@!gTj)2~jqbZlcZh!9QC*iZrzb?ymfENZMxOtw)qDq2Tp1-@Z1`j~$bVr?P`a7ayC^QWzmH{RuikNI#|N{8l9O!L_bGp>CwP->t)L^Cm&ZU+0i zwIN3#Gb&g@z1bm!p;Cv>M+DI--j;Kw*(+eJT{^7Jgu6P^HkbS`cF^tzQ0>eq7ppFZ z8Am+KQ8oF`rOsdPMzD_d04q}Jl(d$|%(6LDrw&uD!==6PK9jF+DVxu_+km$EtU(lI zg@$SW0^Q?|buhC4gApn$cL?g}s?YjFT9M!tpwE^4?Pk|9E_T6V^!aLt;lM5NT}zl8 zLqJdR_Imq4uY;eTrJ@`8LqTz3S%$6|CkX%|A9X95uEhg@OUHBl`@0vA^!^KuBJf=k z4G^ta#;N0Zo0WU)eoo2KrnEQKe8=84D_%r+iT2rssy#(!Iq{O+y$h}Vur*~r!|r$q>h3-8!g( zQ@Yu#f^3!{ywnCip}1ASR{HPE8}B&I9ir;$xwT$xfOlZ8G(4-NB3Z7op11h+%%6Xw zbY_6m{$b3UaOqrzzZTt&K-k2H@L6U*UWSfXJxhAQ}=hJE=dAX&8Flss-Kmn zcIMt}Rqri{`Y6>bjPa&~w()-C#Cq0)!90Dk3y?5nPZp$Qth^K_ugcZ)>5D?R!!X^& zXEQl2)-k;eI*CTIVCQqS2(W4QC=1KFAFd1f zxpT~3jG=PV>tLq657#{BlH)RC3{#5yxFOsoh!_;cn6U^8e|o_oz8w_yqYK3`B8 zC}%l0f9G2B-HOfk`9iWaAWhR*nI)om2)kbD$VAwX7hUN)i%PRKAuatA@-gFozx&*U z%rRc_Q{{UTF+$YpvmS`Q_kUxZKJaz?;zK=W-)L*Tn&h!!J`dVfi=(VB9>5I|qrwD$ zby~j*&3Z*`97s;}hSV99Bn~_mKC9PtN_NPN%7q4rK<^iYW+57 zlf8x@9~}xY5>^v@r7BY|zw~MYX*!m^&R zfLyb60NJ~mqYa;}Db2X`yNMm;sJ!t2AsZM|$_|s!LY<7QWs+O$2U>2{9kKFW^QW_q z$e{Yf*YR%`b>=Ynds24?bhJino{Yc~DKyle!EQ5JDLa@L6Q(lbU0#rjE5PnU7X<%( zvks?OuvD>QxOicp{XijMLh8xiHJZ(?j51%WDpj|j?~_CJJP{b>T!l&TA+##)=(Cjp z)fl4=x&%n*(0|i~0qEdoo<;1*52&6dh*c+1Vn;=(B(RVTWG1TKp>c18lyF#KrmJeW zK+G3Etign$+)cFB)eAmpg@9CxtkS zKiMk)7PkH@{eo(jSto6dkfOoak}B{^R9c0uaZmEniZPhXp?lFm^I6zG(`T#oj+D}v z^EQ6($=1D63dQ8nv?8Y~2RZ)x3-J0A$tiP09&E0OG`wh%Fe1Y4FJIlD8`HH4nW0gbcJT0Y zDr)ybKbYEAn6D}(B_$G~IebHn)WL?T%h@(>imK4qK@}67@i{PIFo{EM>=Qyu#8`D{ z@-yDBSE_!W2PxsN^4luPh_B<{_&R=}v>ofDf`SJ{H3k}mS1;`Ki#my!pOqA5W}>sJ znh~pnTPLDHcOT)W(Y*-;uKCj|`N#Z;TUxQh?AT)hW1gd7%n|E!_o`GgK{AEb%lm?3 z{Zz4UkjSjIiW`!NvVy@~-Raz=?TCT1y6cxrr=uH@Qc2AjeQKoO7Fhe`<@k_Z;#JWa~+bq1ljN%Q@X4-HMn>0C3nWu=E1O z!HNi@gGw{Gvryj!z~`A_hJDYM=ln|-YYk);-E3Y0?G;Qud%Rkk1SqD#uC6$sqza)M z>D%Yyh1aM-GxCBo7NH(qxX2Bm+6+#e(3}ivOA!h!Bcsk9zjb*`53EK#4hZ<}(!t_M zX{ZgQp9500Jv)dE!J(-fCbV=z?HM2QUywd7;L8}QD@r*1YgUk&6CF>`g&;7+wEnpLg<2|FKM(^@yJck8 zhJyk4|(c~cNWC_i9KdiyF`-8z8c{Nm02B3CddWcii8WC&2@hL(7c4 zzFeKoi#Ynb*Sp}l1ae}R#(&q0rPH9XF+09mca4LJe_*dqKLEK-=Wj%j92QK8B4N&x2(R?oea{xVw3V|W zMRagqy6LjNPw#|OiF4LOtw~6CDCb;1hc2dTZjdPBf)ID3@v@_ezQ6yIHClVYUS+r5 z?NaQn^WYgm^g(M9n0#H$i7>1ndFd#q%}J0g5&(no-bkTCni;K$3Yl&ulm@>{lEr9< zOmO|&a_^wy$4L9sc}=$DlTH&xu8 z*A=1LcvKqTsiKkxk8H(-j}LZ<*&pkwci+@V1>jr#`Ob8IZL!A}Egz53W_PBIx&>NLg+pPBW94r@%- ziJ8vlj0P{6Wkc)EXV*KF%W^ijp;=ojr)5D#llknB*~Xc}UKzJ~R^XmL#|p7StlPrQ zVL}fLdyW37N!6snn8Qs`u?3F|fz@ys<^ea%J{1I2{Mlt&!}2$pEeHOde_)yJ*v>C} z%>P6VvzvWN&^M)p@86&~cAQVh{|uGu=w?DiARw9r$p{WR4St!i73C~Q^}FDx2Xacz zC|aja0AH9e>eufv88NQCw-rOLNJjE0>ve3mh&d}g1tShtEsLH<3}JvEk-5%F=-#a^&)@66}#vE42Nu%3^AYF|t%Vk#rkf9_cwpdKp+;cZ$1Q>5@gMZP#1y5>b zaZAODN?EnM{bv;o8{hoM6xIf`(#@sU=-(Dy4DeE?B%s*8i+Q^G1tVj|tI4CzHC{GU zrANz>IqTasVk-L8%}eY(yu{!L3eSv&DAo)&qbx^e$hlJ&hX&>E^XUh?L@=#2oG6Bk z!`fmCdr48>2x@6}tB~Zw6>O+}73}1|i-Jy|-w%)fWHZPHgjG)*Op#t}xCOHeU$B)w zxY{xJMb;AlE+Xk2#H$xPC7a~;nf%u{V6WymvtqAbJ^+g`*idxhVPgwV-JUqzEm#)8 zwPI@GrFUCw#EWBBBqe7%tO|+^3mH9{!)#`e2068zSnDOu_xp1c-MX=OXv2d{!*Ys} z-d@3_Jkg!NEZlQY^r#FFm5Qh>LR*v1`7dAGbS%~;3U)Y6KmuN;Hhr>6ee>#1ynl74 zqG?LdbzB^ES?~mW9WR@I6}-=vN9?}JZ^C)K;CcLpD9}pX%%*R8x6S^ZUw&BBR*?!J z+_Su_`Wu%T?3uAcJn{SeZ<~9(q1f27?s%UsY~|_da&?#P9|d-9e~y3Ck|iDHSv29+ z@8&ah*u~BcR8=qi%}(p^IowWm(NAf`yEQZv(yH^_J85MBF>Gq&qRX{*o$grj14p$i z@>ad8DxIX06ce`di5w^VT>cw_$y1So<=R^Z5@W!G8&ZrYjc}VptYU(8XqIsRxkH*B zp$MfLODq(e$LU==zoMT5(t^qVN{4yt-7n4S7g?#@FN7&g_N-^y^P7p5;h&Y4lLGD- zcqh9Zu@+^YLp_bnbK8j$hB%X%Jy+>~;;Y4^YfxyH?1lKbW-BRfE{K%lwcg`wMa(jZ zkh5Ti7?=SW8Ja$eO0J7dhMO_kW^_X`>j;L;K?muRI^;+0#I-AtXA7TEgVd*D9~|{S zj;Gm*jMh!Uzgn$z3^K-hJJU!IPX`Uk-sS0?49O26_*82@D!>5Qv9m%4_Bw|6b6SBKj72qnQ?Qd7$qIYTA2zf2 z;V_ZbloIHwt($6y=OELP5cE-Rc$Ht?CF`Qy>l4frIxp*q zYv-2kR?!|d!?@$DjGWz!eoewcHx~)muTf9N2yD*aI=cC#@$eOkDwWCRn9QeFhb6*= z=8>%p!$i%|uJH-)^NDQd80t=HZ5S@vnh^$coRA`fXIZ5)s#QVz*`&k4Nlr`cN|ld#9??k;i!NDvTGRm z*&M2ZEymFTU)WupVzYO7dbKNy_Sy?V3XY*RtGJaFPWY4zscPXnd>+zuY*4V7;DLbC zJG!lKh+ZdlQqSYJSEV9Bh|)}o^I_HXg3?v_zfAqSTTd zdk%EJi}KGr4l!6c&*sJ^<{@ofHH*`@N=v@Q=@ zcI=J<-sNQ-S-~ycIj1wfGs2N?7ExAw(qgD$u?!qSirJn=gY1Bm^K#nIUxkPu>lmst zU;`53tNg-pFs16N|H4s!SX)VNp*8=Y#YIm@K~Rn`v4#_edDIWp>S6eQ48YtMhdspm zuXP+o=Y^Rfn%`ko#(?DW6zWO6`93$q%P`Kdb5oS2n2>F1 zb{TQn94j0b!Q^4PrEE(tf12mnvqk%gQm5LV6m!BjOb$MP+`t^feFJb zlTgL4cOk{mE+cSA{i=q^%06(oz9$o4J*`a6-DDiB<HFq&t>m`i43%yHk(zW>(gfq-Z!nUi&hvf{}GanW8xNP!R^{#_H+`T;pA z6Y-GXnjVIwAH%pajM<>}ZfgxaRFu9Wc9NcWnQ}h9mEc9+oL1CyGR^Q~{-+HO$>~;7 z-0xs+qSFWN`KP~7iG;FIJBQVUXn%w@i2D|&eya87Felg#Gek=<0Me(K}p$n%OY)a2FH@Z^dRHQN>Mt>YF}XgD2HunI#&0-N0=^7v`vPH067N)?_o zF}1-e-Jxz(V%jyoVk=*WF*tim1Hoq8cy$mR6?0L-VzgF!GiKN1FoM`ZJk02?HPodH zoRTfN-kEIKVb8Q;9P*>fIQ^YUZz3u&hwx^}fWb4AaA{5pw)Vu5SE~ZEb(XX+SxlT) z8^wHrEHoH=%pZQ>F4Kys@nQ>rUG6_Q@HUlpiWAoS>7u_BGWH65%!>^gU-+1RqIPDb z#2D}~{}TY5&_IH~N_f_wH`2IuK?*LZ_V=?JJ?dfbjx1B&*z3!c_H@&o@b~_|AWtf3 zln$G75DGf5Ow=mmFgq-}oeAso@Hr0|J_)OJ;0$rz%Lt$jFJkZMNrGr?TCd-V4{2Ko|zlIYP|MGM0i zGFykPfW0ZMBt>M34aMH0?xlJjM=}vK*XG@eSq=7eDFw}Eq`T`H4V?Ziu9~&dC^Y2n z;k%X}8UPQ{JL>^V!#{)eLJuetiB>8sxQU`PTayN-<`3M`j;NO3u~LZg*Igw(XnVm# zM{Hj;^b?<&EhyW?)0CugfEC@0-a~AoOQH=lG0B@>1kBuKD>=8>a(hX;O#PDmkcKD= zfKlK$pDB3T09RC5`0z}AU*c$=wo$29Xl^7q+%yjWUtlhU4eVOM75A6f8tHMv;Z`od z%S7|B(wbkU8gB7mXjV}*C^MyZ{#`NbkbZ?Ts9?|lt6G}T4cA`T9K;wgV*ypQmb)A# zOsU#1IwOT{kVCd^E&0L2F63r#0IO3mi!|e!EDHqxv6z*G0UPSkenC1LMdfyzqp;Ep zDLPIqHeKnv9p0?!JH*$g#z+5C2XxJvP@FE)G~bT(e;xmZ)Vsgmf8#NeC6&YC!+);# z!-wcc+we#;j#|(SGY&}B9dP#H&p(c$DM!s|ZeF0}Fyo$oI_^CgMK(uXh&e1+raQil ze-V$4(V!x;zv!@Vr0&H|!UQGQT{ReUf?Z-iP_3e7L1_EipgPi_vt#X1k+9CRBJ~-u zddFMa3@OHCTQpdC$zj-Lx#&w?kxa|QwZybdu^st&Ifv7{lEvhVwcGbcwE-n(pAbHZNV82Y8%DET~N z{v3n?WzSR0U+k=JS#_mzOL;l%~)~g zbF%fyPI-YS@_HT`p3i{&w}jY%sM~H%3#utV70r4}R0>N}2*^O~I`B%~0_ul5jm4tj zbd2PycTj&IHia%9y>vY=7@n+Zf)&;HQZ=oEMqm0In!_MPJ9KBq0+*>^0VVnBy6Awp zBE=2MwBmL=2>;|_bjS_2^ntxHHEc=~<~DRMq}oQL*n9{l$|E4ysG^~J7J3RZYI{M{ zzS4MEsY4iyEUTsre+`}XDAP1(s@xE>dFsI48T_(r9cUh!^_?599EYi~ZCCXbkSrqj z1*C4B)%aXez-oA}PLip97q6_#ud^uN`r(Ea=l(#BAK2=F_xVDMbO4Qo&dqcN6(c9& zFzlDrI~}1@NDjG*O~!@aQ8h4^5YJ$`TUzm$KXIRa;7|V-<}^EN3y7$-;+C?*j5*E- zIXY$cNShs;#Wxzi=LjnszovP}gxHOY(u~yHsRhW=sV5!$phKXC{Sl1(E zyJkHkYE;)byvydZ6Rlm+bP0X(V4j>2#vGjP9hL0;uQcc@^gH=X)7C_*fI)?^8_m9c z7e}Tz;uJ)K7P%w_QrUwZ2#n%xhkpt)YA6UTLTQ@U-#43jdlY&sXs*%Q`n|g7(s+%R z?nAQ&T}lxFByKFz1FV9fpcs|s8rS;)GC`NzjO3zBb&@cy9Sr{-hMK8ECgcFxbVWIqsU=KFit!n zFH(f5aOF^6mcwKX41+@sy*P6jf*fu>dH?9LD;D%ro3-1v*~9`n>fu#Xz~;E*``oaV zr?I9gLLbbO6f_JB*2PJUJNZlG!9E7MIo?>E#e~}AI?IK-Oss5m=>WgIV$gu@N`D@C zBK$MK?HPFKvklz=oOXH0JdL&t*N_}JE{l^d@2pt4F@|6XUVXmL&4%_jKb!zsxKL~H z)9u^6qH5JWc)D%#92eI)3j}cMaRWj$g<&i&L>9 z!$AEEbGqT{_#5x@iDGj|?w9BXaR+VueV;izH@P@bWR|0e*>%HF|Mre>TpG;>s`6bL z^i){I+sEw94n*PYvg0SjG;|Q0DUN5QFe_J*w`!MMM+BAg+FOF4u4@;K8Rb%G4|XFE zS};g>><#W07B~M1iSgNVAT&EyhTE|&XYFmx*A!#S^O6N~3L@JKy_XN>tuP$xgr6%w zu@2$VK}3I!oPDwolziZ-1L;LXl3`&q8B6h~Z<{AaXOl`u4UFPkzGXglti^R!@jm^u zwrurEDB2B4>XsHp!d?drR)H{tUo@1_LDQhT-yBYiL0R*IzI9+LFRwJ97Z-;=l&sWC ze*=}Rq6SrD_UyiSDg3&lcKFNGP&L{n)C1GcGlsB(@>ebyBHV1rFU-+Go?cCkwwMn} z31YmIi6M%WByRUn2h*bUhMI_J=17K=sB|3_pS^leQt7{J1~OlMM%bd?5hE9 Aj# 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 z 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 literal 0 HcmV?d00001 diff --git a/cockatrice/themes/Leather/zones/commandzone.png b/cockatrice/themes/Leather/zones/commandzone.png new file mode 100644 index 0000000000000000000000000000000000000000..8159dfaa081bd0ec246e2a8c7b5db3bc63321b8a GIT binary patch literal 144085 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 literal 0 HcmV?d00001 diff --git a/cockatrice/themes/Plasma/zones/commandzone.png b/cockatrice/themes/Plasma/zones/commandzone.png new file mode 100644 index 0000000000000000000000000000000000000000..115a0d6134ae90edbc690943e58aeb246d53a410 GIT binary patch literal 41412 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 Z|1ZG=u3|@}1>*n!002ovPDHLkV1kqoo)G{5 literal 0 HcmV?d00001 diff --git a/doc/doxygen/groups/doc_groups.dox b/doc/doxygen/groups/doc_groups.dox index ec5158c69..d69cdc52a 100644 --- a/doc/doxygen/groups/doc_groups.dox +++ b/doc/doxygen/groups/doc_groups.dox @@ -476,8 +476,7 @@ * @ingroup GameMenus * @brief Menus for interacting with zones. * - * Provides contextual options for a CardZone such as the hand, - * library, graveyard, and battlefield. + * Provides contextual options for card zones. */ /** @@ -512,8 +511,7 @@ * @ingroup GameGraphics * @brief Graphical representations of zones. * - * Provides layout, visuals, and animations for a CardZone like the hand, - * library, battlefield, and graveyard. + * Provides layout, visuals, and animations for card zones. */ /** @@ -548,8 +546,7 @@ * @ingroup GameLogic * @brief Logical handling of CardZones during a Game. * - * Defines the rules and behaviors of zones such as the hand, - * battlefield, library, and graveyard. + * Defines the rules and behaviors of card zones. */ /** diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.cpp b/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.cpp index 493b8e966..59f64705a 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.cpp @@ -37,6 +37,7 @@ #include #include #include +#include #include #include #include @@ -342,6 +343,13 @@ Response::ResponseCode Server_AbstractParticipant::cmdDelCounter(const Command_D return Response::RespFunctionNotAllowed; } +Response::ResponseCode Server_AbstractParticipant::cmdSetCounterActive(const Command_SetCounterActive & /*cmd*/, + ResponseContainer & /*rc*/, + GameEventStorage & /*ges*/) +{ + return Response::RespFunctionNotAllowed; +} + Response::ResponseCode Server_AbstractParticipant::cmdNextTurn(const Command_NextTurn & /*cmd*/, ResponseContainer & /*rc*/, GameEventStorage & /*ges*/) @@ -525,6 +533,9 @@ Server_AbstractParticipant::processGameCommand(const GameCommand &command, Respo case GameCommand::REVERSE_TURN: return cmdReverseTurn(command.GetExtension(Command_ReverseTurn::ext), rc, ges); break; + case GameCommand::SET_COUNTER_ACTIVE: + return cmdSetCounterActive(command.GetExtension(Command_SetCounterActive::ext), rc, ges); + break; default: return Response::RespInvalidCommand; } diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.h b/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.h index a24fa5799..14de20ed0 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.h +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_abstract_participant.h @@ -41,6 +41,7 @@ class Command_Judge; class Command_IncCounter; class Command_CreateCounter; class Command_SetCounter; +class Command_SetCounterActive; class Command_DelCounter; class Command_NextTurn; class Command_SetActivePhase; @@ -161,6 +162,8 @@ public: virtual Response::ResponseCode cmdDelCounter(const Command_DelCounter &cmd, ResponseContainer &rc, GameEventStorage &ges); virtual Response::ResponseCode + cmdSetCounterActive(const Command_SetCounterActive &cmd, ResponseContainer &rc, GameEventStorage &ges); + virtual Response::ResponseCode cmdNextTurn(const Command_NextTurn &cmd, ResponseContainer &rc, GameEventStorage &ges); virtual Response::ResponseCode cmdSetActivePhase(const Command_SetActivePhase &cmd, ResponseContainer &rc, GameEventStorage &ges); diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.cpp b/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.cpp index b858314c0..8781a5788 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.cpp @@ -114,8 +114,8 @@ QString Server_Card::setAttribute(CardAttribute attribute, const QString &avalue bool Server_Card::setCounter(int _id, int value, Event_SetCardCounter *event) { - // Clamp to valid card counter range [0, MAX_COUNTERS_ON_CARD] - value = qBound(0, value, MAX_COUNTERS_ON_CARD); + // Clamp to valid card counter range [0, MAX_COUNTER_VALUE] + value = qBound(0, value, MAX_COUNTER_VALUE); const int oldValue = counters.value(_id, 0); if (value == oldValue) { @@ -140,9 +140,9 @@ bool Server_Card::incrementCounter(int counterId, int delta, Event_SetCardCounte { const int oldValue = counters.value(counterId, 0); const auto result = static_cast(oldValue) + static_cast(delta); - // Clamp to [0, MAX_COUNTERS_ON_CARD] for card counters + // Clamp to [0, MAX_COUNTER_VALUE] for card counters const int newValue = - static_cast(qBound(static_cast(0), result, static_cast(MAX_COUNTERS_ON_CARD))); + static_cast(qBound(static_cast(0), result, static_cast(MAX_COUNTER_VALUE))); if (newValue == oldValue) { return false; diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.h b/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.h index 3d7e649b9..a2698ad61 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.h +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_card.h @@ -156,7 +156,7 @@ public: /** * @brief Sets a card counter to an exact value with clamping. * @param _id The counter ID. - * @param value The desired value (clamped to [0, MAX_COUNTERS_ON_CARD]; 0 removes the counter). + * @param value The desired value (clamped to [0, MAX_COUNTER_VALUE]; 0 removes the counter). * @param event Optional event to populate with counter state. * @return true if the value changed, false otherwise. */ @@ -168,7 +168,7 @@ public: * @param event Optional event to populate with counter state. * @return true if the value changed, false otherwise. * @note If counter does not exist, starts from 0. Counter is removed if result is 0. - * @note Clamps result to [0, MAX_COUNTERS_ON_CARD]. + * @note Clamps result to [0, MAX_COUNTER_VALUE]. */ [[nodiscard]] bool incrementCounter(int counterId, int delta, Event_SetCardCounter *event = nullptr); void setTapped(bool _tapped) diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.cpp b/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.cpp index e65205cbb..01a3a910f 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.cpp @@ -1,24 +1,19 @@ #include "server_counter.h" #include -#include -Server_Counter::Server_Counter(int _id, const QString &_name, const color &_counterColor, int _radius, int _count) - : id(_id), name(_name), counterColor(_counterColor), radius(_radius), count(_count) +Server_Counter::Server_Counter(int _id, + const QString &_name, + const color &_counterColor, + int _radius, + int _count, + int _minValue, + int _maxValue) + : id(_id), name(_name), counterColor(_counterColor), radius(_radius), count(_count), minValue(_minValue), + maxValue(_maxValue) { } -//! \todo Extract overflow-safe arithmetic into shared helper. -//! Duplicated in Server_Card::incrementCounter() - keep in sync if modified. -bool Server_Counter::incrementCount(int delta) -{ - const int oldCount = count; - const auto result = static_cast(count) + static_cast(delta); - count = static_cast(qBound(static_cast(std::numeric_limits::min()), result, - static_cast(std::numeric_limits::max()))); - return count != oldCount; -} - void Server_Counter::getInfo(ServerInfo_Counter *info) { info->set_id(id); @@ -26,4 +21,5 @@ void Server_Counter::getInfo(ServerInfo_Counter *info) info->mutable_counter_color()->CopyFrom(counterColor); info->set_radius(radius); info->set_count(count); + info->set_active(active); } diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.h b/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.h index 8226e663f..490a5c725 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.h +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_counter.h @@ -22,18 +22,18 @@ #include #include +#include class ServerInfo_Counter; /** * @class Server_Counter - * @brief Represents a player counter with overflow-safe increment arithmetic. + * @brief Represents a player counter with overflow-safe increment arithmetic and optional bounds. * * All value modifications return whether the value actually changed, * enabling callers to skip unnecessary network events. * - * @note Direct assignment via setCount() does not clamp; only - * incrementCount() enforces int boundary saturation. + * @note Values are clamped to [minValue, maxValue] on both setCount() and incrementCount(). * @note Unlike card counters, player counters are never auto-removed * when they reach zero - they persist with value 0. */ @@ -45,9 +45,30 @@ protected: color counterColor; int radius; int count; + int minValue; ///< Minimum allowed value (default: INT_MIN, i.e. unbounded) + int maxValue; ///< Maximum allowed value (default: INT_MAX, i.e. unbounded) + bool active = true; ///< Whether this counter is visible/active (default: true) + + static constexpr int DEFAULT_MAX_VALUE = std::numeric_limits::max(); public: - Server_Counter(int _id, const QString &_name, const color &_counterColor, int _radius, int _count = 0); + /** + * @brief Constructs a counter. + * @param _id Unique counter identifier + * @param _name Display name + * @param _counterColor Counter color + * @param _radius Display radius + * @param _count Initial value (default 0) + * @param _minValue Minimum allowed value (default INT_MIN) + * @param _maxValue Maximum allowed value (default INT_MAX) + */ + Server_Counter(int _id, + const QString &_name, + const color &_counterColor, + int _radius, + int _count = 0, + int _minValue = std::numeric_limits::min(), + int _maxValue = DEFAULT_MAX_VALUE); ~Server_Counter() { } @@ -71,18 +92,31 @@ public: { return count; } - + bool isActive() const + { + return active; + } /** - * @brief Sets the counter to an exact value. - * @param _count The new value (assigned directly without clamping). - * @return true if the value changed, false otherwise. - * @warning This performs raw assignment. For overflow-safe incrementing, - * use incrementCount(). + * @brief Sets the active (visible) state of this counter. + * @param _active True to show the counter, false to hide it + * @return true if the state changed + */ + [[nodiscard]] bool setActive(bool _active) + { + bool oldActive = active; + active = _active; + return active != oldActive; + } + /** + * @brief Sets the counter value, clamping to [minValue, maxValue]. + * @param _count The desired new value + * @return true if the clamped value differs from the previous value + * @note For increment operations, prefer incrementCount() which handles overflow safely. */ [[nodiscard]] bool setCount(int _count) { - const int oldCount = count; - count = _count; + int oldCount = count; + count = qBound(minValue, _count, maxValue); return count != oldCount; } @@ -90,9 +124,17 @@ public: * @brief Increments the counter by delta with overflow-safe arithmetic. * @param delta The amount to add (may be negative for decrement). * @return true if the value changed, false otherwise. - * @note Clamps result to [INT_MIN, INT_MAX] to prevent overflow. + * @note Clamps result to [minValue, maxValue] to prevent overflow. */ - [[nodiscard]] bool incrementCount(int delta); + [[nodiscard]] bool incrementCount(int delta) + { + const auto result = static_cast(count) + static_cast(delta); + const int clamped = + static_cast(qBound(static_cast(minValue), result, static_cast(maxValue))); + int oldCount = count; + count = clamped; + return count != oldCount; + } /** * @brief Populates info with this counter's current state for network serialization. diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.cpp b/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.cpp index 4761199e5..f74458300 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.cpp @@ -67,6 +67,7 @@ Server_Game::Server_Game(const ServerInfo_User &_creatorInfo, bool _spectatorsSeeEverything, int _startingLifeTotal, bool _shareDecklistsOnLoad, + bool _enableCommandZone, Server_Room *_room) : QObject(), room(_room), nextPlayerId(0), hostId(0), creatorInfo(new ServerInfo_User(_creatorInfo)), gameStarted(false), gameClosed(false), gameId(_gameId), password(_password), maxPlayers(_maxPlayers), @@ -74,9 +75,9 @@ Server_Game::Server_Game(const ServerInfo_User &_creatorInfo, onlyRegistered(_onlyRegistered), spectatorsAllowed(_spectatorsAllowed), spectatorsNeedPassword(_spectatorsNeedPassword), spectatorsCanTalk(_spectatorsCanTalk), spectatorsSeeEverything(_spectatorsSeeEverything), startingLifeTotal(_startingLifeTotal), - shareDecklistsOnLoad(_shareDecklistsOnLoad), inactivityCounter(0), startTimeOfThisGame(0), secondsElapsed(0), - firstGameStarted(false), turnOrderReversed(false), startTime(QDateTime::currentDateTime()), pingClock(nullptr), - gameMutex() + shareDecklistsOnLoad(_shareDecklistsOnLoad), enableCommandZone(_enableCommandZone), inactivityCounter(0), + startTimeOfThisGame(0), secondsElapsed(0), firstGameStarted(false), turnOrderReversed(false), + startTime(QDateTime::currentDateTime()), pingClock(nullptr), gameMutex() { currentReplay = new GameReplay; currentReplay->set_replay_id(room->getServer()->getDatabaseInterface()->getNextReplayId()); diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.h b/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.h index e0e7896b7..848d22b7a 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.h +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_game.h @@ -69,6 +69,7 @@ private: bool spectatorsSeeEverything; int startingLifeTotal; bool shareDecklistsOnLoad; + bool enableCommandZone; int inactivityCounter; int startTimeOfThisGame, secondsElapsed; bool firstGameStarted; @@ -106,6 +107,7 @@ public: bool _spectatorsSeeEverything, int _startingLifeTotal, bool _shareDecklistsOnLoad, + bool _enableCommandZone, Server_Room *parent); ~Server_Game() override; Server_Room *getRoom() const @@ -173,6 +175,10 @@ public: { return shareDecklistsOnLoad; } + bool getEnableCommandZone() const + { + return enableCommandZone; + } Response::ResponseCode checkJoin(ServerInfo_User *user, const QString &_password, bool spectator, bool overrideRestrictions, bool asJudge); bool containsUser(const QString &userName) const; diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp b/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp index 56e3f9f8e..017b7e79b 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -39,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -47,6 +49,7 @@ #include #include #include +#include #include #include @@ -101,6 +104,17 @@ void Server_Player::setupZones() addCounter(new Server_Counter(6, "x", makeColor(255, 255, 255), 20, 0)); addCounter(new Server_Counter(7, "storm", makeColor(255, 150, 30), 20, 0)); + // Command zone for Commander format + if (game->getEnableCommandZone()) { + addZone(new Server_CardZone(this, ZoneNames::COMMAND, false, ServerInfo_Zone::PublicZone)); + addCounter(new Server_Counter(CounterIds::CommanderTax, CounterNames::CommanderTax, makeColor(128, 128, 128), + 20, 0, 0, MAX_COUNTER_VALUE)); + auto *partnerTax = new Server_Counter(CounterIds::PartnerTax, CounterNames::PartnerTax, + makeColor(128, 128, 128), 20, 0, 0, MAX_COUNTER_VALUE); + (void)partnerTax->setActive(false); + addCounter(partnerTax); + } + // ------------------------------------------------------------------ // Assign card ids and create deck from deck list @@ -426,6 +440,12 @@ Server_Player::cmdUndoDraw(const Command_UndoDraw & /*cmd*/, ResponseContainer & return retVal; } +bool Server_Player::isCommandZoneCounterBlocked(int counterId) const +{ + return (counterId == CounterIds::CommanderTax || counterId == CounterIds::PartnerTax) && + !game->getEnableCommandZone(); +} + Response::ResponseCode Server_Player::cmdIncCounter(const Command_IncCounter &cmd, ResponseContainer & /*rc*/, GameEventStorage &ges) { @@ -437,6 +457,11 @@ Server_Player::cmdIncCounter(const Command_IncCounter &cmd, ResponseContainer & } const int counterId = cmd.counter_id(); + + if (isCommandZoneCounterBlocked(counterId)) { + return Response::RespContextError; + } + Server_Counter *c = counters.value(counterId, nullptr); if (!c) { return Response::RespNameNotFound; @@ -490,6 +515,11 @@ Server_Player::cmdSetCounter(const Command_SetCounter &cmd, ResponseContainer & } const int counterId = cmd.counter_id(); + + if (isCommandZoneCounterBlocked(counterId)) { + return Response::RespContextError; + } + Server_Counter *c = counters.value(counterId, nullptr); if (!c) { return Response::RespNameNotFound; @@ -517,6 +547,11 @@ Server_Player::cmdDelCounter(const Command_DelCounter &cmd, ResponseContainer & } const int counterId = cmd.counter_id(); + + if (isCommandZoneCounterBlocked(counterId)) { + return Response::RespContextError; + } + Server_Counter *counter = counters.value(counterId, nullptr); if (!counter) { return Response::RespNameNotFound; @@ -531,6 +566,35 @@ Server_Player::cmdDelCounter(const Command_DelCounter &cmd, ResponseContainer & return Response::RespOk; } +Response::ResponseCode Server_Player::cmdSetCounterActive(const Command_SetCounterActive &cmd, + ResponseContainer & /*rc*/, + GameEventStorage &ges) +{ + if (!game->getGameStarted()) { + return Response::RespGameNotStarted; + } + if (conceded) { + return Response::RespContextError; + } + + const int counterId = cmd.counter_id(); + Server_Counter *c = counters.value(counterId, nullptr); + if (!c) { + return Response::RespNameNotFound; + } + + bool didChange = c->setActive(cmd.active()); + + if (didChange) { + Event_SetCounterActive event; + event.set_counter_id(c->getId()); + event.set_active(c->isActive()); + ges.enqueueGameEvent(event, playerId); + } + + return Response::RespOk; +} + Response::ResponseCode Server_Player::cmdNextTurn(const Command_NextTurn & /*cmd*/, ResponseContainer & /*rc*/, GameEventStorage & /*ges*/) { diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.h b/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.h index 5925ed3c2..eb4559631 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.h +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.h @@ -9,6 +9,7 @@ class Server_Player : public Server_AbstractPlayer private: QMap counters; QList lastDrawList; + bool isCommandZoneCounterBlocked(int counterId) const; public: Server_Player(Server_Game *_game, @@ -57,6 +58,8 @@ public: Response::ResponseCode cmdDelCounter(const Command_DelCounter &cmd, ResponseContainer &rc, GameEventStorage &ges) override; Response::ResponseCode + cmdSetCounterActive(const Command_SetCounterActive &cmd, ResponseContainer &rc, GameEventStorage &ges) override; + Response::ResponseCode cmdNextTurn(const Command_NextTurn &cmd, ResponseContainer &rc, GameEventStorage &ges) override; Response::ResponseCode cmdSetActivePhase(const Command_SetActivePhase &cmd, ResponseContainer &rc, GameEventStorage &ges) override; diff --git a/libcockatrice_network/libcockatrice/network/server/remote/server_protocolhandler.cpp b/libcockatrice_network/libcockatrice/network/server/remote/server_protocolhandler.cpp index 27ebaf228..f7af9a113 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/server_protocolhandler.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/server_protocolhandler.cpp @@ -885,10 +885,11 @@ Server_ProtocolHandler::cmdCreateGame(const Command_CreateGame &cmd, Server_Room // When server doesn't permit registered users to exist, do not honor only-reg setting bool onlyRegisteredUsers = cmd.only_registered() && (server->permitUnregisteredUsers()); - auto *game = new Server_Game(copyUserInfo(false), gameId, description, QString::fromStdString(cmd.password()), - cmd.max_players(), gameTypes, cmd.only_buddies(), onlyRegisteredUsers, - cmd.spectators_allowed(), cmd.spectators_need_password(), cmd.spectators_can_talk(), - cmd.spectators_see_everything(), startingLifeTotal, shareDecklistsOnLoad, room); + auto *game = + new Server_Game(copyUserInfo(false), gameId, description, QString::fromStdString(cmd.password()), + cmd.max_players(), gameTypes, cmd.only_buddies(), onlyRegisteredUsers, cmd.spectators_allowed(), + cmd.spectators_need_password(), cmd.spectators_can_talk(), cmd.spectators_see_everything(), + startingLifeTotal, shareDecklistsOnLoad, cmd.enable_command_zone(), room); game->addPlayer(this, rc, asSpectator, asJudge, false); room->addGame(game); diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/CMakeLists.txt b/libcockatrice_protocol/libcockatrice/protocol/pb/CMakeLists.txt index b4c7b6ac8..8769086a1 100644 --- a/libcockatrice_protocol/libcockatrice/protocol/pb/CMakeLists.txt +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/CMakeLists.txt @@ -46,6 +46,7 @@ set(PROTO_FILES command_set_card_attr.proto command_set_card_counter.proto command_set_counter.proto + command_set_counter_active.proto command_set_sideboard_lock.proto command_set_sideboard_plan.proto command_shuffle.proto @@ -106,6 +107,7 @@ set(PROTO_FILES event_set_card_attr.proto event_set_card_counter.proto event_set_counter.proto + event_set_counter_active.proto event_shuffle.proto event_user_joined.proto event_user_left.proto diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/command_set_counter_active.proto b/libcockatrice_protocol/libcockatrice/protocol/pb/command_set_counter_active.proto new file mode 100644 index 000000000..232fd69d5 --- /dev/null +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/command_set_counter_active.proto @@ -0,0 +1,9 @@ +syntax = "proto2"; +import "game_commands.proto"; +message Command_SetCounterActive { + extend GameCommand { + optional Command_SetCounterActive ext = 1035; + } + optional sint32 counter_id = 1 [default = -1]; + optional bool active = 2 [default = true]; +} diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/event_set_counter_active.proto b/libcockatrice_protocol/libcockatrice/protocol/pb/event_set_counter_active.proto new file mode 100644 index 000000000..9e674dfe3 --- /dev/null +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/event_set_counter_active.proto @@ -0,0 +1,10 @@ +syntax = "proto2"; +import "game_event.proto"; + +message Event_SetCounterActive { + extend GameEvent { + optional Event_SetCounterActive ext = 2023; + } + optional sint32 counter_id = 1; + optional bool active = 2; +} diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/game_commands.proto b/libcockatrice_protocol/libcockatrice/protocol/pb/game_commands.proto index 796f4fc68..78108e466 100644 --- a/libcockatrice_protocol/libcockatrice/protocol/pb/game_commands.proto +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/game_commands.proto @@ -38,6 +38,7 @@ message GameCommand { UNCONCEDE = 1032; JUDGE = 1033; REVERSE_TURN = 1034; + SET_COUNTER_ACTIVE = 1035; } extensions 100 to max; } diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/game_event.proto b/libcockatrice_protocol/libcockatrice/protocol/pb/game_event.proto index 7d3147701..3b829ebc6 100644 --- a/libcockatrice_protocol/libcockatrice/protocol/pb/game_event.proto +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/game_event.proto @@ -34,6 +34,7 @@ message GameEvent { CHANGE_ZONE_PROPERTIES = 2020; REVERSE_TURN = 2021; GAME_LOG_NOTICE = 2022; + SET_COUNTER_ACTIVE = 2023; } optional sint32 player_id = 1 [default = -1]; extensions 100 to max; diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/room_commands.proto b/libcockatrice_protocol/libcockatrice/protocol/pb/room_commands.proto index a8c90ec6c..0ba36fe85 100644 --- a/libcockatrice_protocol/libcockatrice/protocol/pb/room_commands.proto +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/room_commands.proto @@ -69,6 +69,9 @@ message Command_CreateGame { // share decklists with all players when selected optional bool share_decklists_on_load = 14; + + // enable command zone for Commander format + optional bool enable_command_zone = 15; } message Command_JoinGame { diff --git a/libcockatrice_protocol/libcockatrice/protocol/pb/serverinfo_counter.proto b/libcockatrice_protocol/libcockatrice/protocol/pb/serverinfo_counter.proto index 849e3b4e9..af56efe13 100644 --- a/libcockatrice_protocol/libcockatrice/protocol/pb/serverinfo_counter.proto +++ b/libcockatrice_protocol/libcockatrice/protocol/pb/serverinfo_counter.proto @@ -7,4 +7,5 @@ message ServerInfo_Counter { optional color counter_color = 3; optional sint32 radius = 4; optional sint32 count = 5; + optional bool active = 6 [default = true]; } diff --git a/libcockatrice_utility/CMakeLists.txt b/libcockatrice_utility/CMakeLists.txt index c0c7d8cc9..910077147 100644 --- a/libcockatrice_utility/CMakeLists.txt +++ b/libcockatrice_utility/CMakeLists.txt @@ -15,6 +15,7 @@ set(UTILITY_HEADERS libcockatrice/utility/levenshtein.h libcockatrice/utility/macros.h libcockatrice/utility/passwordhasher.h + libcockatrice/utility/counter_ids.h libcockatrice/utility/trice_limits.h libcockatrice/utility/zone_names.h ) diff --git a/libcockatrice_utility/libcockatrice/utility/counter_ids.h b/libcockatrice_utility/libcockatrice/utility/counter_ids.h new file mode 100644 index 000000000..6745f4487 --- /dev/null +++ b/libcockatrice_utility/libcockatrice/utility/counter_ids.h @@ -0,0 +1,46 @@ +/** + * @file counter_ids.h + * @ingroup GameLogic + * @brief Shared counter IDs and names for system counters (e.g. commander tax). + */ + +#ifndef COCKATRICE_COUNTER_IDS_H +#define COCKATRICE_COUNTER_IDS_H + +#include + +/** + * Shared counter IDs used by both client and server. + * These must match between server_player.cpp and player_event_handler.cpp. + * + * Reserved counter IDs for system counters: + * IDs 0-7: Standard player counters (life, mana colors, storm) + * IDs 8-9: Commander tax counters + * IDs 10+: Available for user-created counters + * + * The server's newCounterId() starts from the highest existing ID + 1, + * so these reserved IDs won't conflict as long as they're created first + * during setupZones(). See server_player.cpp::setupZones() for the + * authoritative list of reserved IDs. + * + * To find all files referencing these IDs, grep for CounterIds::CommanderTax + * and CounterIds::PartnerTax across the codebase. + */ +namespace CounterIds +{ +constexpr int CommanderTax = 8; +constexpr int PartnerTax = 9; +} // namespace CounterIds + +namespace CounterNames +{ +constexpr const char *CommanderTax = "commander_tax_counter"; +constexpr const char *PartnerTax = "partner_tax_counter"; + +inline bool isTaxCounter(const QString &name) +{ + return name == CommanderTax || name == PartnerTax; +} +} // namespace CounterNames + +#endif // COCKATRICE_COUNTER_IDS_H diff --git a/libcockatrice_utility/libcockatrice/utility/trice_limits.h b/libcockatrice_utility/libcockatrice/utility/trice_limits.h index 833ce1b98..4b35a546e 100644 --- a/libcockatrice_utility/libcockatrice/utility/trice_limits.h +++ b/libcockatrice_utility/libcockatrice/utility/trice_limits.h @@ -15,11 +15,11 @@ constexpr uint MAXIMUM_DIE_SIDES = 1000000; constexpr uint MINIMUM_DICE_TO_ROLL = 1; constexpr uint MAXIMUM_DICE_TO_ROLL = 100; -// Card counter value bounds [0, MAX_COUNTERS_ON_CARD]. -// Counters on cards (e.g., +1/+1 counters, charge counters) are non-negative physical game objects. +// Counter value bounds [0, MAX_COUNTER_VALUE]. +// Counters (on cards or players) are non-negative values. // The max of 999 is a display constraint (3-digit rendering) and reasonable gameplay limit. // Server enforces these bounds; client may also check for UX optimization. -constexpr int MAX_COUNTERS_ON_CARD = 999; +constexpr int MAX_COUNTER_VALUE = 999; // optimized functions to get qstrings that are at most that long static inline QString nameFromStdString(const std::string &_string) diff --git a/libcockatrice_utility/libcockatrice/utility/zone_names.h b/libcockatrice_utility/libcockatrice/utility/zone_names.h index d1463de6a..0388cdf71 100644 --- a/libcockatrice_utility/libcockatrice/utility/zone_names.h +++ b/libcockatrice_utility/libcockatrice/utility/zone_names.h @@ -14,6 +14,9 @@ constexpr const char *DECK = "deck"; constexpr const char *SIDEBOARD = "sb"; constexpr const char *STACK = "stack"; +// Command zone (Commander format) +constexpr const char *COMMAND = "command"; + } // namespace ZoneNames #endif // ZONE_NAMES_H diff --git a/tests/movecard_tests/reverse_card_move_test.cpp b/tests/movecard_tests/reverse_card_move_test.cpp index 2231a7e3b..aa0de591f 100644 --- a/tests/movecard_tests/reverse_card_move_test.cpp +++ b/tests/movecard_tests/reverse_card_move_test.cpp @@ -22,7 +22,8 @@ TEST(ReverseCardMoveTest, MoveCardFromBottomTest) // instantiate a fake server instance FakeServer server; Server_Room room(0, 0, "", "", "", "", false, "", {}, &server); - Server_Game game(user, 1, "", "", 2, QList(), false, false, false, false, false, false, 20, false, &room); + Server_Game game(user, 1, "", "", 2, QList(), false, false, false, false, false, false, 20, false, false, + &room); Server_AbstractPlayer player(&game, 1, user, false, nullptr); Server_CardZone deckZone(&player, ZoneNames::DECK, true, ServerInfo_Zone::PublicZone); Server_CardZone exileZone(&player, ZoneNames::EXILE, true, ServerInfo_Zone::PublicZone); diff --git a/tests/server_card_counter_test.cpp b/tests/server_card_counter_test.cpp index ff906b906..b6aacc31b 100644 --- a/tests/server_card_counter_test.cpp +++ b/tests/server_card_counter_test.cpp @@ -28,9 +28,9 @@ TEST(ServerCardCounter, IncrementExistingCounter) TEST(ServerCardCounter, IncrementOverflowProtection) { Server_Card card(CardRef{"TestCard", ""}, 1, 0, 0); - ASSERT_TRUE(card.setCounter(1, MAX_COUNTERS_ON_CARD)); + ASSERT_TRUE(card.setCounter(1, MAX_COUNTER_VALUE)); EXPECT_FALSE(card.incrementCounter(1, 1)); - EXPECT_EQ(card.getCounter(1), MAX_COUNTERS_ON_CARD); + EXPECT_EQ(card.getCounter(1), MAX_COUNTER_VALUE); } TEST(ServerCardCounter, DecrementUnderflowProtection) @@ -113,13 +113,13 @@ TEST(ServerCardCounter, IncrementCounterPopulatesEvent) TEST(ServerCardCounter, IncrementCounterEventReflectsClampedValue) { Server_Card card(CardRef{"TestCard", ""}, 1, 0, 0); - ASSERT_TRUE(card.setCounter(1, MAX_COUNTERS_ON_CARD - 5)); + ASSERT_TRUE(card.setCounter(1, MAX_COUNTER_VALUE - 5)); Event_SetCardCounter event; EXPECT_TRUE(card.incrementCounter(1, 10, &event)); EXPECT_EQ(event.counter_id(), 1); - EXPECT_EQ(event.counter_value(), MAX_COUNTERS_ON_CARD); + EXPECT_EQ(event.counter_value(), MAX_COUNTER_VALUE); } TEST(ServerCardCounter, IncrementCounterNoEventWhenNullptr) @@ -133,7 +133,7 @@ TEST(ServerCardCounter, IncrementCounterNoEventWhenNullptr) TEST(ServerCardCounter, IncrementCounterEventNotPopulatedWhenUnchanged) { Server_Card card(CardRef{"TestCard", ""}, 1, 0, 0); - ASSERT_TRUE(card.setCounter(1, MAX_COUNTERS_ON_CARD)); + ASSERT_TRUE(card.setCounter(1, MAX_COUNTER_VALUE)); Event_SetCardCounter event; event.set_counter_id(999); @@ -156,7 +156,7 @@ TEST(ServerCardCounter, SetCounterClampsAboveMaxToMax) { Server_Card card(CardRef{"TestCard", ""}, 1, 0, 0); EXPECT_TRUE(card.setCounter(1, 1500)); - EXPECT_EQ(card.getCounter(1), MAX_COUNTERS_ON_CARD); + EXPECT_EQ(card.getCounter(1), MAX_COUNTER_VALUE); } TEST(ServerCardCounter, IncrementDoesNotGoBelowZero) @@ -171,9 +171,9 @@ TEST(ServerCardCounter, IncrementDoesNotGoBelowZero) TEST(ServerCardCounter, IncrementDoesNotExceedMax) { Server_Card card(CardRef{"TestCard", ""}, 1, 0, 0); - ASSERT_TRUE(card.setCounter(1, MAX_COUNTERS_ON_CARD - 5)); + ASSERT_TRUE(card.setCounter(1, MAX_COUNTER_VALUE - 5)); EXPECT_TRUE(card.incrementCounter(1, 10)); - EXPECT_EQ(card.getCounter(1), MAX_COUNTERS_ON_CARD); + EXPECT_EQ(card.getCounter(1), MAX_COUNTER_VALUE); } int main(int argc, char **argv) diff --git a/tests/server_counter_test.cpp b/tests/server_counter_test.cpp index 0f41f2cbd..1f3c20154 100644 --- a/tests/server_counter_test.cpp +++ b/tests/server_counter_test.cpp @@ -5,6 +5,7 @@ #include #include +#include #include TEST(ServerCounter, IncrementDoesNotOverflow) @@ -79,6 +80,37 @@ TEST(ServerCounter, MixedExtremesDoNotClamp) EXPECT_EQ(c.getCount(), -1); } +TEST(ServerCounter, SetCountClampsToCustomBounds) +{ + Server_Counter c(1, "test", color(), 10, 50, 0, 100); + EXPECT_TRUE(c.setCount(150)); + EXPECT_EQ(c.getCount(), 100); + EXPECT_TRUE(c.setCount(-10)); + EXPECT_EQ(c.getCount(), 0); +} + +TEST(ServerCounter, IncrementClampsToCustomBounds) +{ + Server_Counter c(1, "test", color(), 10, 50, 0, 100); + EXPECT_TRUE(c.incrementCount(100)); + EXPECT_EQ(c.getCount(), 100); + EXPECT_FALSE(c.incrementCount(1)); + EXPECT_EQ(c.getCount(), 100); + EXPECT_TRUE(c.incrementCount(-200)); + EXPECT_EQ(c.getCount(), 0); + EXPECT_FALSE(c.incrementCount(-1)); + EXPECT_EQ(c.getCount(), 0); +} + +TEST(ServerCounter, CustomBoundsForCommanderTax) +{ + Server_Counter taxCounter(1, "tax", color(), 20, 0, 0, MAX_COUNTER_VALUE); + EXPECT_TRUE(taxCounter.setCount(1000)); + EXPECT_EQ(taxCounter.getCount(), MAX_COUNTER_VALUE); + EXPECT_TRUE(taxCounter.setCount(-5)); + EXPECT_EQ(taxCounter.getCount(), 0); +} + int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); From 8ca693ef701f18da93414cf36ca925dab6d6c1d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20Br=C3=BCbach?= Date: Tue, 9 Jun 2026 09:26:53 +0200 Subject: [PATCH 2/4] Adjust to rebase. Took 28 minutes Took 7 seconds Took 2 minutes Took 8 minutes Took 13 seconds --- cockatrice/CMakeLists.txt | 4 ++-- cockatrice/src/game/player/player_actions.cpp | 16 +++++++--------- cockatrice/src/game/player/player_actions.h | 10 +++++++--- .../src/game/player/player_event_handler.cpp | 6 +++--- cockatrice/src/game/player/player_logic.cpp | 10 +++++----- cockatrice/src/game/player/player_logic.h | 1 + cockatrice/src/game/zones/command_zone_logic.cpp | 2 +- .../board/commander_tax_counter.cpp | 2 +- .../board/commander_tax_counter.h | 0 .../src/game_graphics/player/menu/card_menu.cpp | 8 ++------ .../player/menu/command_zone_menu.cpp | 11 ++++++----- .../game_graphics/player/menu/player_menu.cpp | 5 +++-- .../src/game_graphics/player/menu/player_menu.h | 2 +- .../player/player_graphics_item.cpp | 6 +++--- .../zones/command_zone.cpp | 11 ++++++----- .../{game => game_graphics}/zones/command_zone.h | 4 ++-- 16 files changed, 50 insertions(+), 48 deletions(-) rename cockatrice/src/{game => game_graphics}/board/commander_tax_counter.cpp (97%) rename cockatrice/src/{game => game_graphics}/board/commander_tax_counter.h (100%) rename cockatrice/src/{game => game_graphics}/zones/command_zone.cpp (96%) rename cockatrice/src/{game => game_graphics}/zones/command_zone.h (97%) diff --git a/cockatrice/CMakeLists.txt b/cockatrice/CMakeLists.txt index 649cd49cd..608ac7a6a 100644 --- a/cockatrice/CMakeLists.txt +++ b/cockatrice/CMakeLists.txt @@ -87,7 +87,7 @@ set(cockatrice_SOURCES src/game_graphics/log/message_log_widget.cpp src/game/phase.cpp src/game_graphics/phases_toolbar.cpp - src/game_graphics/player/menu/card_menu. + src/game_graphics/player/menu/card_menu.cpp src/game_graphics/player/menu/command_zone_menu.cpp src/game_graphics/player/menu/custom_zone_menu.cpp src/game_graphics/player/menu/grave_menu.cpp @@ -112,7 +112,7 @@ set(cockatrice_SOURCES src/game_graphics/player/player_target.cpp src/game/replay.cpp src/game/zones/card_zone_logic.cpp - src/game/zones/command_zone.cpp + src/game_graphics/zones/command_zone.cpp src/game/zones/command_zone_logic.cpp src/game/zones/hand_zone_logic.cpp src/game/zones/pile_zone_logic.cpp diff --git a/cockatrice/src/game/player/player_actions.cpp b/cockatrice/src/game/player/player_actions.cpp index 3fc3e3ef7..1021629cc 100644 --- a/cockatrice/src/game/player/player_actions.cpp +++ b/cockatrice/src/game/player/player_actions.cpp @@ -7,7 +7,6 @@ #include "../../game_graphics/zones/table_zone.h" #include "../../interface/widgets/tabs/tab_game.h" #include "../../interface/widgets/utility/get_text_with_max.h" - #include "../zones/view_zone_logic.h" #include @@ -1627,14 +1626,13 @@ static bool isUnwritableRevealZone(CardZoneLogic *zone) void PlayerActions::playSelectedCards(QList selectedCards, const bool faceDown) { - playSelectedCardsImpl(faceDown, nullptr); + playSelectedCardsImpl(selectedCards, faceDown, nullptr); } -void PlayerActions::playSelectedCardsImpl(bool faceDown, +void PlayerActions::playSelectedCardsImpl(QList selectedCards, + bool faceDown, const std::function &postPlayCallback) { - QList selectedCards = player->getGameScene()->selectedCards(); - // CardIds will get shuffled downwards when cards leave the deck. // We need to iterate through the cards in reverse order so cardIds don't get changed out from under us as we play // out the cards one-by-one. @@ -1652,9 +1650,9 @@ void PlayerActions::playSelectedCardsImpl(bool faceDown, } } -void PlayerActions::actPlayAndIncreaseTax() +void PlayerActions::actPlayAndIncreaseTax(QList selectedCards) { - playSelectedCardsImpl(false, [this](CardItem * /*card*/, const QString &originalZone) { + playSelectedCardsImpl(selectedCards, false, [this](CardItem * /*card*/, const QString &originalZone) { if (originalZone == ZoneNames::COMMAND) { AbstractCounter *ctr = player->getCounterWidget(CounterIds::CommanderTax); if (ctr && ctr->isActive()) { @@ -1664,9 +1662,9 @@ void PlayerActions::actPlayAndIncreaseTax() }); } -void PlayerActions::actPlayAndIncreasePartnerTax() +void PlayerActions::actPlayAndIncreasePartnerTax(QList selectedCards) { - playSelectedCardsImpl(false, [this](CardItem * /*card*/, const QString &originalZone) { + playSelectedCardsImpl(selectedCards, false, [this](CardItem * /*card*/, const QString &originalZone) { if (originalZone == ZoneNames::COMMAND) { AbstractCounter *ctr = player->getCounterWidget(CounterIds::PartnerTax); if (ctr && ctr->isActive()) { diff --git a/cockatrice/src/game/player/player_actions.h b/cockatrice/src/game/player/player_actions.h index 3c552f509..c8ef1d359 100644 --- a/cockatrice/src/game/player/player_actions.h +++ b/cockatrice/src/game/player/player_actions.h @@ -128,9 +128,9 @@ public slots: void actPlay(QList selectedCards); void actPlayFacedown(QList selectedCards); /** @brief Plays the selected card and increments the primary commander tax counter. */ - void actPlayAndIncreaseTax(); + void actPlayAndIncreaseTax(QList selectedCards); /** @brief Plays the selected card and increments the partner commander tax counter. */ - void actPlayAndIncreasePartnerTax(); + void actPlayAndIncreasePartnerTax(QList selectedCards); /** @brief Modifies a tax counter by delta if it is active. */ void actModifyTaxCounter(int counterId, int delta); /** @brief Toggles a tax counter's active state (only if inactive or value is 0). */ @@ -257,10 +257,14 @@ private: /** * @brief Shared implementation for playing selected cards with an optional post-play callback. + * @param selectedCards + * @param selectedCards + * @param selectedCards * @param postPlayCallback Called after each card is played, receiving the card and its *original* zone name * (captured before playCard, since playCard sends a move command that may change the card's zone). */ - void playSelectedCardsImpl(bool faceDown, + void playSelectedCardsImpl(QList selectedCards, + bool faceDown, const std::function &postPlayCallback = nullptr); void cmdSetTopCard(Command_MoveCard &cmd); diff --git a/cockatrice/src/game/player/player_event_handler.cpp b/cockatrice/src/game/player/player_event_handler.cpp index 6900e2c16..9f9aca671 100644 --- a/cockatrice/src/game/player/player_event_handler.cpp +++ b/cockatrice/src/game/player/player_event_handler.cpp @@ -4,7 +4,6 @@ #include "../../game_graphics/board/card_item.h" #include "../../game_graphics/zones/view_zone.h" #include "../../interface/widgets/tabs/tab_game.h" -#include "../board/abstract_counter.h" #include "../board/arrow_data.h" #include "../board/card_list.h" #include "player_actions.h" @@ -287,11 +286,12 @@ void PlayerEventHandler::eventSetCounterActive(const Event_SetCounterActive &eve } state->setActive(event.active()); - AbstractCounter *widget = player->getGraphicsItem()->getCounterWidget(event.counter_id()); + // TODO: The counters data should emit this and the widget hook up to it. Don't reach into graphics like this. + /*AbstractCounter *widget = player->getGraphicsItem()->getCounterWidget(event.counter_id()); if (widget) { widget->setActive(event.active()); emit player->rearrangeCounters(); - } + }*/ } void PlayerEventHandler::eventDelCounter(const Event_DelCounter &event) diff --git a/cockatrice/src/game/player/player_logic.cpp b/cockatrice/src/game/player/player_logic.cpp index 35b197763..84180a2f5 100644 --- a/cockatrice/src/game/player/player_logic.cpp +++ b/cockatrice/src/game/player/player_logic.cpp @@ -2,9 +2,11 @@ #include "../../game_graphics/board/arrow_item.h" #include "../../game_graphics/board/card_item.h" +#include "../../game_graphics/board/commander_tax_counter.h" #include "../../game_graphics/board/counter_general.h" #include "../../game_graphics/game_scene.h" #include "../../game_graphics/player/player_target.h" +#include "../../game_graphics/zones/command_zone.h" #include "../../game_graphics/zones/hand_zone.h" #include "../../game_graphics/zones/pile_zone.h" #include "../../game_graphics/zones/stack_zone.h" @@ -12,10 +14,6 @@ #include "../../interface/theme_manager.h" #include "../../interface/widgets/tabs/tab_game.h" #include "../board/card_list.h" -#include "../board/commander_tax_counter.h" -#include "../board/counter_general.h" -#include "../game_scene.h" -#include "../zones/command_zone.h" #include "player_actions.h" #include @@ -320,7 +318,9 @@ CounterState *PlayerLogic::getLifeCounter() const AbstractCounter *PlayerLogic::getCounterWidget(int counterId) const { - return graphicsItem->getCounterWidget(counterId); + Q_UNUSED(counterId); + return nullptr; + // TODO: Do not reach into graphics like this return graphicsItem->getCounterWidget(counterId); } bool PlayerLogic::clearCardsToDelete() diff --git a/cockatrice/src/game/player/player_logic.h b/cockatrice/src/game/player/player_logic.h index 4bb22f80c..b530d96bd 100644 --- a/cockatrice/src/game/player/player_logic.h +++ b/cockatrice/src/game/player/player_logic.h @@ -26,6 +26,7 @@ #include #include #include +#include #include inline Q_LOGGING_CATEGORY(PlayerLog, "player"); diff --git a/cockatrice/src/game/zones/command_zone_logic.cpp b/cockatrice/src/game/zones/command_zone_logic.cpp index 3e97ece41..687ee49d1 100644 --- a/cockatrice/src/game/zones/command_zone_logic.cpp +++ b/cockatrice/src/game/zones/command_zone_logic.cpp @@ -1,6 +1,6 @@ #include "command_zone_logic.h" -#include "../board/card_item.h" +#include "../../game_graphics/board/card_item.h" #include "card_zone_algorithms.h" CommandZoneLogic::CommandZoneLogic(PlayerLogic *_player, diff --git a/cockatrice/src/game/board/commander_tax_counter.cpp b/cockatrice/src/game_graphics/board/commander_tax_counter.cpp similarity index 97% rename from cockatrice/src/game/board/commander_tax_counter.cpp rename to cockatrice/src/game_graphics/board/commander_tax_counter.cpp index d0ae0ad5c..d3cd83a6c 100644 --- a/cockatrice/src/game/board/commander_tax_counter.cpp +++ b/cockatrice/src/game_graphics/board/commander_tax_counter.cpp @@ -1,6 +1,6 @@ #include "commander_tax_counter.h" -#include "counter_state.h" +#include "../../game/board/counter_state.h" #include "translate_counter_name.h" #include diff --git a/cockatrice/src/game/board/commander_tax_counter.h b/cockatrice/src/game_graphics/board/commander_tax_counter.h similarity index 100% rename from cockatrice/src/game/board/commander_tax_counter.h rename to cockatrice/src/game_graphics/board/commander_tax_counter.h diff --git a/cockatrice/src/game_graphics/player/menu/card_menu.cpp b/cockatrice/src/game_graphics/player/menu/card_menu.cpp index cac772023..67c5ad716 100644 --- a/cockatrice/src/game_graphics/player/menu/card_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/card_menu.cpp @@ -83,6 +83,8 @@ CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _sho aUnattach = makeAction(this, [actions, sel]() { actions->actUnattach(sel()); }); aSetAnnotation = makeAction(this, [actions, sel]() { actions->actRequestSetAnnotationDialog(sel()); }); aPlay = makeAction(this, [actions, sel]() { actions->actPlay(sel()); }); + aPlayAndIncreaseTax = makeAction(this, [actions, sel]() { actions->actPlayAndIncreaseTax(sel()); }); + aPlayAndIncreasePartnerTax = makeAction(this, [actions, sel]() { actions->actPlayAndIncreasePartnerTax(sel()); }); aPlayFacedown = makeAction(this, [actions, sel]() { actions->actPlayFacedown(sel()); }); aHide = makeAction(this, [actions, sel]() { actions->actHide(sel()); }); aReduceLifeByPower = makeAction(this, [actions, sel]() { actions->actReduceLifeByPower(sel()); }); @@ -94,12 +96,6 @@ CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _sho aSelectRow = new QAction(this); aSelectColumn = new QAction(this); - aPlayAndIncreaseTax = new QAction(this); - connect(aPlayAndIncreaseTax, &QAction::triggered, playerActions, &PlayerActions::actPlayAndIncreaseTax); - aPlayAndIncreasePartnerTax = new QAction(this); - connect(aPlayAndIncreasePartnerTax, &QAction::triggered, playerActions, - &PlayerActions::actPlayAndIncreasePartnerTax); - connect(aAttach, &QAction::triggered, actions, &PlayerActions::actAttach); connect(aDrawArrow, &QAction::triggered, actions, &PlayerActions::actDrawArrow); connect(aSelectAll, &QAction::triggered, actions, &PlayerActions::actSelectAll); diff --git a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp index f7d979b7d..2a4935bc6 100644 --- a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp @@ -2,11 +2,11 @@ #include "../../../client/settings/cache_settings.h" #include "../../board/abstract_counter.h" +#include "../../game/player/player_actions.h" +#include "../../game/player/player_logic.h" #include "../../game_scene.h" #include "../../zones/command_zone.h" -#include "../player_actions.h" #include "../player_graphics_item.h" -#include "../player_logic.h" #include #include @@ -21,7 +21,7 @@ CommandZoneMenu::CommandZoneMenu(PlayerLogic *_player, QMenu *playerMenu) : QMen aViewZone = new QAction(this); connect(aViewZone, &QAction::triggered, this, - [this]() { player->getGameScene()->toggleZoneView(player, ZoneNames::COMMAND, -1); }); + [this]() { emit player->requestZoneViewToggle(player, ZoneNames::COMMAND, -1, false); }); if (player->getPlayerInfo()->getLocalOrJudge()) { addAction(aViewZone); @@ -106,10 +106,11 @@ void CommandZoneMenu::retranslateUi() void CommandZoneMenu::actToggleMinimized() { - CommandZone *zone = player->getGraphicsItem()->getCommandZoneGraphicsItem(); + // TODO + /*CommandZone *zone = player->getGraphicsItem()->getCommandZoneGraphicsItem(); if (zone) { zone->toggleMinimized(); - } + }*/ } void CommandZoneMenu::updateTaxCounterActionStates() diff --git a/cockatrice/src/game_graphics/player/menu/player_menu.cpp b/cockatrice/src/game_graphics/player/menu/player_menu.cpp index 6fab513b0..dba319b21 100644 --- a/cockatrice/src/game_graphics/player/menu/player_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/player_menu.cpp @@ -33,14 +33,15 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_ if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) { sideboardMenu = addManagedMenu(player, playerMenu); - commandZoneMenu = addManagedMenu(player, playerMenu); + // TODO + /*commandZoneMenu = addManagedMenu(player, playerMenu); auto updateCommandZoneMenuVisibility = [this](bool has) { if (commandZoneMenu) { commandZoneMenu->menuAction()->setVisible(has); } }; connect(player, &PlayerLogic::commandZoneSupportChanged, this, updateCommandZoneMenuVisibility); - updateCommandZoneMenuVisibility(player->hasServerCommandZone()); + updateCommandZoneMenuVisibility(player->hasServerCommandZone());*/ customZonesMenu = addManagedMenu(player); playerMenu->addSeparator(); diff --git a/cockatrice/src/game_graphics/player/menu/player_menu.h b/cockatrice/src/game_graphics/player/menu/player_menu.h index e77401f67..226d93e01 100644 --- a/cockatrice/src/game_graphics/player/menu/player_menu.h +++ b/cockatrice/src/game_graphics/player/menu/player_menu.h @@ -8,7 +8,7 @@ #define COCKATRICE_PLAYER_MENU_H #include "../../../interface/widgets/menus/tearoff_menu.h" -#include "../player_logic.h" +#include "../../game/player/player_logic.h" #include "command_zone_menu.h" #include "custom_zone_menu.h" #include "grave_menu.h" diff --git a/cockatrice/src/game_graphics/player/player_graphics_item.cpp b/cockatrice/src/game_graphics/player/player_graphics_item.cpp index 7d5541c5f..ca1f5572f 100644 --- a/cockatrice/src/game_graphics/player/player_graphics_item.cpp +++ b/cockatrice/src/game_graphics/player/player_graphics_item.cpp @@ -6,6 +6,8 @@ #include "../board/commander_tax_counter.h" #include "../board/counter_general.h" #include "../hand_counter.h" +#include "../z_values.h" +#include "../zones/command_zone.h" #include "../zones/hand_zone.h" #include "../zones/pile_zone.h" #include "../zones/stack_zone.h" @@ -14,9 +16,6 @@ #include "player_dialogs.h" #include -#include "../z_values.h" -#include "../zones/command_zone.h" - #include PlayerGraphicsItem::PlayerGraphicsItem(PlayerLogic *_player) : player(_player) @@ -66,6 +65,7 @@ PlayerGraphicsItem::PlayerGraphicsItem(PlayerLogic *_player) : player(_player) connect(player, &PlayerLogic::addViewCustomZoneActionToCustomZoneMenu, this, &PlayerGraphicsItem::onCustomZoneAdded); + connect(player, &PlayerLogic::commandZoneSupportChanged, this, &PlayerGraphicsItem::setCommandZoneVisible); playerMenu->setMenusForGraphicItems(); diff --git a/cockatrice/src/game/zones/command_zone.cpp b/cockatrice/src/game_graphics/zones/command_zone.cpp similarity index 96% rename from cockatrice/src/game/zones/command_zone.cpp rename to cockatrice/src/game_graphics/zones/command_zone.cpp index cbac7ce31..ed3e52b9d 100644 --- a/cockatrice/src/game/zones/command_zone.cpp +++ b/cockatrice/src/game_graphics/zones/command_zone.cpp @@ -1,14 +1,14 @@ #include "command_zone.h" #include "../../client/settings/cache_settings.h" -#include "../../game_graphics/zones/select_zone.h" +#include "../../game/player/player_actions.h" +#include "../../game/player/player_logic.h" #include "../../interface/theme_manager.h" #include "../board/card_drag_item.h" #include "../board/card_item.h" #include "../board/commander_tax_counter.h" -#include "../player/player_actions.h" -#include "../player/player_logic.h" #include "../z_values.h" +#include "select_zone.h" #include #include @@ -140,7 +140,8 @@ void CommandZone::reorganizeCards() void CommandZone::rearrangeTaxCounters() { - bool commandZoneVisible = isVisible(); + // TODO + /*bool commandZoneVisible = isVisible(); int activeTaxCounterCount = 0; auto *graphicsItem = getLogic()->getPlayer()->getGraphicsItem(); @@ -162,7 +163,7 @@ void CommandZone::rearrangeTaxCounters() int minHeight = activeTaxCounterCount * (TaxCounterSizes::TAX_COUNTER_SIZE + TaxCounterSizes::TAX_COUNTER_MARGIN) + TaxCounterSizes::TAX_COUNTER_MARGIN; - setMinimumHeight(minHeight); + setMinimumHeight(minHeight);*/ } void CommandZone::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) diff --git a/cockatrice/src/game/zones/command_zone.h b/cockatrice/src/game_graphics/zones/command_zone.h similarity index 97% rename from cockatrice/src/game/zones/command_zone.h rename to cockatrice/src/game_graphics/zones/command_zone.h index 4a6143890..9a23b03f5 100644 --- a/cockatrice/src/game/zones/command_zone.h +++ b/cockatrice/src/game_graphics/zones/command_zone.h @@ -7,9 +7,9 @@ #ifndef COCKATRICE_COMMAND_ZONE_H #define COCKATRICE_COMMAND_ZONE_H -#include "../../game_graphics/zones/select_zone.h" +#include "../../game/zones/command_zone_logic.h" #include "../card_dimensions.h" -#include "command_zone_logic.h" +#include "select_zone.h" #include From b0ed79d9c3e805643e848026ff88e6c2d0b64565 Mon Sep 17 00:00:00 2001 From: DawnFire42 Date: Tue, 9 Jun 2026 14:29:20 -0400 Subject: [PATCH 3/4] Fix Command Zone graphics/logic layers separation 1. CommandZoneMenu: Changed to take PlayerGraphicsItem* instead of PlayerLogic*, accessing logic via player->getLogic() 2. Removed getCounterWidget() from PlayerLogic; method already exists correctly in PlayerGraphicsItem 3. PlayerMenu: CommandZoneMenu, fixed signal connection to use player->getLogic() for commandZoneSupportChanged 4. AbstractCounter: Connects to CounterState::activeChanged signal, removing direct graphics calls from PlayerEventHandler 5. CommandZone: Explicit tax counter registration via registerTaxCounter() with auto-cleanup, replacing childItems()/dynamic_cast iteration Also fixed PlayerActions to query CounterState instead of AbstractCounter for proper layer separation. --- cockatrice/src/game/player/player_actions.cpp | 19 +++++++-------- .../src/game/player/player_event_handler.cpp | 7 ------ cockatrice/src/game/player/player_logic.cpp | 7 ------ cockatrice/src/game/player/player_logic.h | 3 --- .../game_graphics/board/abstract_counter.cpp | 5 ++++ .../player/menu/command_zone_menu.cpp | 22 ++++++++++-------- .../player/menu/command_zone_menu.h | 6 ++--- .../game_graphics/player/menu/player_menu.cpp | 7 +++--- .../player/player_graphics_item.cpp | 1 + .../src/game_graphics/zones/command_zone.cpp | 23 +++++++++++-------- .../src/game_graphics/zones/command_zone.h | 11 ++++++--- 11 files changed, 55 insertions(+), 56 deletions(-) diff --git a/cockatrice/src/game/player/player_actions.cpp b/cockatrice/src/game/player/player_actions.cpp index 1021629cc..681641093 100644 --- a/cockatrice/src/game/player/player_actions.cpp +++ b/cockatrice/src/game/player/player_actions.cpp @@ -7,6 +7,7 @@ #include "../../game_graphics/zones/table_zone.h" #include "../../interface/widgets/tabs/tab_game.h" #include "../../interface/widgets/utility/get_text_with_max.h" +#include "../board/counter_state.h" #include "../zones/view_zone_logic.h" #include @@ -1654,8 +1655,8 @@ void PlayerActions::actPlayAndIncreaseTax(QList selectedCards) { playSelectedCardsImpl(selectedCards, false, [this](CardItem * /*card*/, const QString &originalZone) { if (originalZone == ZoneNames::COMMAND) { - AbstractCounter *ctr = player->getCounterWidget(CounterIds::CommanderTax); - if (ctr && ctr->isActive()) { + CounterState *state = player->getCounters().value(CounterIds::CommanderTax, nullptr); + if (state && state->isActive()) { sendIncCounter(CounterIds::CommanderTax, 2); } } @@ -1666,8 +1667,8 @@ void PlayerActions::actPlayAndIncreasePartnerTax(QList selectedCards { playSelectedCardsImpl(selectedCards, false, [this](CardItem * /*card*/, const QString &originalZone) { if (originalZone == ZoneNames::COMMAND) { - AbstractCounter *ctr = player->getCounterWidget(CounterIds::PartnerTax); - if (ctr && ctr->isActive()) { + CounterState *state = player->getCounters().value(CounterIds::PartnerTax, nullptr); + if (state && state->isActive()) { sendIncCounter(CounterIds::PartnerTax, 2); } } @@ -1684,8 +1685,8 @@ void PlayerActions::sendIncCounter(int counterId, int delta) void PlayerActions::actModifyTaxCounter(int counterId, int delta) { - AbstractCounter *ctr = player->getCounterWidget(counterId); - if (!ctr || !ctr->isActive()) { + CounterState *state = player->getCounters().value(counterId, nullptr); + if (!state || !state->isActive()) { return; } sendIncCounter(counterId, delta); @@ -1693,13 +1694,13 @@ void PlayerActions::actModifyTaxCounter(int counterId, int delta) void PlayerActions::actToggleTaxCounter(int counterId) { - AbstractCounter *ctr = player->getCounterWidget(counterId); - if (!ctr || (ctr->isActive() && ctr->getValue() != 0)) { + CounterState *state = player->getCounters().value(counterId, nullptr); + if (!state || (state->isActive() && state->getValue() != 0)) { return; } Command_SetCounterActive cmd; cmd.set_counter_id(counterId); - cmd.set_active(!ctr->isActive()); + cmd.set_active(!state->isActive()); sendGameCommand(cmd); } diff --git a/cockatrice/src/game/player/player_event_handler.cpp b/cockatrice/src/game/player/player_event_handler.cpp index 9f9aca671..0eb471bd9 100644 --- a/cockatrice/src/game/player/player_event_handler.cpp +++ b/cockatrice/src/game/player/player_event_handler.cpp @@ -285,13 +285,6 @@ void PlayerEventHandler::eventSetCounterActive(const Event_SetCounterActive &eve return; } state->setActive(event.active()); - - // TODO: The counters data should emit this and the widget hook up to it. Don't reach into graphics like this. - /*AbstractCounter *widget = player->getGraphicsItem()->getCounterWidget(event.counter_id()); - if (widget) { - widget->setActive(event.active()); - emit player->rearrangeCounters(); - }*/ } void PlayerEventHandler::eventDelCounter(const Event_DelCounter &event) diff --git a/cockatrice/src/game/player/player_logic.cpp b/cockatrice/src/game/player/player_logic.cpp index 84180a2f5..aabc014b3 100644 --- a/cockatrice/src/game/player/player_logic.cpp +++ b/cockatrice/src/game/player/player_logic.cpp @@ -316,13 +316,6 @@ CounterState *PlayerLogic::getLifeCounter() const return nullptr; } -AbstractCounter *PlayerLogic::getCounterWidget(int counterId) const -{ - Q_UNUSED(counterId); - return nullptr; - // TODO: Do not reach into graphics like this return graphicsItem->getCounterWidget(counterId); -} - bool PlayerLogic::clearCardsToDelete() { if (cardsToDelete.isEmpty()) { diff --git a/cockatrice/src/game/player/player_logic.h b/cockatrice/src/game/player/player_logic.h index b530d96bd..0394bbb74 100644 --- a/cockatrice/src/game/player/player_logic.h +++ b/cockatrice/src/game/player/player_logic.h @@ -223,9 +223,6 @@ public: */ CounterState *getLifeCounter() const; - /** @brief Returns the counter widget for the given ID, or nullptr if not found. */ - AbstractCounter *getCounterWidget(int counterId) const; - void setConceded(bool _conceded); bool getConceded() const { diff --git a/cockatrice/src/game_graphics/board/abstract_counter.cpp b/cockatrice/src/game_graphics/board/abstract_counter.cpp index ac092803d..46eb7cba3 100644 --- a/cockatrice/src/game_graphics/board/abstract_counter.cpp +++ b/cockatrice/src/game_graphics/board/abstract_counter.cpp @@ -33,6 +33,11 @@ AbstractCounter::AbstractCounter(CounterState *state, update(); }); + connect(state, &CounterState::activeChanged, this, [this](bool newActive) { + setActive(newActive); + emit player->rearrangeCounters(); + }); + if (player->getPlayerInfo()->getLocalOrJudge()) { menu = new TearOffMenu(TranslateCounterName::getDisplayName(state->getName())); aSet = new QAction(this); diff --git a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp index 2a4935bc6..dd2aa621f 100644 --- a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp @@ -11,7 +11,7 @@ #include #include -CommandZoneMenu::CommandZoneMenu(PlayerLogic *_player, QMenu *playerMenu) : QMenu(playerMenu), player(_player) +CommandZoneMenu::CommandZoneMenu(PlayerGraphicsItem *_player, QMenu *playerMenu) : QMenu(playerMenu), player(_player) { viewZoneShortcutKey = QStringLiteral("Player/aViewCommandZone"); incTaxShortcutKey = QStringLiteral("Player/aAddCommanderTax"); @@ -20,14 +20,17 @@ CommandZoneMenu::CommandZoneMenu(PlayerLogic *_player, QMenu *playerMenu) : QMen decPartnerTaxShortcutKey = QStringLiteral("Player/aRemovePartnerTax"); aViewZone = new QAction(this); - connect(aViewZone, &QAction::triggered, this, - [this]() { emit player->requestZoneViewToggle(player, ZoneNames::COMMAND, -1, false); }); + connect(aViewZone, &QAction::triggered, this, [this]() { + if (PlayerLogic *logic = player->getLogic()) { + emit logic->requestZoneViewToggle(logic, ZoneNames::COMMAND, -1, false); + } + }); - if (player->getPlayerInfo()->getLocalOrJudge()) { + if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) { addAction(aViewZone); addSeparator(); - PlayerActions *playerActions = player->getPlayerActions(); + PlayerActions *playerActions = player->getLogic()->getPlayerActions(); aIncreaseCommanderTax = new QAction(this); connect(aIncreaseCommanderTax, &QAction::triggered, this, @@ -106,20 +109,19 @@ void CommandZoneMenu::retranslateUi() void CommandZoneMenu::actToggleMinimized() { - // TODO - /*CommandZone *zone = player->getGraphicsItem()->getCommandZoneGraphicsItem(); + CommandZone *zone = player->getCommandZoneGraphicsItem(); if (zone) { zone->toggleMinimized(); - }*/ + } } void CommandZoneMenu::updateTaxCounterActionStates() { AbstractCounter *cmdTax = player->getCounterWidget(CounterIds::CommanderTax); - bool cmdActive = cmdTax && cmdTax->isActive(); + bool cmdActive = cmdTax != nullptr && cmdTax->isActive(); AbstractCounter *partnerTax = player->getCounterWidget(CounterIds::PartnerTax); - bool partnerActive = partnerTax && partnerTax->isActive(); + bool partnerActive = partnerTax != nullptr && partnerTax->isActive(); if (aIncreaseCommanderTax) { aIncreaseCommanderTax->setVisible(cmdActive); diff --git a/cockatrice/src/game_graphics/player/menu/command_zone_menu.h b/cockatrice/src/game_graphics/player/menu/command_zone_menu.h index 2f36c6d7a..cdd2056cc 100644 --- a/cockatrice/src/game_graphics/player/menu/command_zone_menu.h +++ b/cockatrice/src/game_graphics/player/menu/command_zone_menu.h @@ -11,7 +11,7 @@ #include -class PlayerLogic; +class PlayerGraphicsItem; /** * @class CommandZoneMenu @@ -29,7 +29,7 @@ class CommandZoneMenu : public QMenu, public AbstractPlayerComponent Q_OBJECT public: - explicit CommandZoneMenu(PlayerLogic *player, QMenu *playerMenu); + explicit CommandZoneMenu(PlayerGraphicsItem *player, QMenu *playerMenu); void retranslateUi() override; void setShortcutsActive() override; void setShortcutsInactive() override; @@ -50,7 +50,7 @@ private slots: private: void updateTaxCounterActionStates(); - PlayerLogic *player; + PlayerGraphicsItem *player; QString viewZoneShortcutKey; QString incTaxShortcutKey; diff --git a/cockatrice/src/game_graphics/player/menu/player_menu.cpp b/cockatrice/src/game_graphics/player/menu/player_menu.cpp index dba319b21..450099709 100644 --- a/cockatrice/src/game_graphics/player/menu/player_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/player_menu.cpp @@ -33,15 +33,14 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_ if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) { sideboardMenu = addManagedMenu(player, playerMenu); - // TODO - /*commandZoneMenu = addManagedMenu(player, playerMenu); + commandZoneMenu = addManagedMenu(player, playerMenu); auto updateCommandZoneMenuVisibility = [this](bool has) { if (commandZoneMenu) { commandZoneMenu->menuAction()->setVisible(has); } }; - connect(player, &PlayerLogic::commandZoneSupportChanged, this, updateCommandZoneMenuVisibility); - updateCommandZoneMenuVisibility(player->hasServerCommandZone());*/ + connect(player->getLogic(), &PlayerLogic::commandZoneSupportChanged, this, updateCommandZoneMenuVisibility); + updateCommandZoneMenuVisibility(player->getLogic()->hasServerCommandZone()); customZonesMenu = addManagedMenu(player); playerMenu->addSeparator(); diff --git a/cockatrice/src/game_graphics/player/player_graphics_item.cpp b/cockatrice/src/game_graphics/player/player_graphics_item.cpp index ca1f5572f..2f9ac91a6 100644 --- a/cockatrice/src/game_graphics/player/player_graphics_item.cpp +++ b/cockatrice/src/game_graphics/player/player_graphics_item.cpp @@ -205,6 +205,7 @@ void PlayerGraphicsItem::onCounterAdded(CounterState *state) } widget = new CommanderTaxCounter(state, player, commandZoneGraphicsItem); widget->setActive(state->isActive()); + commandZoneGraphicsItem->registerTaxCounter(widget); } else { widget = new GeneralCounter(state, player, true, this); } diff --git a/cockatrice/src/game_graphics/zones/command_zone.cpp b/cockatrice/src/game_graphics/zones/command_zone.cpp index ed3e52b9d..69824499a 100644 --- a/cockatrice/src/game_graphics/zones/command_zone.cpp +++ b/cockatrice/src/game_graphics/zones/command_zone.cpp @@ -4,11 +4,11 @@ #include "../../game/player/player_actions.h" #include "../../game/player/player_logic.h" #include "../../interface/theme_manager.h" +#include "../board/abstract_counter.h" #include "../board/card_drag_item.h" #include "../board/card_item.h" #include "../board/commander_tax_counter.h" #include "../z_values.h" -#include "select_zone.h" #include #include @@ -138,18 +138,21 @@ void CommandZone::reorganizeCards() update(); } -void CommandZone::rearrangeTaxCounters() +void CommandZone::registerTaxCounter(AbstractCounter *counter) { - // TODO - /*bool commandZoneVisible = isVisible(); - int activeTaxCounterCount = 0; - - auto *graphicsItem = getLogic()->getPlayer()->getGraphicsItem(); - if (!graphicsItem) { + if (!counter || taxCounters.contains(counter)) { return; } + taxCounters.append(counter); + connect(counter, &QObject::destroyed, this, [this, counter]() { taxCounters.removeOne(counter); }); +} - for (AbstractCounter *ctr : graphicsItem->getTaxCounterWidgets()) { +void CommandZone::rearrangeTaxCounters() +{ + bool commandZoneVisible = isVisible(); + int activeTaxCounterCount = 0; + + for (AbstractCounter *ctr : taxCounters) { qreal y = TaxCounterSizes::TAX_COUNTER_MARGIN + activeTaxCounterCount * (TaxCounterSizes::TAX_COUNTER_SIZE + TaxCounterSizes::TAX_COUNTER_MARGIN); ctr->setPos(TaxCounterSizes::TAX_COUNTER_MARGIN, y); @@ -163,7 +166,7 @@ void CommandZone::rearrangeTaxCounters() int minHeight = activeTaxCounterCount * (TaxCounterSizes::TAX_COUNTER_SIZE + TaxCounterSizes::TAX_COUNTER_MARGIN) + TaxCounterSizes::TAX_COUNTER_MARGIN; - setMinimumHeight(minHeight);*/ + setMinimumHeight(minHeight); } void CommandZone::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) diff --git a/cockatrice/src/game_graphics/zones/command_zone.h b/cockatrice/src/game_graphics/zones/command_zone.h index 9a23b03f5..52d4f79a6 100644 --- a/cockatrice/src/game_graphics/zones/command_zone.h +++ b/cockatrice/src/game_graphics/zones/command_zone.h @@ -13,6 +13,8 @@ #include +class AbstractCounter; + inline Q_LOGGING_CATEGORY(CommandZoneLog, "command_zone"); /** @@ -50,9 +52,10 @@ public: private: static constexpr double MINIMIZED_HEIGHT_RATIO = 0.25; - int zoneHeight; ///< Full height in pixels when expanded - bool minimized = false; ///< Whether zone is at 25% height - int minimumHeight = 0; ///< Floor for minimized height (e.g. to fit tax counters) + int zoneHeight; ///< Full height in pixels when expanded + bool minimized = false; ///< Whether zone is at 25% height + int minimumHeight = 0; ///< Floor for minimized height (e.g. to fit tax counters) + QList taxCounters; ///< Registered tax counter widgets public: /** @@ -86,6 +89,8 @@ public: [[nodiscard]] qreal currentHeight() const; /** @brief Sets the minimum height floor, e.g. to ensure tax counters remain visible. */ void setMinimumHeight(int height); + /** @brief Registers a tax counter widget for layout management. */ + void registerTaxCounter(AbstractCounter *counter); /** @brief Lays out visible tax counters vertically in the top-left corner of the command zone. */ void rearrangeTaxCounters(); From beea819b896e0e1afd675d0135b04e7b6fd3fe70 Mon Sep 17 00:00:00 2001 From: DawnFire42 Date: Tue, 9 Jun 2026 15:29:22 -0400 Subject: [PATCH 4/4] Code cleanup MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add missing isCommandZoneCounterBlocked check to cmdSetCounterActive - Revert accidental deck view layout change from b4057a86 - Fix duplicate @param in playSelectedCardsImpl doc - Add null check for PlayerLogic in CommandZoneMenu constructor - Add index bounds check in CommandZone handleDropEvent - Add index bounds check in StackZone handleDropEvent - Add ownership comment for tax counter widget creation - Add command zone to zoneGraphicsItems map - Conditionally show command zone menu item based on server support - Remove layer-violating includes from player_logic.cpp - Fix tax counter increment (1 per cast, not 2) - Add getTaxCounterIfActive() helper to PlayerGraphicsItem --- cockatrice/src/game/board/counter_state.cpp | 2 +- cockatrice/src/game/player/player_actions.cpp | 5 ++-- cockatrice/src/game/player/player_actions.h | 5 ++-- cockatrice/src/game/player/player_logic.cpp | 2 -- .../game_graphics/player/menu/card_menu.cpp | 6 ++--- .../player/menu/command_zone_menu.cpp | 26 +++++++++---------- .../game_graphics/player/menu/move_menu.cpp | 5 ++++ .../player/player_graphics_item.cpp | 9 +++++++ .../player/player_graphics_item.h | 2 ++ .../src/game_graphics/zones/command_zone.cpp | 3 ++- .../src/game_graphics/zones/stack_zone.cpp | 3 ++- .../src/interface/widgets/tabs/tab_game.cpp | 2 +- .../server/remote/game/server_player.cpp | 4 +++ 13 files changed, 45 insertions(+), 29 deletions(-) diff --git a/cockatrice/src/game/board/counter_state.cpp b/cockatrice/src/game/board/counter_state.cpp index b8377102f..116de4a8d 100644 --- a/cockatrice/src/game/board/counter_state.cpp +++ b/cockatrice/src/game/board/counter_state.cpp @@ -37,4 +37,4 @@ void CounterState::setActive(bool newActive) } active = newActive; emit activeChanged(newActive); -} \ No newline at end of file +} diff --git a/cockatrice/src/game/player/player_actions.cpp b/cockatrice/src/game/player/player_actions.cpp index 681641093..7c62696a1 100644 --- a/cockatrice/src/game/player/player_actions.cpp +++ b/cockatrice/src/game/player/player_actions.cpp @@ -1657,7 +1657,7 @@ void PlayerActions::actPlayAndIncreaseTax(QList selectedCards) if (originalZone == ZoneNames::COMMAND) { CounterState *state = player->getCounters().value(CounterIds::CommanderTax, nullptr); if (state && state->isActive()) { - sendIncCounter(CounterIds::CommanderTax, 2); + sendIncCounter(CounterIds::CommanderTax, 1); } } }); @@ -1669,7 +1669,7 @@ void PlayerActions::actPlayAndIncreasePartnerTax(QList selectedCards if (originalZone == ZoneNames::COMMAND) { CounterState *state = player->getCounters().value(CounterIds::PartnerTax, nullptr); if (state && state->isActive()) { - sendIncCounter(CounterIds::PartnerTax, 2); + sendIncCounter(CounterIds::PartnerTax, 1); } } }); @@ -1695,6 +1695,7 @@ void PlayerActions::actModifyTaxCounter(int counterId, int delta) void PlayerActions::actToggleTaxCounter(int counterId) { CounterState *state = player->getCounters().value(counterId, nullptr); + // Prevent disabling a counter with tax accumulated; player must reset to 0 first if (!state || (state->isActive() && state->getValue() != 0)) { return; } diff --git a/cockatrice/src/game/player/player_actions.h b/cockatrice/src/game/player/player_actions.h index c8ef1d359..282a80a5c 100644 --- a/cockatrice/src/game/player/player_actions.h +++ b/cockatrice/src/game/player/player_actions.h @@ -257,9 +257,8 @@ private: /** * @brief Shared implementation for playing selected cards with an optional post-play callback. - * @param selectedCards - * @param selectedCards - * @param selectedCards + * @param selectedCards Cards to play + * @param faceDown Whether to play cards face-down * @param postPlayCallback Called after each card is played, receiving the card and its *original* zone name * (captured before playCard, since playCard sends a move command that may change the card's zone). */ diff --git a/cockatrice/src/game/player/player_logic.cpp b/cockatrice/src/game/player/player_logic.cpp index aabc014b3..9e88f7ee3 100644 --- a/cockatrice/src/game/player/player_logic.cpp +++ b/cockatrice/src/game/player/player_logic.cpp @@ -2,11 +2,9 @@ #include "../../game_graphics/board/arrow_item.h" #include "../../game_graphics/board/card_item.h" -#include "../../game_graphics/board/commander_tax_counter.h" #include "../../game_graphics/board/counter_general.h" #include "../../game_graphics/game_scene.h" #include "../../game_graphics/player/player_target.h" -#include "../../game_graphics/zones/command_zone.h" #include "../../game_graphics/zones/hand_zone.h" #include "../../game_graphics/zones/pile_zone.h" #include "../../game_graphics/zones/stack_zone.h" diff --git a/cockatrice/src/game_graphics/player/menu/card_menu.cpp b/cockatrice/src/game_graphics/player/menu/card_menu.cpp index 67c5ad716..736af8353 100644 --- a/cockatrice/src/game_graphics/player/menu/card_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/card_menu.cpp @@ -165,13 +165,11 @@ CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _sho if (writeableCard) { addAction(aPlay); - AbstractCounter *cmdTax = player->getCounterWidget(CounterIds::CommanderTax); - if (cmdTax && cmdTax->isActive()) { + if (player->getTaxCounterIfActive(CounterIds::CommanderTax)) { addAction(aPlayAndIncreaseTax); } - AbstractCounter *partnerTax = player->getCounterWidget(CounterIds::PartnerTax); - if (partnerTax && partnerTax->isActive()) { + if (player->getTaxCounterIfActive(CounterIds::PartnerTax)) { addAction(aPlayAndIncreasePartnerTax); } diff --git a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp index dd2aa621f..ee9bf219a 100644 --- a/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/command_zone_menu.cpp @@ -26,7 +26,8 @@ CommandZoneMenu::CommandZoneMenu(PlayerGraphicsItem *_player, QMenu *playerMenu) } }); - if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) { + PlayerLogic *logic = player->getLogic(); + if (logic && logic->getPlayerInfo()->getLocalOrJudge()) { addAction(aViewZone); addSeparator(); @@ -117,32 +118,29 @@ void CommandZoneMenu::actToggleMinimized() void CommandZoneMenu::updateTaxCounterActionStates() { - AbstractCounter *cmdTax = player->getCounterWidget(CounterIds::CommanderTax); - bool cmdActive = cmdTax != nullptr && cmdTax->isActive(); - - AbstractCounter *partnerTax = player->getCounterWidget(CounterIds::PartnerTax); - bool partnerActive = partnerTax != nullptr && partnerTax->isActive(); + AbstractCounter *cmdTax = player->getTaxCounterIfActive(CounterIds::CommanderTax); + AbstractCounter *partnerTax = player->getTaxCounterIfActive(CounterIds::PartnerTax); if (aIncreaseCommanderTax) { - aIncreaseCommanderTax->setVisible(cmdActive); + aIncreaseCommanderTax->setVisible(cmdTax != nullptr); } if (aDecreaseCommanderTax) { - aDecreaseCommanderTax->setVisible(cmdActive); + aDecreaseCommanderTax->setVisible(cmdTax != nullptr); } if (aToggleCommanderTaxCounter) { - aToggleCommanderTaxCounter->setText(cmdActive ? tr("&Remove Commander Tax") : tr("&Add Commander Tax")); - aToggleCommanderTaxCounter->setVisible(!cmdActive || (cmdTax && cmdTax->getValue() == 0)); + aToggleCommanderTaxCounter->setText(cmdTax ? tr("&Remove Commander Tax") : tr("&Add Commander Tax")); + aToggleCommanderTaxCounter->setVisible(!cmdTax || cmdTax->getValue() == 0); } if (aIncreasePartnerTax) { - aIncreasePartnerTax->setVisible(partnerActive); + aIncreasePartnerTax->setVisible(partnerTax != nullptr); } if (aDecreasePartnerTax) { - aDecreasePartnerTax->setVisible(partnerActive); + aDecreasePartnerTax->setVisible(partnerTax != nullptr); } if (aTogglePartnerTaxCounter) { - aTogglePartnerTaxCounter->setText(partnerActive ? tr("R&emove Partner Tax") : tr("&Add Partner Tax")); - aTogglePartnerTaxCounter->setVisible(!partnerActive || (partnerTax && partnerTax->getValue() == 0)); + aTogglePartnerTaxCounter->setText(partnerTax ? tr("R&emove Partner Tax") : tr("&Add Partner Tax")); + aTogglePartnerTaxCounter->setVisible(!partnerTax || partnerTax->getValue() == 0); } } diff --git a/cockatrice/src/game_graphics/player/menu/move_menu.cpp b/cockatrice/src/game_graphics/player/menu/move_menu.cpp index 2c345a81c..becbc3625 100644 --- a/cockatrice/src/game_graphics/player/menu/move_menu.cpp +++ b/cockatrice/src/game_graphics/player/menu/move_menu.cpp @@ -54,6 +54,11 @@ MoveMenu::MoveMenu(PlayerGraphicsItem *player) : QMenu(tr("Move to")) addSeparator(); addAction(aMoveToCommandZone); + auto *playerLogic = player->getLogic(); + auto updateCommandZoneVisibility = [this](bool has) { aMoveToCommandZone->setVisible(has); }; + connect(playerLogic, &PlayerLogic::commandZoneSupportChanged, this, updateCommandZoneVisibility); + updateCommandZoneVisibility(playerLogic->hasServerCommandZone()); + setShortcutsActive(); retranslateUi(); diff --git a/cockatrice/src/game_graphics/player/player_graphics_item.cpp b/cockatrice/src/game_graphics/player/player_graphics_item.cpp index 2f9ac91a6..b586ab386 100644 --- a/cockatrice/src/game_graphics/player/player_graphics_item.cpp +++ b/cockatrice/src/game_graphics/player/player_graphics_item.cpp @@ -143,6 +143,7 @@ void PlayerGraphicsItem::initializeZones() zoneGraphicsItems.insert(player->getTableZone()->getName(), tableZoneGraphicsItem); zoneGraphicsItems.insert(player->getStackZone()->getName(), stackZoneGraphicsItem); zoneGraphicsItems.insert(player->getHandZone()->getName(), handZoneGraphicsItem); + zoneGraphicsItems.insert(player->getCommandZone()->getName(), commandZoneGraphicsItem); } void PlayerGraphicsItem::onCustomZoneAdded(QString customZoneName) @@ -203,6 +204,8 @@ void PlayerGraphicsItem::onCounterAdded(CounterState *state) qWarning() << "Cannot create tax counter" << state->getName() << "- command zone not available"; return; } + // Qt parent (commandZoneGraphicsItem) owns widget; counterWidgets map holds reference + // for lookup; CommandZone::registerTaxCounter connects QObject::destroyed for cleanup widget = new CommanderTaxCounter(state, player, commandZoneGraphicsItem); widget->setActive(state->isActive()); commandZoneGraphicsItem->registerTaxCounter(widget); @@ -267,6 +270,12 @@ QList PlayerGraphicsItem::getTaxCounterWidgets() const return result; } +AbstractCounter *PlayerGraphicsItem::getTaxCounterIfActive(int counterId) const +{ + AbstractCounter *counter = getCounterWidget(counterId); + return (counter && counter->isActive()) ? counter : nullptr; +} + void PlayerGraphicsItem::rearrangeZones() { auto base = QPointF(CardDimensions::HEIGHT_F + counterAreaWidth + 15, 0); diff --git a/cockatrice/src/game_graphics/player/player_graphics_item.h b/cockatrice/src/game_graphics/player/player_graphics_item.h index 47c5fafba..87fb94e26 100644 --- a/cockatrice/src/game_graphics/player/player_graphics_item.h +++ b/cockatrice/src/game_graphics/player/player_graphics_item.h @@ -125,6 +125,8 @@ public: } /** @brief Returns all tax counter widgets (commander tax and partner tax). */ [[nodiscard]] QList getTaxCounterWidgets() const; + /** @brief Returns the tax counter if it exists and is active, or nullptr otherwise. */ + [[nodiscard]] AbstractCounter *getTaxCounterIfActive(int counterId) const; public slots: void onPlayerActiveChanged(bool _active); diff --git a/cockatrice/src/game_graphics/zones/command_zone.cpp b/cockatrice/src/game_graphics/zones/command_zone.cpp index 69824499a..72451e5c3 100644 --- a/cockatrice/src/game_graphics/zones/command_zone.cpp +++ b/cockatrice/src/game_graphics/zones/command_zone.cpp @@ -96,7 +96,8 @@ void CommandZone::handleDropEvent(const QList &dragItems, // Same-zone no-op: don't move a card onto itself const auto &cards = getLogic()->getCards(); - if (!cards.isEmpty() && startZone == getLogic() && cards.at(index)->getId() == dragItems.at(0)->getId()) { + if (!cards.isEmpty() && index < cards.size() && startZone == getLogic() && + cards.at(index)->getId() == dragItems.at(0)->getId()) { return; } diff --git a/cockatrice/src/game_graphics/zones/stack_zone.cpp b/cockatrice/src/game_graphics/zones/stack_zone.cpp index c3015496c..877312232 100644 --- a/cockatrice/src/game_graphics/zones/stack_zone.cpp +++ b/cockatrice/src/game_graphics/zones/stack_zone.cpp @@ -51,7 +51,8 @@ void StackZone::handleDropEvent(const QList &dragItems, // Same-zone no-op: don't move a card onto itself const auto &cards = getLogic()->getCards(); - if (!cards.isEmpty() && startZone == getLogic() && cards.at(index)->getId() == dragItems.at(0)->getId()) { + if (!cards.isEmpty() && index < cards.size() && startZone == getLogic() && + cards.at(index)->getId() == dragItems.at(0)->getId()) { return; } diff --git a/cockatrice/src/interface/widgets/tabs/tab_game.cpp b/cockatrice/src/interface/widgets/tabs/tab_game.cpp index a6fc3f151..a81161e83 100644 --- a/cockatrice/src/interface/widgets/tabs/tab_game.cpp +++ b/cockatrice/src/interface/widgets/tabs/tab_game.cpp @@ -690,7 +690,7 @@ void TabGame::addLocalPlayer(PlayerLogic *newPlayer, int playerId) auto *deckView = new TabbedDeckViewContainer(playerId, this); connect(deckView->playerDeckView, &DeckViewContainer::newCardAdded, this, &TabGame::newCardAdded); deckViewContainers.insert(playerId, deckView); - deckViewContainerLayout->insertWidget(0, deckView, 1); + deckViewContainerLayout->addWidget(deckView); // auto load deck for player if that debug setting is enabled QString deckPath = SettingsCache::instance().debug().getDeckPathForPlayer(newPlayer->getPlayerInfo()->getName()); diff --git a/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp b/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp index 017b7e79b..9d5ba3de5 100644 --- a/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp +++ b/libcockatrice_network/libcockatrice/network/server/remote/game/server_player.cpp @@ -578,6 +578,10 @@ Response::ResponseCode Server_Player::cmdSetCounterActive(const Command_SetCount } const int counterId = cmd.counter_id(); + if (isCommandZoneCounterBlocked(counterId)) { + return Response::RespContextError; + } + Server_Counter *c = counters.value(counterId, nullptr); if (!c) { return Response::RespNameNotFound;