cp_market_callbacks.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 UFO: Alien Invasion.

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; either version 2
of the License, or (at your option) any later version.

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.

*/

#include "../cl_shared.h"
#include "../cl_inventory.h"
#include "../ui/ui_main.h"
#include "../ui/ui_popup.h"
#include "cp_campaign.h"
#include "cp_market.h"
#include "cp_market_callbacks.h"

#define MAX_BUYLIST     64

#define MAX_MARKET_MENU_ENTRIES 22

typedef struct buyListEntry_s {
    const objDef_t *item;           
    const ugv_t *ugv;               
    const aircraft_t *aircraft; 
} buyListEntry_t;

typedef struct buyList_s {
    buyListEntry_t l[MAX_BUYLIST];  
    int length;     
    int scroll;     
} buyList_t;

static buyList_t buyList;   
static const objDef_t *currentSelectedMenuEntry;    
static int buyCat = FILTER_S_PRIMARY;   
static const int MAX_BS_FACTORS = 500;

static qboolean BS_AircraftIsOnMarket (const aircraft_t *aircraft)
{
    return aircraft->type != AIRCRAFT_UFO && aircraft->price != -1;
}

static inline int BS_GetBuySellFactor (void)
{
    return 1;
}

static const objDef_t *BS_GetObjectDefition (const buyListEntry_t *entry)
{
    assert(entry);
    if (entry->item)
        return entry->item;
    else if (entry->ugv)
        return NULL;
    else if (entry->aircraft)
        return NULL;

    Com_Error(ERR_DROP, "You should not check an empty buy list entry");
}


static void BS_MarketAircraftDescription (const aircraft_t *aircraftTemplate)
{
    const technology_t *tech;

    /* Break if no aircraft was given or if  it's no sample-aircraft (i.e. template). */
    if (!aircraftTemplate || aircraftTemplate != aircraftTemplate->tpl)
        return;

    tech = aircraftTemplate->tech;
    assert(tech);
    UP_AircraftDescription(tech);
    Cvar_Set("mn_aircraftname", _(aircraftTemplate->name));
    Cvar_Set("mn_item", aircraftTemplate->id);
}


static int BS_GetStorageAmountInBase (const base_t* base, const char *aircraftID)
{
    aircraft_t *aircraft;
    int storage = 0;

    assert(base);

    /* Get storage amount in the base. */
    aircraft = NULL;
    while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL) {
        if (!strcmp(aircraft->id, aircraftID))
            storage++;
    }
    return storage;
}

static inline qboolean BS_GetMinMaxValueByItemID (const base_t *base, int itemNum, int *min, int *max, int *value)
{
    assert(base);

    if (itemNum < 0 || itemNum + buyList.scroll >= buyList.length)
        return qfalse;

    if (buyCat == FILTER_UGVITEM && buyList.l[itemNum + buyList.scroll].ugv) {
        *min = 0;
        *value = 10000;
        *max = 20000;
    } else if (buyCat == FILTER_AIRCRAFT && buyList.l[itemNum + buyList.scroll].aircraft) {
        const aircraft_t *aircraft = buyList.l[itemNum + buyList.scroll].aircraft;
        if (!aircraft)
            return qfalse;
        *value = BS_GetStorageAmountInBase(base, aircraft->id);
        *max = BS_GetStorageAmountInBase(base, aircraft->id) + BS_GetAircraftOnMarket(aircraft);
        *min = 0;
    } else {
        const objDef_t *item = BS_GetObjectDefition(&buyList.l[itemNum + buyList.scroll]);
        if (!item)
            return qfalse;
        *value = base->storage.numItems[item->idx];
        *max = base->storage.numItems[item->idx] + ccs.eMarket.numItems[item->idx];
        *min = 0;
    }

    return qtrue;
}

static void BS_UpdateItem (const base_t *base, int itemNum)
{
    int min, max, value;

    if (BS_GetMinMaxValueByItemID(base, itemNum, &min, &max, &value))
        UI_ExecuteConfunc("buy_updateitem %d %d %d %d", itemNum, value, min, max);
}

