itemmarketmodel.h

Go to the documentation of this file.

/*
  * Copyright 2020 Twilight
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
*/
#pragma once
#include <QObject>
#include <QString>
#include <QAbstractListModel>
#include <QVector>
#include <QVariant>
 
class ItemStorageBox;
class Router;
class PlayerBasics;
class Storage;
class PlayerPokemon;
class ItemMarketEntry;
class SaveFile;
class ItemDBEntry;

class ItemMarketModel : public QAbstractListModel
{
  Q_OBJECT
 
  Q_PROPERTY(bool isBuyMode MEMBER isBuyMode NOTIFY isBuyModeChanged)             
  Q_PROPERTY(bool isMoneyCurrency MEMBER isMoneyCurrency NOTIFY isMoneyCurrencyChanged) 
  Q_PROPERTY(bool isExchangeMode MEMBER isExchangeMode NOTIFY isExchangeModeChanged) 
  Q_PROPERTY(int whichMode READ whichMode NOTIFY isAnyChanged)                    
 
  // Dual-currency totals for the Exchange receipt (money AND coins both move).
  Q_PROPERTY(int exchangeMoneyStart READ exchangeMoneyStart NOTIFY reUpdateValues) 
  Q_PROPERTY(int exchangeMoneyAfter READ exchangeMoneyAfter NOTIFY reUpdateValues) 
  Q_PROPERTY(int exchangeCoinsStart READ exchangeCoinsStart NOTIFY reUpdateValues) 
  Q_PROPERTY(int exchangeCoinsAfter READ exchangeCoinsAfter NOTIFY reUpdateValues) 
  Q_PROPERTY(int exchangeBuyRate READ exchangeBuyRate NOTIFY reUpdateValues)        
  Q_PROPERTY(int exchangeSellRate READ exchangeSellRate NOTIFY reUpdateValues)      
 
  Q_PROPERTY(int totalCartWorth READ totalCartWorth NOTIFY reUpdateValues)        
  Q_PROPERTY(int totalCartCount READ totalCartCount NOTIFY reUpdateValues)        
  Q_PROPERTY(int moneyStart READ moneyStart NOTIFY reUpdateValues)                
  Q_PROPERTY(int moneyLeftover READ moneyLeftover NOTIFY reUpdateValues)          
  Q_PROPERTY(bool anyNotEnoughSpace READ anyNotEnoughSpace NOTIFY reUpdateValues) 
  Q_PROPERTY(bool canAnyCheckout READ canAnyCheckout NOTIFY reUpdateValues)       
 
signals:
  void isBuyModeChanged();
  void isMoneyCurrencyChanged();
  void isExchangeModeChanged();
  void isAnyChanged();
  void reUpdateValues();
 
public:
  enum ItemRoles {
    // Name of item
    NameRole = Qt::UserRole + 1,
 
    // Amount of item to sell (When in sell mode)
    InStockCountRole,
 
    // If the item can be sold (When in sell mode)
    CanSellRole,
 
    // Value of item individually to buy or sell
    ItemWorthRole,
 
    // Item Type, There are 5 types
    // * An item the player has which may or may not be sellable
    // * An item the player can buy
    // * A Game Corner Pokemon
    // * Player Money / Coins
    // * A Message
    WhichTypeRole,
 
    // Stack count of this item
    StackCountRole,
 
    // Items left that can be placed on the cart
    OnCartLeftRole,
 
    // Amount of items on cart
    CartCountRole,
 
    // Value of item total on cart to buy or sell
    CartWorthRole,
 
    // Stack count of this item
    TotalStackCountRole,
    TotalWorthRole,
 
    // Can a checkout be done?
    CanCheckoutRole,
 
    // For this setup, is the item valid?
    ValidItemRole,
 
    // Exclude this item from most totals, it's not to be mixed in with other
    // items
    ExcludeItemRole,
 
    // How much money is left after all is said and done
    MoneyLeftRole,
 
    // Which modes we're in
    BuyModeRole,
    MoneyCurrencyRole,
 
    // Which left-list VIEW this row belongs to (ViewBuy / ViewSell); -1 = unfiltered
    ViewTagRole,
 
    // Sign this row contributes to the net (+1 sell, -1 buy)
    CartSignRole,
 
    // For a money/exchange row: its fixed direction (1 = Money=>Coins, 0 = Coins=>
    // Money); -1 for non-money rows. Lets the Exchange converter label each lane.
    MoneyDirRole,
 
    // Detailed-tooltip text for the row (what the item is / how it's obtained).
    InfoRole,
  };

  enum {
    SelBuyMoney = 0,
    SelBuyCoins,
    SelSellMoney,
    SelSellCoins
  };

  enum {
    ViewBuy = 0,
    ViewSell = 1
  };
 
  ItemMarketModel(ItemStorageBox* itemBag,
                  ItemStorageBox* itemStorage,
                  PlayerBasics* basics,
                  Router* router,
                  PlayerPokemon* playerPokemon,
                  Storage* storage,
                  SaveFile* file);
 
  virtual int rowCount(const QModelIndex& parent) const override;          
  virtual QVariant data(const QModelIndex& index, int role) const override; 
  virtual QHash<int, QByteArray> roleNames() const override;                
  bool setData(const QModelIndex& index, const QVariant& value, int role) override; 
 
  // Value of total on cart
  // Uses -/+ to indicate buy/sell
  int totalCartWorth();   
  int totalCartCount();   
  int whichMode();        
  int moneyStart();       
  int moneyLeftover();    
  bool anyNotEnoughSpace(); 
  bool canAnyCheckout();  
 
  // Exchange totals (mirror the money rows' checkout deltas exactly).
  int exchangeMoneyStart(); 
  int exchangeMoneyAfter(); 
  int exchangeCoinsStart(); 
  int exchangeCoinsAfter(); 
  int exchangeBuyRate();    
  int exchangeSellRate();   
 
  // The Exchange converter drives one net coin axis via two buttons.
  Q_INVOKABLE int exchangeNet();                 
  Q_INVOKABLE void exchangeAdjust(int deltaCoins); 
 
  void onReUpdateValues(); 
 
  // Re-create list cache methods
  bool vendorListItem(ItemDBEntry* el); 
  bool buyableInGame(ItemDBEntry* el) const; 
  bool isVendingItem(ItemDBEntry* el) const; 
  void clearList();           
  void buildList();           
  void buildPlayerItemList(); 
  void buildMartItemList();   
  void buildExchangeList();   
 
  // Respodning to events and signals
  void pageOpening(QString path); 
 
public slots:
  void checkout();   
  void reUpdateAll(); 
 
public:
  QVector<ItemMarketEntry*> itemListCache; 
 
  // Buy or Sell, do we view the store's items or our own?
  // Default to Buy (the Market opens on Buy + Pokemart).
  bool isBuyMode = true; 
 
  // Money or Coins, do we sell your items to money/coins or do we look at the
  // Pokemart or Game Corner Mart to buy with money and coins
  // Default to dealing with money
  bool isMoneyCurrency = true; 
 
  // The money<->coins exchange as its own list (pulled out of the buy/sell lists).
  // When true the buy/sell + currency choice is irrelevant; the list is the two
  // swap rows.
  bool isExchangeMode = false; 
 
  // Connections to the Sav Data
  ItemStorageBox* itemBag = nullptr;     
  ItemStorageBox* itemStorage = nullptr; 
  Router* router = nullptr;              
  PlayerBasics* basics = nullptr;        
  PlayerPokemon* playerPokemon = nullptr; 
  Storage* storage = nullptr;            
  SaveFile* file = nullptr;              
};