itemexchangemodel.h

Go to the documentation of this file.

/*
  * Copyright 2026 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 <QHash>
#include <QVariantList>
 
class ItemStorageBox;
class PlayerBasics;

class ItemExchangeModel : public QObject
{
  Q_OBJECT
 
  // The two selected item indices (-1 = none). The dropdowns write these.
  Q_PROPERTY(int itemAInd READ itemAInd WRITE setItemAInd NOTIFY selectionChanged)
  Q_PROPERTY(int itemBInd READ itemBInd WRITE setItemBInd NOTIFY selectionChanged)
 
  Q_PROPERTY(bool valid READ valid NOTIFY changed)          
  Q_PROPERTY(int net READ net NOTIFY changed)               
 
  Q_PROPERTY(QString aName READ aName NOTIFY changed)       
  Q_PROPERTY(QString bName READ bName NOTIFY changed)       
  Q_PROPERTY(int aBuy READ aBuy NOTIFY changed)             
  Q_PROPERTY(int bBuy READ bBuy NOTIFY changed)             
 
  Q_PROPERTY(int aStart READ aStart NOTIFY changed)         
  Q_PROPERTY(int aAfter READ aAfter NOTIFY changed)         
  Q_PROPERTY(int bStart READ bStart NOTIFY changed)         
  Q_PROPERTY(int bAfter READ bAfter NOTIFY changed)         
  Q_PROPERTY(int moneyStart READ moneyStart NOTIFY changed) 
  Q_PROPERTY(int moneyAfter READ moneyAfter NOTIFY changed) 
 
  Q_PROPERTY(bool canAddA READ canAddA NOTIFY changed)      
  Q_PROPERTY(bool canAddB READ canAddB NOTIFY changed)      
 
  
  Q_PROPERTY(int revision READ revision NOTIFY changed)
 
public:
  static constexpr int MoneyCap = 999999; 
  static constexpr int StackCap = 99;     
 
  ItemExchangeModel(ItemStorageBox* bag, ItemStorageBox* storage, PlayerBasics* basics);
 
  int itemAInd() const { return m_itemAInd; }
  int itemBInd() const { return m_itemBInd; }
  void setItemAInd(int v);
  void setItemBInd(int v);
 
  int net() const { return m_net; }
  int revision() const { return m_revision; }
  bool valid() const;
 
  QString aName() const { return readableOf(m_itemAInd); }
  QString bName() const { return readableOf(m_itemBInd); }
  int aBuy() const { return buyOf(m_itemAInd); }
  int bBuy() const { return buyOf(m_itemBInd); }
 
  int aStart() const { return combinedAmount(m_itemAInd); }
  int bStart() const { return combinedAmount(m_itemBInd); }
  int moneyStart() const;
  int aAfter() const { return aAfterFor(m_net); }
  int bAfter() const { return bAfterFor(m_net); }
  int moneyAfter() const { return moneyAfterFor(m_net); }

  Q_INVOKABLE int giveFor(int dir, int steps) const;

  Q_INVOKABLE int refundFor(int dir, int steps) const;
 
  bool canAddA() const { return valid() && stateValid(m_net + 1); }
  bool canAddB() const { return valid() && stateValid(m_net - 1); }

  Q_INVOKABLE QVariantList sourceItems(bool healingOnly, int excludeInd) const;

  Q_INVOKABLE QVariantList targetItems(bool healingOnly, int excludeInd) const;

  Q_INVOKABLE bool canGainTarget(int bInd) const;

  Q_INVOKABLE void pickDefaults(bool healingOnly);
 
  Q_INVOKABLE void adjust(int dir); 
  Q_INVOKABLE void reset();         
  Q_INVOKABLE void refresh();       
 
public slots:
  void checkout(); 
 
signals:
  void selectionChanged(); 
  void changed();          
 
private:
  int combinedAmount(int ind) const;   
  int combinedCapacity(int ind) const; 
  int buyOf(int ind) const;            
  QString readableOf(int ind) const;   
  bool isHealing(int ind) const;       
  int indOfName(const QString& name) const;      
  static void sortByName(QVariantList& list);    
 
  static int nA(int m) { return m > 0 ? m : 0; }
  static int nB(int m) { return m < 0 ? -m : 0; }
  int aAfterFor(int m) const;
  int bAfterFor(int m) const;
  int moneyAfterFor(int m) const;
  bool stateValid(int m) const;        
  void clampNet();                     
  void emitChanged();                  
 
  ItemStorageBox* bag = nullptr;
  ItemStorageBox* storage = nullptr;
  PlayerBasics* basics = nullptr;
 
  int m_itemAInd = -1;
  int m_itemBInd = -1;
  int m_net = 0;
  int m_revision = 0;

  struct Info { QString name; QString readable; int buy = 0; bool healing = false; };
  QHash<int, Info> m_info;
};