static void BS_MarketScroll_f (void)
{
    int i;
    base_t *base = B_GetCurrentSelectedBase();

    if (!base || buyCat >= MAX_FILTERTYPES || buyCat < 0)
        return;

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <scrollpos>\n", Cmd_Argv(0));
        return;
    }

    buyList.scroll = atoi(Cmd_Argv(1));
    assert(buyList.scroll >= 0);
    assert(!((buyList.length > MAX_MARKET_MENU_ENTRIES && buyList.scroll >= buyList.length - MAX_MARKET_MENU_ENTRIES)));

    /* now update the menu pics */
    for (i = 0; i < MAX_MARKET_MENU_ENTRIES; i++) {
        UI_ExecuteConfunc("buy_autoselli %i", i);
    }

    /* get item list */
    for (i = buyList.scroll; i < buyList.length - buyList.scroll; i++) {
        if (i >= MAX_MARKET_MENU_ENTRIES)
            break;
        else {
            const objDef_t *od = BS_GetObjectDefition(&buyList.l[i]);
            /* Check whether the item matches the proper filter, storage in current base and market. */
            if (od && (base->storage.numItems[od->idx] || ccs.eMarket.numItems[od->idx]) && INV_ItemMatchesFilter(od, buyCat)) {
                UI_ExecuteConfunc("buy_show %i", i - buyList.scroll);
                BS_UpdateItem(base, i - buyList.scroll);
                if (ccs.eMarket.autosell[od->idx])
                    UI_ExecuteConfunc("buy_autoselle %i", i - buyList.scroll);
                else
                    UI_ExecuteConfunc("buy_autoselld %i", i - buyList.scroll);
            }
        }
    }
}

static void BS_MarketClick_f (void)
{
    int num;

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <num>\n", Cmd_Argv(0));
        return;
    }

    num = atoi(Cmd_Argv(1));
    if (num >= buyList.length || num < 0)
        return;

    Cvar_Set("mn_item", "");

    switch (buyCat) {
    case FILTER_AIRCRAFT:
        assert(buyList.l[num].aircraft);
        BS_MarketAircraftDescription(buyList.l[num].aircraft->tpl);
        break;
    case FILTER_CRAFTITEM:
        UP_AircraftItemDescription(buyList.l[num].item);
        Cvar_Set("mn_aircraftname", "");
        break;
    case FILTER_UGVITEM:
        if (buyList.l[num].ugv) {
            UP_UGVDescription(buyList.l[num].ugv);
            currentSelectedMenuEntry = NULL;
        } else {
            INV_ItemDescription(buyList.l[num].item);
            currentSelectedMenuEntry = buyList.l[num].item;
        }
        break;
    case MAX_FILTERTYPES:
        break;
    default:
        INV_ItemDescription(buyList.l[num].item);
        currentSelectedMenuEntry = buyList.l[num].item;
        break;
    }

    /* update selected element */
    UI_ExecuteConfunc("buy_selectitem %i", num);
}

static void BS_MarketInfoClick_f (void)
{
    const technology_t *tech = RS_GetTechByProvided(Cvar_GetString("mn_item"));

    if (tech)
        UP_OpenWith(tech->id);
}

static linkedList_t *bsMarketNames;
static linkedList_t *bsMarketStorage;
static linkedList_t *bsMarketMarket;
static linkedList_t *bsMarketPrices;

static void BS_AddToList (const char *name, int storage, int market, int price)
{
    LIST_AddString(&bsMarketNames, _(name));
    LIST_AddString(&bsMarketStorage, va("%i", storage));
    LIST_AddString(&bsMarketMarket, va("%i", market));
    LIST_AddString(&bsMarketPrices, va(_("%i c"), price));
}

