exchangemanager.h

Go to the documentation of this file.

/*
 * exchangemanager.h
 *
 * Copyright (C) 2001 Atomic Blue (info@planeshift.it, http://www.atomicblue.org)
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */
#ifndef __EXCHANGEMANAGER_H__
#define __EXCHANGEMANAGER_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/ref.h>
#include <csutil/refarr.h>
#include <csutil/parray.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "bulkobjects/pscharinventory.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "msgmanager.h"             // Parent class

class ClientConnectionSet;
class psSpawnManager;
class psServer;
class Exchange;
class ExchangeManager;
class psNPCDialog;
class psDatabase;

class ExchangingCharacter
{
public:
    ExchangingCharacter(int client, psCharacterInventory &inv);

    bool OfferItem(int exchSlotNum, INVENTORY_SLOT_NUMBER invSlot, int stackcount, bool test);

    bool RemoveItemFromOffer(int itemNum, int count, int &remain);

    bool MoveOfferedItem(int fromSlot,int stackcount,int toSlot);

    bool IsOfferingSane();

    void TransferOffer(int targetClientNum);

    void TransferOffer(psCharacter* npc);

    void TransferMoney(int targetClientNum);

    void TransferMoney(psCharacter* target);

    psMoney GetOfferedMoney()
    {
        return offeringMoney;
    }

    void AdjustMoney(int coin, int delta);
    void AdjustMoney(const psMoney &amount);

    void GetOfferingCSV(csString &buff);

    void GetOffering(csString &buff);

    psItem* GetOfferedItem(int slot);

    void GetSimpleOffering(csString &buff, psCharacter* chr, bool exact = true);

    void UpdateReceivingMoney(psMoney &money);

    void UpdateOfferingMoney();

    psMoney offeringMoney;

    float GetSumSize();

    float GetSumWeight();

    bool GetExchangedItems(csString &text);

protected:

    psCharacter* GetClientCharacter(int clientNum);

//    psItem *offering[EXCHANGE_SLOT_COUNT];
    // csArray<psItem*> itemsOffered;

    int client;
    psCharacterInventory* chrinv;
};

//------------------------------------------------------------------------------

class Exchange : public iDeleteObjectCallback
{
public:
    Exchange(Client* starter, bool automaticExchange, ExchangeManager* manager);
    virtual ~Exchange();

    virtual void HandleEnd(Client* client) = 0;

    virtual bool HandleAccept(Client* client) = 0;
    // virtual bool Involves(psCharacter * character) = 0;
    // virtual bool Involves(psItem * item) = 0;

    virtual bool AddItem(Client* fromClient, INVENTORY_SLOT_NUMBER fromSlot, int stackCount, int toSlot);

    virtual void MoveItem(Client* client, int fromSlot, int stackCount, int toSlot);

    virtual bool RemoveItem(Client* fromClient, int slot, int stackCount);

    virtual psMoney GetOfferedMoney(Client* client);
    virtual bool AdjustMoney(Client* client, int moneyType, int newMoney);
    virtual bool AdjustMoney(Client* client, const psMoney &money);
    int GetID() const
    {
        return id;
    }
    bool CheckRange(int clientNum, gemObject* ourActor, gemObject* otherActor);

    Client* GetStarterClient()
    {
        return starterClient;    // NILAYA: Should axe.
    }

    psItem* GetStarterOffer(int slot);
    virtual psItem* GetTargetOffer(int slot)
    {
        return NULL;
    }

protected:
    virtual void SendAddItemMessage(Client* fromClient, int slot, psCharacterInventory::psCharacterInventoryItem* item);
    virtual void SendRemoveItemMessage(Client* fromClient, int slot);

    void SendEnd(int clientNum);
    static int next_id;

    int id;

    ExchangingCharacter starterChar;
    Client* starterClient;
    uint32_t player;

    bool exchangeEnded;    
    bool exchangeSuccess; 

    bool automaticExchange; 

    ExchangeManager* exchangeMgr;
};

//------------------------------------------------------------------------------

class PlayerToPlayerExchange : public Exchange
{
public:
    PlayerToPlayerExchange(Client* client, Client* target, ExchangeManager* manager);
    virtual ~PlayerToPlayerExchange();

    bool CheckExchange(uint32_t clientNum, bool checkRange=false);
    bool HandleAccept(Client* client);
    void HandleEnd(Client* client);
    void SendExchangeStatusToBoth();
    psMoney GetOfferedMoney(Client* client);
    bool AdjustMoney(Client* client, int moneyType, int newMoney);
    bool AdjustMoney(Client* client, const psMoney &money);

    virtual bool AddItem(Client* fromClient, INVENTORY_SLOT_NUMBER fromSlot, int stackCount, int toSlot);

    virtual bool RemoveItem(Client* fromClient, int slot, int stackCount);

    virtual void DeleteObjectCallback(iDeleteNotificationObject* object);

    virtual psItem* GetTargetOffer(int slot);

protected:
    virtual void SendAddItemMessage(Client* fromClient, int slot, psCharacterInventory::psCharacterInventoryItem* item);
    virtual void SendRemoveItemMessage(Client* fromClient, int slot);

private:
    void SendRequestToBoth();

    Client* GetOtherClient(Client* client) const;

    PlayerToPlayerExchange();

    Client* targetClient;
    ExchangingCharacter targetChar;
    int target;

    bool starterAccepted, targetAccepted;
};

//------------------------------------------------------------------------------

class PlayerToNPCExchange : public Exchange
{
public:
    PlayerToNPCExchange(Client* starter, gemObject* target, bool automaticExchange, int questID, ExchangeManager* manager);
    virtual ~PlayerToNPCExchange();
    gemObject* GetTargetGEM();
    bool CheckExchange(uint32_t clientNum, bool checkRange=false);
    virtual void HandleEnd(Client* client);
    virtual bool HandleAccept(Client* client);
    //virtual bool Involves(psCharacter * character);
    //virtual bool Involves(psItem * item);
    virtual void DeleteObjectCallback(iDeleteNotificationObject* object);

protected:
    bool CheckXMLResponse(Client* client, psNPCDialog* dlg, csString trigger);

    gemObject* target;
    int questID;
};

/* Maintains a list of all the exchanges that are ongoing.
 */
class ExchangeManager : public MessageManager<ExchangeManager>
{
public:

    ExchangeManager(ClientConnectionSet* pCCS);
    virtual ~ExchangeManager();

    static bool ExchangeCheck(Client* client, gemObject* target, csString* errorMessage = NULL);

    void StartExchange(Client* client, bool withPlayer, bool automaticExchange = false, int questID = -1);

    void HandleExchangeRequest(MsgEntry* me,Client* client);
    void HandleExchangeAccept(MsgEntry* me,Client* client);
    void HandleExchangeEnd(MsgEntry* me,Client* client);
    void HandleAutoGive(MsgEntry* me,Client* client);

    Exchange* GetExchange(int id);

    void AddExchange(Exchange* exchange)
    {
        exchanges.Push(exchange);
    }

    void DeleteExchange(Exchange* exchange);

protected:

    ClientConnectionSet* clients;

    csPDelArray<Exchange> exchanges;
};

#endif