static void BS_BuyType (const base_t *base)
{
    const objDef_t *od;
    int i, j = 0;
    char tmpbuf[MAX_VAR];

    if (!base || buyCat >= MAX_FILTERTYPES || buyCat < 0)
        return;

    CL_UpdateCredits(ccs.credits);

    bsMarketNames = NULL;
    bsMarketStorage = NULL;
    bsMarketMarket = NULL;
    bsMarketPrices = NULL;
    UI_ResetData(TEXT_ITEMDESCRIPTION);

    /* 'normal' items */
    switch (buyCat) {
    case FILTER_AIRCRAFT:   /* Aircraft */
        {
        const technology_t* tech;
        const aircraft_t *aircraftTemplate;
        for (i = 0, j = 0, aircraftTemplate = ccs.aircraftTemplates; i < ccs.numAircraftTemplates; i++, aircraftTemplate++) {
            if (!BS_AircraftIsOnMarket(aircraftTemplate))
                continue;
            tech = aircraftTemplate->tech;
            assert(tech);
            if (BS_GetStorageAmountInBase(base, aircraftTemplate->id) + BS_GetAircraftOnMarket(aircraftTemplate) > 0) {
                if (j >= buyList.scroll && j < MAX_MARKET_MENU_ENTRIES) {
                    UI_ExecuteConfunc("buy_autoselli %i", j - buyList.scroll);
                    UI_ExecuteConfunc("buy_show %i", j - buyList.scroll);
                }
                BS_AddToList(aircraftTemplate->name, BS_GetStorageAmountInBase(base, aircraftTemplate->id),
                        BS_GetAircraftOnMarket(aircraftTemplate), BS_GetAircraftBuyingPrice(aircraftTemplate));
                if (j >= MAX_BUYLIST)
                    Com_Error(ERR_DROP, "Increase the MAX_BUYLIST value to handle that much items\n");
                buyList.l[j].item = NULL;
                buyList.l[j].ugv = NULL;
                buyList.l[j].aircraft = aircraftTemplate;
                buyList.length = j + 1;
                BS_UpdateItem(base, j - buyList.scroll);
                j++;
            }
        }
        }
        break;
    case FILTER_CRAFTITEM:  /* Aircraft items */
        /* get item list */
        for (i = 0, j = 0, od = csi.ods; i < csi.numODs; i++, od++) {
            if (!BS_IsOnMarket(od))
                continue;
            /* Check whether the item matches the proper filter, storage in current base and market. */
            if ((base->storage.numItems[i] || ccs.eMarket.numItems[i])
             && INV_ItemMatchesFilter(od, FILTER_CRAFTITEM)) {
                if (j >= buyList.scroll && j < MAX_MARKET_MENU_ENTRIES) {
                    UI_ExecuteConfunc("buy_show %i", j - buyList.scroll);
                    if (ccs.eMarket.autosell[i])
                        UI_ExecuteConfunc("buy_autoselle %i", j - buyList.scroll);
                    else
                        UI_ExecuteConfunc("buy_autoselld %i", j - buyList.scroll);
                }
                BS_AddToList(od->name, base->storage.numItems[i], ccs.eMarket.numItems[i], BS_GetItemBuyingPrice(od));
                if (j >= MAX_BUYLIST)
                    Com_Error(ERR_DROP, "Increase the MAX_FILTERLIST value to handle that much items\n");
                buyList.l[j].item = od;
                buyList.l[j].ugv = NULL;
                buyList.l[j].aircraft = NULL;
                buyList.length = j + 1;
                BS_UpdateItem(base, j - buyList.scroll);
                j++;
            }
        }
        break;
    case FILTER_UGVITEM:    /* Heavy equipment like UGVs and it's weapons/ammo. */
        {
        /* Get item list. */
        j = 0;
        for (i = 0; i < csi.numUGV; i++) {
            ugv_t *ugv = &csi.ugvs[i];
            const technology_t* tech = RS_GetTechByProvided(ugv->id);
            assert(tech);
            if (RS_IsResearched_ptr(tech)) {
                const int hiredRobot = E_CountHiredRobotByType(base, ugv);
                const int unhiredRobot = E_CountUnhiredRobotsByType(ugv);

                if (hiredRobot + unhiredRobot <= 0)
                    continue;

                if (j >= buyList.scroll && j < MAX_MARKET_MENU_ENTRIES) {
                    UI_ExecuteConfunc("buy_show %i", j - buyList.scroll);
                }

                BS_AddToList(tech->name,
                    hiredRobot,         /* numInStorage */
                    unhiredRobot,           /* numOnMarket */
                    ugv->price);

                if (j >= MAX_BUYLIST)
                    Com_Error(ERR_DROP, "Increase the MAX_BUYLIST value to handle that much entries.\n");
                buyList.l[j].item = NULL;
                buyList.l[j].ugv = ugv;
                buyList.l[j].aircraft = NULL;
                buyList.length = j + 1;
                BS_UpdateItem(base, j - buyList.scroll);
                j++;
            }
        }

        for (i = 0, od = csi.ods; i < csi.numODs; i++, od++) {
            if (!BS_IsOnMarket(od))
                continue;

            /* Check whether the item matches the proper filter, storage in current base and market. */
            if (INV_ItemMatchesFilter(od, FILTER_UGVITEM) && (base->storage.numItems[i] || ccs.eMarket.numItems[i])) {
                BS_AddToList(od->name, base->storage.numItems[i], ccs.eMarket.numItems[i], BS_GetItemBuyingPrice(od));
                /* Set state of Autosell button. */
                if (j >= buyList.scroll && j < MAX_MARKET_MENU_ENTRIES) {
                    UI_ExecuteConfunc("buy_show %i", j - buyList.scroll);
                    if (ccs.eMarket.autosell[i])
                        UI_ExecuteConfunc("buy_autoselle %i", j - buyList.scroll);
                    else
                        UI_ExecuteConfunc("buy_autoselld %i", j - buyList.scroll);
                }

                if (j >= MAX_BUYLIST)
                    Com_Error(ERR_DROP, "Increase the MAX_BUYLIST value to handle that much items\n");
                buyList.l[j].item = od;
                buyList.l[j].ugv = NULL;
                buyList.l[j].aircraft = NULL;
                buyList.length = j + 1;
                BS_UpdateItem(base, j - buyList.scroll);
                j++;
            }
        }
        }
        break;
    default:    /* Normal items */
        if (buyCat < MAX_SOLDIER_FILTERTYPES || buyCat == FILTER_DUMMY) {
            /* get item list */
            for (i = 0, j = 0, od = csi.ods; i < csi.numODs; i++, od++) {
                if (!BS_IsOnMarket(od))
                    continue;
                /* Check whether the item matches the proper filter, storage in current base and market. */
                if ((base->storage.numItems[i] || ccs.eMarket.numItems[i]) && INV_ItemMatchesFilter(od, buyCat)) {
                    BS_AddToList(od->name, base->storage.numItems[i], ccs.eMarket.numItems[i], BS_GetItemBuyingPrice(od));
                    /* Set state of Autosell button. */
                    if (j >= buyList.scroll && j < MAX_MARKET_MENU_ENTRIES) {
                        UI_ExecuteConfunc("buy_show %i", j - buyList.scroll);
                        if (ccs.eMarket.autosell[i])
                            UI_ExecuteConfunc("buy_autoselle %i", j - buyList.scroll);
                        else
                            UI_ExecuteConfunc("buy_autoselld %i", j - buyList.scroll);
                    }

                    if (j >= MAX_BUYLIST)
                        Com_Error(ERR_DROP, "Increase the MAX_BUYLIST value to handle that much items\n");
                    buyList.l[j].item = od;
                    buyList.l[j].ugv = NULL;
                    buyList.l[j].aircraft = NULL;
                    buyList.length = j + 1;
                    BS_UpdateItem(base, j - buyList.scroll);
                    j++;
                }
            }
        }
        break;
    }

    for (; j < MAX_MARKET_MENU_ENTRIES; j++) {
        /* Hide the rest of the entries. */
        UI_ExecuteConfunc("buy_autoselli %i", j);
        UI_ExecuteConfunc("buy_hide %i", j);
    }

    /* Update some menu cvars. */
    /* Set up base capacities. */
    Com_sprintf(tmpbuf, sizeof(tmpbuf), "%i/%i", base->capacities[CAP_ITEMS].cur,
        base->capacities[CAP_ITEMS].max);
    Cvar_Set("mn_bs_storage", tmpbuf);

    /* select first item */
    if (buyList.length) {
        switch (buyCat) {   
        case FILTER_AIRCRAFT:
            BS_MarketAircraftDescription(buyList.l[0].aircraft);
            break;
        case FILTER_CRAFTITEM:
            Cvar_Set("mn_aircraftname", "");    
            /* Select current item or first one. */
            if (currentSelectedMenuEntry)
                UP_AircraftItemDescription(currentSelectedMenuEntry);
            else
                UP_AircraftItemDescription(buyList.l[0].item);
            break;
        case FILTER_UGVITEM:
            if (currentSelectedMenuEntry)
                INV_ItemDescription(currentSelectedMenuEntry);
            else if (buyList.l[0].ugv)
                UP_UGVDescription(buyList.l[0].ugv);
            else if (buyList.l[0].item)
                INV_ItemDescription(buyList.l[0].item);
            break;
        default:
            assert(buyCat != MAX_FILTERTYPES);
            /* Select current item or first one. */
            if (currentSelectedMenuEntry)
                INV_ItemDescription(currentSelectedMenuEntry);
            else
                INV_ItemDescription(buyList.l[0].item);
            break;
        }
    } else {
        /* reset description */
        INV_ItemDescription(NULL);
    }

    UI_RegisterLinkedListText(TEXT_MARKET_NAMES, bsMarketNames);
    UI_RegisterLinkedListText(TEXT_MARKET_STORAGE, bsMarketStorage);
    UI_RegisterLinkedListText(TEXT_MARKET_MARKET, bsMarketMarket);
    UI_RegisterLinkedListText(TEXT_MARKET_PRICES, bsMarketPrices);
}

static void BS_BuyType_f (void)
{
    base_t *base = B_GetCurrentSelectedBase();

    if (Cmd_Argc() == 2) {
        buyCat = INV_GetFilterTypeID(Cmd_Argv(1));

        if (buyCat == FILTER_DISASSEMBLY)
            buyCat--;
        if (buyCat < 0) {
            buyCat = MAX_FILTERTYPES - 1;
            if (buyCat == FILTER_DISASSEMBLY)
                buyCat--;
        } else if (buyCat >= MAX_FILTERTYPES) {
            buyCat = 0;
        }

        Cvar_Set("mn_itemtype", INV_GetFilterType(buyCat));
        currentSelectedMenuEntry = NULL;
    }

    BS_BuyType(base);
    buyList.scroll = 0;
    UI_ExecuteConfunc("sync_market_scroll 0 %d", buyList.scroll);
    UI_ExecuteConfunc("market_scroll %d", buyList.scroll);
    UI_ExecuteConfunc("market_click 0");
}

static void BS_BuyAircraft_f (void)
{
    int num;
    const aircraft_t *aircraftTemplate;
    base_t *base = B_GetCurrentSelectedBase();

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <num>\n", Cmd_Argv(0));
        return;
    }

    if (!base)
        return;

    num = atoi(Cmd_Argv(1));
    if (num < 0 || num >= buyList.length)
        return;

    if (buyCat == FILTER_AIRCRAFT) {
        int freeSpace;
        /* We cannot buy aircraft if there is no power in our base. */
        if (!B_GetBuildingStatus(base, B_POWER)) {
            UI_Popup(_("Note"), _("No power supplies in this base.\nHangars are not functional."));
            return;
        }
        /* We cannot buy aircraft without any hangar. */
        if (!B_GetBuildingStatus(base, B_HANGAR) && !B_GetBuildingStatus(base, B_SMALL_HANGAR)) {
            UI_Popup(_("Note"), _("Build a hangar first."));
            return;
        }
        aircraftTemplate = buyList.l[num].aircraft;
        freeSpace = AIR_CalculateHangarStorage(aircraftTemplate, base, 0);

        /* Check free space in hangars. */
        if (freeSpace < 0) {
            Com_Printf("BS_BuyAircraft_f: something bad happened, AIR_CalculateHangarStorage returned -1!\n");
            return;
        }

        if (freeSpace == 0) {
            UI_Popup(_("Notice"), _("You cannot buy this aircraft.\nNot enough space in hangars.\n"));
            return;
        } else {
            const int price = BS_GetAircraftBuyingPrice(aircraftTemplate);
            if (ccs.credits < price) {
                UI_Popup(_("Notice"), _("You cannot buy this aircraft.\nNot enough credits.\n"));
                return;
            } else {
                /* Hangar capacities are being updated in AIR_NewAircraft().*/
                BS_RemoveAircraftFromMarket(aircraftTemplate, 1);
                CL_UpdateCredits(ccs.credits - price);
                AIR_NewAircraft(base, aircraftTemplate->id);
                Cmd_ExecuteString(va("buy_type %s", INV_GetFilterType(FILTER_AIRCRAFT)));
            }
        }
    }
}

static void BS_SellAircraft_f (void)
{
    int num;
    base_t *base = B_GetCurrentSelectedBase();

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <num>\n", Cmd_Argv(0));
        return;
    }

    if (!base)
        return;

    num = atoi(Cmd_Argv(1));
    if (num < 0 || num >= buyList.length)
        return;

    if (buyCat == FILTER_AIRCRAFT) {
        qboolean aircraftOutNote = qfalse;
        qboolean teamNote = qfalse;
        qboolean found = qfalse;
        aircraft_t *aircraft;
        const aircraft_t *aircraftTemplate = buyList.l[num].aircraft;
        if (!aircraftTemplate)
            return;

        aircraft = NULL;
        while ((aircraft = AIR_GetNextFromBase(base, aircraft)) != NULL) {
            if (!strcmp(aircraft->id, aircraftTemplate->id)) {
                if (AIR_GetTeamSize(aircraft) > 0) {
                    teamNote = qtrue;
                    continue;
                }
                if (!AIR_IsAircraftInBase(aircraft)) {
                    /* aircraft is not in base */
                    aircraftOutNote = qtrue;
                    continue;
                }
                found = qtrue;
                break;
            }
        }
        /* ok, we've found an empty aircraft (no team) in a base
         * so now we can sell it */
        if (found) {
            int j;
            /* sell off any items which are mounted on it */
            for (j = 0; j < aircraft->maxWeapons; j++) {
                BS_ProcessCraftItemSale(aircraft->weapons[j].item, 1);
                BS_ProcessCraftItemSale(aircraft->weapons[j].ammo, 1);
            }

            BS_ProcessCraftItemSale(aircraft->shield.item, 1);
            /* there should be no ammo here, but checking can't hurt */
            BS_ProcessCraftItemSale(aircraft->shield.ammo, 1);

            for (j = 0; j < aircraft->maxElectronics; j++) {
                BS_ProcessCraftItemSale(aircraft->electronics[j].item, 1);
                /* there should be no ammo here, but checking can't hurt */
                BS_ProcessCraftItemSale(aircraft->electronics[j].ammo, 1);
            }

            Com_DPrintf(DEBUG_CLIENT, "BS_SellAircraft_f: Selling aircraft with IDX %i\n", aircraft->idx);
            /* the capacities are also updated here */
            BS_AddAircraftToMarket(aircraft, 1);
            CL_UpdateCredits(ccs.credits + BS_GetAircraftSellingPrice(aircraft));

            AIR_DeleteAircraft(aircraft);

            /* reinit the menu */
            BS_BuyType(base);
        } else {
            if (teamNote)
                UI_Popup(_("Note"), _("You can't sell an aircraft if it still has a team assigned"));
            else if (aircraftOutNote)
                UI_Popup(_("Note"), _("You can't sell an aircraft that is not in base"));
            else
                Com_DPrintf(DEBUG_CLIENT, "BS_SellAircraft_f: There are no aircraft available (with no team assigned) for selling\n");
        }
    }
}

static void BS_BuyItem_f (void)
{
    int num;
    base_t *base = B_GetCurrentSelectedBase();

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <num>\n", Cmd_Argv(0));
        return;
    }

    if (!base)
        return;

    if (buyCat == FILTER_AIRCRAFT) {
        Com_DPrintf(DEBUG_CLIENT, "BS_BuyItem_f: Redirects to BS_BuyAircraft_f\n");
        BS_BuyAircraft_f();
        return;
    }

    num = atoi(Cmd_Argv(1));
    if (num < 0 || num >= buyList.length)
        return;

    UI_ExecuteConfunc("buy_selectitem %i", num + buyList.scroll);

    if (buyCat == FILTER_UGVITEM && buyList.l[num + buyList.scroll].ugv) {
        /* The list entry is an actual ugv/robot */
        const ugv_t *ugv = buyList.l[num + buyList.scroll].ugv;

        UP_UGVDescription(ugv);

        if (ccs.credits >= ugv->price && E_CountUnhiredRobotsByType(ugv) > 0) {
            qboolean ugvWeaponBuyable;
            /* Check if we have a weapon for this ugv in the market and there is enough storage-room for it. */
            const objDef_t *ugvWeapon = INVSH_GetItemByID(ugv->weapon);
            if (!ugvWeapon)
                Com_Error(ERR_DROP, "BS_BuyItem_f: Could not get weapon '%s' for ugv/tank '%s'.", ugv->weapon, ugv->id);

            ugvWeaponBuyable = qtrue;
            if (!ccs.eMarket.numItems[ugvWeapon->idx])
                ugvWeaponBuyable = qfalse;

            if (base->capacities[CAP_ITEMS].max - base->capacities[CAP_ITEMS].cur <
                UGV_SIZE + ugvWeapon->size) {
                UI_Popup(_("Not enough storage space"), _("You cannot buy this item.\nNot enough space in storage.\nBuild more storage facilities."));
                ugvWeaponBuyable = qfalse;
            }

            if (ugvWeaponBuyable && E_HireRobot(base, ugv)) {
                /* Move the item into the storage. */
                B_UpdateStorageAndCapacity(base, ugvWeapon, 1, qfalse, qfalse);
                BS_RemoveItemFromMarket(ugvWeapon, 1);

                /* Update Display/List and credits. */
                BS_BuyType(base);
                CL_UpdateCredits(ccs.credits - ugv->price); 
            } else {
                Com_Printf("Could not buy this item.\n");
            }
        }
    } else {
        /* Normal item (or equipment for UGVs/Robots if buyCategory==BUY_HEAVY) */
        const objDef_t *item = BS_GetObjectDefition(&buyList.l[num + buyList.scroll]);
        assert(item);
        currentSelectedMenuEntry = item;
        INV_ItemDescription(item);
        Com_DPrintf(DEBUG_CLIENT, "BS_BuyItem_f: item %s\n", item->id);
        BS_CheckAndDoBuyItem(base, item, BS_GetBuySellFactor());
        /* reinit the menu */
        BS_BuyType(base);
        BS_UpdateItem(base, num);
    }
}

static void BS_SellItem_f (void)
{
    int num;
    base_t *base = B_GetCurrentSelectedBase();

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <num>\n", Cmd_Argv(0));
        return;
    }

    if (!base)
        return;

    if (buyCat == FILTER_AIRCRAFT) {
        Com_DPrintf(DEBUG_CLIENT, "BS_SellItem_f: Redirects to BS_SellAircraft_f\n");
        BS_SellAircraft_f();
        return;
    }

    num = atoi(Cmd_Argv(1));
    if (num < 0 || num >= buyList.length)
        return;

    UI_ExecuteConfunc("buy_selectitem %i", num + buyList.scroll);
    if (buyCat == FILTER_UGVITEM && buyList.l[num + buyList.scroll].ugv) {
        employee_t *employee;
        /* The list entry is an actual ugv/robot */
        const ugv_t *ugv = buyList.l[num + buyList.scroll].ugv;
        const objDef_t *ugvWeapon;

        UP_UGVDescription(ugv);

        /* Check if we have a weapon for this ugv in the market to sell it. */
        ugvWeapon = INVSH_GetItemByID(ugv->weapon);
        if (!ugvWeapon)
            Com_Error(ERR_DROP, "BS_BuyItem_f: Could not get wepaon '%s' for ugv/tank '%s'.", ugv->weapon, ugv->id);

        employee = E_GetHiredRobot(base, ugv);
        if (!E_UnhireEmployee(employee)) {
            Com_DPrintf(DEBUG_CLIENT, "Couldn't sell/fire robot/ugv.\n");
        } else {
            if (base->storage.numItems[ugvWeapon->idx]) {
                /* If we have a weapon we sell it as well. */
                B_UpdateStorageAndCapacity(base, ugvWeapon, -1, qfalse, qfalse);
                BS_AddItemToMarket(ugvWeapon, 1);
            }
            BS_BuyType(base);
            CL_UpdateCredits(ccs.credits + ugv->price); 
        }
    } else {
        const objDef_t *item = BS_GetObjectDefition(&buyList.l[num + buyList.scroll]);
        /* don't sell more items than we have */
        const int numItems = min(base->storage.numItems[item->idx], BS_GetBuySellFactor());
        /* Normal item (or equipment for UGVs/Robots if buyCategory==BUY_HEAVY) */
        assert(item);
        currentSelectedMenuEntry = item;
        INV_ItemDescription(item);

        /* don't sell more items than we have */
        if (numItems) {
            /* reinit the menu */
            B_UpdateStorageAndCapacity(base, item, -numItems, qfalse, qfalse);
            BS_AddItemToMarket(item, numItems);
            BS_BuyType(base);
            CL_UpdateCredits(ccs.credits + BS_GetItemSellingPrice(item) * numItems);
            BS_UpdateItem(base, num);
        }
    }
}

static void BS_BuySellItem_f (void)
{
    float value;

    if (Cmd_Argc() < 3) {
        /* num is used in the other callbacks to do the real buy or sell */
        Com_Printf("Usage: %s <num> <value>\n", Cmd_Argv(0));
        return;
    }

    value = atof(Cmd_Argv(2));
    if (value == 0)
        return;

    if (value > 0) {
        BS_BuyItem_f();
    } else {
        BS_SellItem_f();
    }
}

static void BS_Autosell_f (void)
{
    int num;
    const objDef_t *item;
    base_t *base = B_GetCurrentSelectedBase();

    /* Can be called from everywhere. */
    if (!base)
        return;

    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <num>\n", Cmd_Argv(0));
        return;
    }

    num = atoi(Cmd_Argv(1));
    Com_DPrintf(DEBUG_CLIENT, "BS_Autosell_f: listnumber %i\n", num);
    if (num < 0 || num >= buyList.length)
        return;

    item = BS_GetObjectDefition(&buyList.l[num + buyList.scroll]);
    assert(item);

    if (ccs.eMarket.autosell[item->idx]) {
        ccs.eMarket.autosell[item->idx] = qfalse;
        Com_DPrintf(DEBUG_CLIENT, "item name: %s, autosell false\n", item->name);
    } else {
        const technology_t *tech = RS_GetTechForItem(item);
        /* Don't allow to enable autosell for items not researched. */
        if (!RS_IsResearched_ptr(tech))
            return;
        ccs.eMarket.autosell[item->idx] = qtrue;
        Com_DPrintf(DEBUG_CLIENT, "item name: %s, autosell true\n", item->name);
    }

    /* Reinit the menu. */
    BS_BuyType(base);
}



void BS_InitCallbacks(void)
{
    Cmd_AddCommand("buy_type", BS_BuyType_f, NULL);
    Cmd_AddCommand("market_click", BS_MarketClick_f, "Click function for buy menu text node");
    Cmd_AddCommand("market_scroll", BS_MarketScroll_f, "Scroll function for buy menu");
    Cmd_AddCommand("mn_buysell", BS_BuySellItem_f, NULL);
    Cmd_AddCommand("mn_buy", BS_BuyItem_f, NULL);
    Cmd_AddCommand("mn_sell", BS_SellItem_f, NULL);
    Cmd_AddCommand("buy_autosell", BS_Autosell_f, "Enable or disable autosell option for given item.");
    Cmd_AddCommand("market_openpedia", BS_MarketInfoClick_f, "Open UFOPedia entry for selected item");

    memset(&buyList, 0, sizeof(buyList));
    buyList.length = -1;
}

void BS_ShutdownCallbacks(void)
{
    Cmd_RemoveCommand("buy_type");
    Cmd_RemoveCommand("market_click");
    Cmd_RemoveCommand("market_scroll");
    Cmd_RemoveCommand("mn_buysell");
    Cmd_RemoveCommand("mn_buy");
    Cmd_RemoveCommand("mn_sell");
    Cmd_RemoveCommand("buy_autosell");
    Cmd_RemoveCommand("market_openpedia");
}