cp_produce_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_ufo.h"
#include "cp_produce.h"
#include "cp_produce_callbacks.h"

static int produceCategory = FILTER_S_PRIMARY;

static production_t *selectedProduction = NULL;

static linkedList_t *productionItemList;

static objDef_t *selectedItem = NULL;
static storedUFO_t *selectedDisassembly = NULL;
static aircraft_t *selectedAircraft = NULL;

static const int QUEUE_SPACERS = 2;

static void PR_ClearSelected (void)
{
    selectedProduction = NULL;
    selectedAircraft = NULL;
    selectedItem = NULL;
    selectedDisassembly = NULL;
}

static void PR_UpdateProductionList (const base_t* base)
{
    int i, j, counter;
    linkedList_t *productionList = NULL;
    linkedList_t *productionQueued = NULL;
    linkedList_t *productionAmount = NULL;
    const production_queue_t *queue;

    assert(base);

    queue = &ccs.productions[base->idx];

    /* First add all the queue items ... */
    for (i = 0; i < queue->numItems; i++) {
        const production_t *prod = &queue->items[i];
        if (prod->item) {
            const objDef_t *od = prod->item;
            LIST_AddString(&productionList, va("%s", _(od->name)));
            LIST_AddString(&productionAmount, va("%i", base->storage.numItems[prod->item->idx]));
            LIST_AddString(&productionQueued, va("%i", prod->amount));
        } else if (prod->aircraft) {
            const aircraft_t *aircraftTemplate = prod->aircraft;
            LIST_AddString(&productionList, va("%s", _(aircraftTemplate->name)));
            for (j = 0, counter = 0; j < ccs.numAircraft; j++) {
                const aircraft_t *aircraftBase = AIR_AircraftGetFromIDX(j);
                assert(aircraftBase);
                if (aircraftBase->homebase == base && aircraftBase->tpl == aircraftTemplate)
                    counter++;
            }
            LIST_AddString(&productionAmount, va("%i", counter));
            LIST_AddString(&productionQueued, va("%i", prod->amount));
        } else if (prod->ufo) {
            const storedUFO_t *ufo = prod->ufo;

            LIST_AddString(&productionList, va("%s (%.0f%%)", UFO_TypeToName(ufo->ufoTemplate->ufotype), ufo->condition * 100));
            LIST_AddString(&productionAmount, va("%i", US_UFOsInStorage(ufo->ufoTemplate, ufo->installation)));
            LIST_AddString(&productionQueued, "1");
        }
    }

    /* Then spacers ... */
    for (i = 0; i < QUEUE_SPACERS; i++) {
        LIST_AddString(&productionList, "");
        LIST_AddString(&productionAmount, "");
        LIST_AddString(&productionQueued, "");
    }

    LIST_Delete(&productionItemList);

    /* Then go through all object definitions ... */
    if (produceCategory == FILTER_DISASSEMBLY) {
        storedUFO_t *ufo = NULL;
        while ((ufo = US_GetNext(ufo)) != NULL) {
            /* UFO is being transported */
            if (ufo->status != SUFO_STORED)
                continue;
            /* UFO not researched */
            if (!RS_IsResearched_ptr(ufo->ufoTemplate->tech))
                continue;
            /* The UFO is being disassembled aready */
            if (ufo->disassembly)
                continue;

            LIST_AddPointer(&productionItemList, ufo);
            LIST_AddString(&productionList, va("%s (%.0f%%)", UFO_TypeToName(ufo->ufoTemplate->ufotype), ufo->condition * 100));
            LIST_AddString(&productionAmount, va("%i", US_UFOsInStorage(ufo->ufoTemplate, ufo->installation)));
            LIST_AddString(&productionQueued, "");
        }
    } else if (produceCategory == FILTER_AIRCRAFT) {
        for (i = 0; i < ccs.numAircraftTemplates; i++) {
            aircraft_t *aircraftTemplate = &ccs.aircraftTemplates[i];
            /* don't allow producing ufos */
            if (AIR_IsUFO(aircraftTemplate))
                continue;
            if (!aircraftTemplate->tech) {
                Com_Printf("PR_UpdateProductionList: no technology for craft %s!\n", aircraftTemplate->id);
                continue;
            }

            Com_DPrintf(DEBUG_CLIENT, "air: %s ufotype: %i tech: %s time: %i\n", aircraftTemplate->id,
                    aircraftTemplate->ufotype, aircraftTemplate->tech->id, aircraftTemplate->tech->produceTime);

            if (aircraftTemplate->tech->produceTime > 0 && RS_IsResearched_ptr(aircraftTemplate->tech)) {
                LIST_AddPointer(&productionItemList, aircraftTemplate);

                LIST_AddString(&productionList, va("%s", _(aircraftTemplate->name)));
                for (j = 0, counter = 0; j < ccs.numAircraft; j++) {
                    const aircraft_t *aircraftBase = AIR_AircraftGetFromIDX(j);
                    assert(aircraftBase);
                    if (aircraftBase->homebase == base && aircraftBase->tpl == aircraftTemplate)
                        counter++;
                }
                LIST_AddString(&productionAmount, va("%i", counter));
                LIST_AddString(&productionQueued, "");
            }
        }
    } else {
        objDef_t *od;
        for (i = 0, od = csi.ods; i < csi.numODs; i++, od++) {
            const technology_t *tech;
            if (od->isVirtual)
                continue;
            tech = RS_GetTechForItem(od);
            /* We will not show items that are not producible.
             * We can only produce what was researched before. */
            if (RS_IsResearched_ptr(tech) && PR_ItemIsProduceable(od) && INV_ItemMatchesFilter(od, produceCategory)) {
                LIST_AddPointer(&productionItemList, od);

                LIST_AddString(&productionList, va("%s", _(od->name)));
                LIST_AddString(&productionAmount, va("%i", base->storage.numItems[i]));
                LIST_AddString(&productionQueued, "");
            }
        }
    }

    /* bind the menu text to our static char array */
    UI_RegisterLinkedListText(TEXT_PRODUCTION_LIST, productionList);
    /* bind the amount of available items */
    UI_RegisterLinkedListText(TEXT_PRODUCTION_AMOUNT, productionAmount);
    /* bind the amount of queued items */
    UI_RegisterLinkedListText(TEXT_PRODUCTION_QUEUED, productionQueued);
}

static void PR_ItemProductionInfo (const base_t *base, const objDef_t *od, const float percentDone)
{
    static char productionInfo[512];

    assert(base);
    assert(od);

    /* Don't try to display an item which is not producible. */
    if (!PR_ItemIsProduceable(od)) {
        Com_sprintf(productionInfo, sizeof(productionInfo), _("No item selected"));
        Cvar_Set("mn_item", "");
    } else {
        const technology_t *tech = RS_GetTechForItem(od);
        const float prodPerHour = PR_CalculateProductionPercentDone(base, tech, NULL);
        /* If you entered production menu, that means that prodPerHour > 0 (must not divide by 0) */
        const int time = ceil((1.0f - percentDone) / prodPerHour);

        Com_sprintf(productionInfo, sizeof(productionInfo), "%s\n", _(od->name));
        Q_strcat(productionInfo, va(_("Costs per item\t%i c\n"), (od->price * PRODUCE_FACTOR / PRODUCE_DIVISOR)),
            sizeof(productionInfo));
        Q_strcat(productionInfo, va(_("Production time\t%ih\n"), time), sizeof(productionInfo));
        Q_strcat(productionInfo, va(_("Item size\t%i\n"), od->size), sizeof(productionInfo));
        Cvar_Set("mn_item", od->id);
    }
    UI_RegisterText(TEXT_PRODUCTION_INFO, productionInfo);
}

static void PR_DisassemblyInfo (const base_t *base, const storedUFO_t *ufo, float percentDone)
{
    static char productionInfo[512];
    int time, i;
    float prodPerHour;

    assert(base);
    assert(ufo);
    assert(ufo->ufoTemplate);
    assert(ufo->ufoTemplate->tech);

    prodPerHour = PR_CalculateProductionPercentDone(base, ufo->ufoTemplate->tech, ufo);
    /* If you entered production menu, that means that prodPerHour > 0 (must not divide by 0) */
    assert(prodPerHour > 0);
    time = ceil((1.0f - percentDone) / prodPerHour);

    Com_sprintf(productionInfo, sizeof(productionInfo), "%s (%.0f%%) - %s\n", _(UFO_TypeToName(ufo->ufoTemplate->ufotype)), ufo->condition * 100, _("Disassembly"));
    Q_strcat(productionInfo, va(_("Stored at: %s\n"), ufo->installation->name), sizeof(productionInfo));
    Q_strcat(productionInfo, va(_("Disassembly time: %ih\n"), time), sizeof(productionInfo));
    Q_strcat(productionInfo, _("Components:\n"), sizeof(productionInfo));
    /* Print components. */
    for (i = 0; i < ufo->comp->numItemtypes; i++) {
        const objDef_t *compOd = ufo->comp->items[i];
        const int amount = (ufo->condition < 1 && ufo->comp->itemAmount2[i] != COMP_ITEMCOUNT_SCALED) ? ufo->comp->itemAmount2[i] : round(ufo->comp->itemAmount[i] * ufo->condition);

        assert(compOd);
        if (amount == 0)
            continue;

        Q_strcat(productionInfo, va("  %s (%i)\n", _(compOd->name), amount), sizeof(productionInfo));
    }
    UI_RegisterText(TEXT_PRODUCTION_INFO, productionInfo);
    Cvar_Set("mn_item", ufo->id);
}

static void PR_AircraftInfo (const base_t *base, const aircraft_t *aircraftTemplate, float percentDone)
{
    static char productionInfo[512];
    int time;
    float prodPerHour;
    assert(aircraftTemplate);

    prodPerHour = PR_CalculateProductionPercentDone(base, aircraftTemplate->tech, NULL);
    /* If you entered production menu, that means that prodPerHour > 0 (must not divide by 0) */
    assert(prodPerHour > 0);
    time = ceil((1.0f - percentDone) / prodPerHour);

    Com_sprintf(productionInfo, sizeof(productionInfo), "%s\n", _(aircraftTemplate->name));
    Q_strcat(productionInfo, va(_("Production costs\t%i c\n"), (aircraftTemplate->price * PRODUCE_FACTOR / PRODUCE_DIVISOR)),
        sizeof(productionInfo));
    assert(aircraftTemplate->tech);
    Q_strcat(productionInfo, va(_("Production time\t%ih\n"), time), sizeof(productionInfo));
    UI_RegisterText(TEXT_PRODUCTION_INFO, productionInfo);
    Cvar_Set("mn_item", aircraftTemplate->id);
}

static void PR_ProductionInfo (const base_t *base)
{
    if (selectedProduction) {
        production_t *prod = selectedProduction;
        UI_ExecuteConfunc("prod_taskselected");
        if (prod->aircraft) {
            PR_AircraftInfo(base, prod->aircraft, prod->percentDone);
            UI_ExecuteConfunc("amountsetter enable");
        } else if (prod->item) {
            PR_ItemProductionInfo(base, prod->item, prod->percentDone);
            UI_ExecuteConfunc("amountsetter enable");
        } else if (prod->ufo) {
            PR_DisassemblyInfo(base, prod->ufo, prod->percentDone);
            UI_ExecuteConfunc("amountsetter disable");
        } else {
            Com_Error(ERR_DROP, "PR_ProductionInfo: Selected production is not item nor aircraft nor ufo.\n");
        }
        Cvar_SetValue("mn_production_amount", selectedProduction->amount);
    } else {
        if (!(selectedAircraft || selectedItem || selectedDisassembly)) {
            UI_ExecuteConfunc("prod_nothingselected");
            if (produceCategory == FILTER_AIRCRAFT)
                UI_RegisterText(TEXT_PRODUCTION_INFO, _("No aircraft selected."));
            else
                UI_RegisterText(TEXT_PRODUCTION_INFO, _("No item selected"));
            Cvar_Set("mn_item", "");
        } else {
            UI_ExecuteConfunc("prod_availableselected");
            if (selectedAircraft) {
                PR_AircraftInfo(base, selectedAircraft, 0.0);
            } else if (selectedItem) {
                PR_ItemProductionInfo(base, selectedItem, 0.0);
            } else if (selectedDisassembly) {
                PR_DisassemblyInfo(base, selectedDisassembly, 0.0);
            }
        }
    }
}

static void PR_ProductionListRightClick_f (void)
{
    int num;
    production_queue_t *queue;
    base_t *base = B_GetCurrentSelectedBase();

    /* can be called from everywhere without a base set */
    if (!base)
        return;

    queue = &ccs.productions[base->idx];

    /* not enough parameters */
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <arg>\n", Cmd_Argv(0));
        return;
    }

    /* clicked which item? */
    num = atoi(Cmd_Argv(1));

    /* Clicked the production queue or the item list? */
    if (num < queue->numItems && num >= 0) {
        selectedProduction = &queue->items[num];
        if (selectedProduction->aircraft) {
            assert(selectedProduction->aircraft->tech);
            UP_OpenWith(selectedProduction->aircraft->tech->id);
        } else if (selectedProduction->item) {
            const objDef_t *od = selectedProduction->item;
            const technology_t *tech = RS_GetTechForItem(od);
            UP_OpenWith(tech->id);
        } else if (selectedProduction->ufo) {
            const aircraft_t *ufoTemplate = selectedProduction->ufo->ufoTemplate;
            const technology_t *tech = ufoTemplate->tech;
            UP_OpenWith(tech->id);
        }
    } else if (num >= queue->numItems + QUEUE_SPACERS) {
        /* Clicked in the item list. */
        const int idx = num - queue->numItems - QUEUE_SPACERS;

        if (produceCategory == FILTER_AIRCRAFT) {
            const aircraft_t *aircraftTemplate = (aircraft_t*)LIST_GetByIdx(productionItemList, idx);
            /* aircraftTemplate may be empty if rclicked below real entry.
             * UFO research definition must not have a tech assigned,
             * only RS_CRAFT types have */
            if (aircraftTemplate && aircraftTemplate->tech)
                UP_OpenWith(aircraftTemplate->tech->id);
        } else if (produceCategory == FILTER_DISASSEMBLY) {
            storedUFO_t *ufo = (storedUFO_t*)LIST_GetByIdx(productionItemList, idx);
            if (ufo && ufo->ufoTemplate && ufo->ufoTemplate->tech) {
                UP_OpenWith(ufo->ufoTemplate->tech->id);
            }
        } else {
            objDef_t *od = (objDef_t*)LIST_GetByIdx(productionItemList, idx);
            const technology_t *tech = RS_GetTechForItem(od);

            /* Open up UFOpaedia for this entry. */
            if (RS_IsResearched_ptr(tech) && INV_ItemMatchesFilter(od, produceCategory)) {
                PR_ClearSelected();
                selectedItem = od;
                UP_OpenWith(tech->id);
                return;
            }
        }
    }
#ifdef DEBUG
    else
        Com_DPrintf(DEBUG_CLIENT, "PR_ProductionListRightClick_f: Click on spacer %i\n", num);
#endif
}

static void PR_ProductionListClick_f (void)
{
    int num;
    production_queue_t *queue;
    base_t *base = B_GetCurrentSelectedBase();

    /* can be called from everywhere without a base set */
    if (!base)
        return;

    queue = &ccs.productions[base->idx];

    /* Break if there are not enough parameters. */
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <arg>\n", Cmd_Argv(0));
        return;
    }

    /* Clicked which item? */
    num = atoi(Cmd_Argv(1));

    /* Clicked the production queue or the item list? */
    if (num < queue->numItems && num >= 0) {
        selectedProduction = &queue->items[num];
        PR_ProductionInfo(base);
    } else if (num >= queue->numItems + QUEUE_SPACERS) {
        /* Clicked in the item list. */
        const int idx = num - queue->numItems - QUEUE_SPACERS;

        if (produceCategory == FILTER_DISASSEMBLY) {
            storedUFO_t *ufo = (storedUFO_t*)LIST_GetByIdx(productionItemList, idx);

            PR_ClearSelected();
            selectedDisassembly = ufo;

            PR_ProductionInfo(base);
        } else if (produceCategory == FILTER_AIRCRAFT) {
            aircraft_t *aircraftTemplate = (aircraft_t*)LIST_GetByIdx(productionItemList, idx);
            if (!aircraftTemplate) {
                Com_DPrintf(DEBUG_CLIENT, "PR_ProductionListClick_f: No item found at the list-position %i!\n", idx);
                return;
            }
            /* ufo research definition must not have a tech assigned
             * only RS_CRAFT types have
             * @sa RS_InitTree */
            if (aircraftTemplate->tech && aircraftTemplate->tech->produceTime >= 0
             && RS_IsResearched_ptr(aircraftTemplate->tech)) {
                PR_ClearSelected();
                selectedAircraft = aircraftTemplate;
                PR_ProductionInfo(base);
            }
        } else {
            objDef_t *od = (objDef_t*)LIST_GetByIdx(productionItemList, idx);
            const technology_t *tech = RS_GetTechForItem(od);

            /* We can only produce items that fulfill the following conditions... */
            if (RS_IsResearched_ptr(tech) && PR_ItemIsProduceable(od) && INV_ItemMatchesFilter(od, produceCategory)) {
                PR_ClearSelected();
                selectedItem = od;
                PR_ProductionInfo(base);
            }
        }
    }
}

static void PR_ProductionType_f (void)
{
    int cat;
    base_t *base = B_GetCurrentSelectedBase();

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

    cat = INV_GetFilterTypeID(Cmd_Argv(1));

    /* Check if the given category index is valid. */
    if (cat < 0 || cat >= MAX_FILTERTYPES)
        cat = FILTER_S_PRIMARY;

    /* Can be called from everywhere without a base set */
    if (!base)
        return;

    produceCategory = cat;
    Cvar_Set("mn_itemtype", INV_GetFilterType(produceCategory));

    /* Update list of entries for current production tab. */
    PR_UpdateProductionList(base);

    /* Reset selected entry, if it was not from the queue */
    selectedItem = NULL;
    selectedDisassembly = NULL;
    selectedAircraft = NULL;

    /* Select first entry in the list (if any). */
    if (LIST_Count(productionItemList) > 0) {
        if (produceCategory == FILTER_AIRCRAFT)
            selectedAircraft = (aircraft_t*)LIST_GetByIdx(productionItemList, 0);
        else if (produceCategory == FILTER_DISASSEMBLY)
            selectedDisassembly = (storedUFO_t*)LIST_GetByIdx(productionItemList, 0);
        else
            selectedItem = (objDef_t*)LIST_GetByIdx(productionItemList, 0);
    }
    /* update selection index if first entry of actual list was chosen */
    if (!selectedProduction)
        UI_ExecuteConfunc("prod_selectline %i", ccs.productions[base->idx].numItems + QUEUE_SPACERS);

    /* Update displayed info about selected entry (if any). */
    PR_ProductionInfo(base);
}

static void PR_ProductionList_f (void)
{
    char tmpbuf[MAX_VAR];
    int numWorkshops;
    base_t *base = B_GetCurrentSelectedBase();

    /* can be called from everywhere without a started game */
    if (!base)
        return;

    numWorkshops = max(0, B_GetNumberOfBuildingsInBaseByBuildingType(base, B_WORKSHOP));

    Cvar_SetValue("mn_production_limit", MAX_PRODUCTIONS_PER_WORKSHOP * numWorkshops);
    Cvar_SetValue("mn_production_basecap", base->capacities[CAP_WORKSPACE].max);

    /* Set amount of workers - all/ready to work (determined by base capacity. */
    PR_UpdateProductionCap(base);

    Com_sprintf(tmpbuf, sizeof(tmpbuf), "%i/%i",
        base->capacities[CAP_WORKSPACE].cur,
        E_CountHired(base, EMPL_WORKER));
    Cvar_Set("mn_production_workers", tmpbuf);

    Com_sprintf(tmpbuf, sizeof(tmpbuf), "%i/%i",
        base->capacities[CAP_ITEMS].cur,
        base->capacities[CAP_ITEMS].max);
    Cvar_Set("mn_production_storage", tmpbuf);

    PR_ClearSelected();
}

static void PR_ProductionIncrease_f (void)
{
    production_queue_t *queue;
    production_t *prod;
    base_t *base = B_GetCurrentSelectedBase();
    technology_t *tech = NULL;
    int amount = 1;
    int producibleAmount;
    static char productionPopup[UI_MAX_SMALLTEXTLEN];

    if (!base)
        return;

    if (!(selectedProduction || selectedAircraft || selectedItem || selectedDisassembly))
        return;

    if (Cmd_Argc() == 2)
        amount = atoi(Cmd_Argv(1));

    queue = &ccs.productions[base->idx];

    if (selectedProduction) {
        prod = selectedProduction;

        /* We can disassembly UFOs only one-by-one. */
        if (prod->ufo)
            return;

        if (prod->aircraft) {
            /* Don't allow to queue more aircraft if there is no free space. */
            if (AIR_CalculateHangarStorage(prod->aircraft, base, 0) <= 0) {
                UI_Popup(_("Hangars not ready"), _("You cannot queue aircraft.\nNo free space in hangars.\n"));
                Cvar_SetValue("mn_production_amount", prod->amount);
                return;
            }
        }

        /* amount limit per one production */
        if (prod->amount + amount > MAX_PRODUCTION_AMOUNT) {
            amount = max(0, MAX_PRODUCTION_AMOUNT - prod->amount);
        }
        if (amount == 0) {
            Cvar_SetValue("mn_production_amount", prod->amount);
            return;
        }

        if (prod->item) {
            tech = RS_GetTechForItem(prod->item);
        } else if (prod->aircraft) {
            tech = prod->aircraft->tech;
        }
        assert(tech);

        producibleAmount = PR_RequirementsMet(amount, &tech->requireForProduction, base);
        if (producibleAmount == 0) {
            UI_Popup(_("Not enough materials"), _("You don't have the materials needed for producing more of this item.\n"));
            Cvar_SetValue("mn_production_amount", prod->amount);
            return;
        } else if (amount != producibleAmount) {
            Com_sprintf(productionPopup, lengthof(productionPopup), _("You don't have enough material to produce all (%i) additional items. Only %i could be added."), amount, producibleAmount);
            UI_Popup(_("Not enough material!"), productionPopup);
        }

        PR_IncreaseProduction(prod, producibleAmount);
        Cvar_SetValue("mn_production_amount", prod->amount);
    } else {
        const char *name = NULL;

        /* no free production slot */
        if (PR_QueueFreeSpace(queue) <= 0) {
            UI_Popup(_("Not enough workshops"), _("You cannot queue more items.\nBuild more workshops.\n"));
            return;
        }

        if (selectedItem) {
            tech = RS_GetTechForItem(selectedItem);
            name = selectedItem->name;
        } else if (selectedAircraft) {
            tech = selectedAircraft->tech;
            name = selectedAircraft->name;
        } else if (selectedDisassembly) {
            assert(selectedDisassembly->ufoTemplate);
            tech = selectedDisassembly->ufoTemplate->tech;
            name = selectedDisassembly->ufoTemplate->name;
            amount = 1;
        }
        assert(tech);
        assert(name);

        producibleAmount = PR_RequirementsMet(amount, &tech->requireForProduction, base);
        if (producibleAmount == 0) {
            UI_Popup(_("Not enough materials"), _("You don't have the materials needed for producing this item.\n"));
            return;
        } else if (amount != producibleAmount) {
            Com_sprintf(productionPopup, lengthof(productionPopup), _("You don't have enough material to produce all (%i) items. Production will continue with a reduced (%i) number."), amount, producibleAmount);
            UI_Popup(_("Not enough material!"), productionPopup);
        }
        if (selectedAircraft && AIR_CalculateHangarStorage(selectedAircraft, base, 0) <= 0) {
            UI_Popup(_("Hangars not ready"), _("You cannot queue aircraft.\nNo free space in hangars.\n"));
            return;
        }

        /* add production */
        prod = PR_QueueNew(base, queue, selectedItem, selectedAircraft, selectedDisassembly, producibleAmount);

        if (!prod)
            return;

        /* Now we select the item we just created. */
        UI_ExecuteConfunc("prod_selectline %i", prod->idx);
        PR_ClearSelected();
        selectedProduction = &queue->items[queue->numItems - 1];

        /* messages */
        Com_sprintf(cp_messageBuffer, sizeof(cp_messageBuffer), _("Production of %s started"), _(name));
        MSO_CheckAddNewMessage(NT_PRODUCTION_STARTED, _("Production started"), cp_messageBuffer, qfalse, MSG_PRODUCTION, tech);
    }

    PR_ProductionInfo(base);
    PR_UpdateProductionList(base);
}

static void PR_ProductionStop_f (void)
{
    production_queue_t *queue;
    base_t *base = B_GetCurrentSelectedBase();
    int prodIDX;

    if (!base || !selectedProduction)
        return;

    prodIDX = selectedProduction->idx;
    queue = &ccs.productions[base->idx];

    PR_QueueDelete(base, queue, prodIDX);

    if (queue->numItems == 0) {
        selectedProduction = NULL;
        UI_ExecuteConfunc("prod_selectline -1");
    } else if (prodIDX >= queue->numItems) {
        selectedProduction = &queue->items[queue->numItems - 1];
        UI_ExecuteConfunc("prod_selectline %i", prodIDX);
    }

    PR_ProductionInfo(base);
    PR_UpdateProductionList(base);
}

static void PR_ProductionDecrease_f (void)
{
    int amount = 1;
    base_t *base = B_GetCurrentSelectedBase();
    production_t *prod = selectedProduction;

    if (Cmd_Argc() == 2)
        amount = atoi(Cmd_Argv(1));

    if (!prod)
        return;

    if (prod->amount <= amount) {
        PR_ProductionStop_f();
        return;
    }

    PR_DecreaseProduction(prod, amount);

    if (base) {
        PR_ProductionInfo(base);
        PR_UpdateProductionList(base);
    }
}

static void PR_ProductionChange_f (void)
{
    int amount;

    if (!(selectedProduction || selectedAircraft || selectedItem || selectedDisassembly))
        return;

    if (Cmd_Argc() != 2) {
        Com_Printf("Usage: %s <diff> : change the production amount\n", Cmd_Argv(0));
        return;
    }

    amount = atoi(Cmd_Argv(1));
    if (amount > 0) {
        Cbuf_AddText(va("prod_inc %i\n", amount));
    } else {
        Cbuf_AddText(va("prod_dec %i\n", -amount));
    }
}

static void PR_ProductionUp_f (void)
{
    production_queue_t *queue;
    base_t *base = B_GetCurrentSelectedBase();

    if (!base || !selectedProduction)
        return;

    /* first position already */
    if (selectedProduction->idx == 0)
        return;

    queue = &ccs.productions[base->idx];
    PR_QueueMove(queue, selectedProduction->idx, -1);

    selectedProduction = &queue->items[selectedProduction->idx - 1];
    UI_ExecuteConfunc("prod_selectline %i", selectedProduction->idx);
    PR_UpdateProductionList(base);
}

static void PR_ProductionDown_f (void)
{
    production_queue_t *queue;
    base_t *base = B_GetCurrentSelectedBase();

    if (!base || !selectedProduction)
        return;

    queue = &ccs.productions[base->idx];

    if (selectedProduction->idx >= queue->numItems - 1)
        return;

    PR_QueueMove(queue, selectedProduction->idx, 1);

    selectedProduction = &queue->items[selectedProduction->idx + 1];
    UI_ExecuteConfunc("prod_selectline %i", selectedProduction->idx);
    PR_UpdateProductionList(base);
}

void PR_InitCallbacks (void)
{
    Cmd_AddCommand("prod_init", PR_ProductionList_f, NULL);
    Cmd_AddCommand("prod_type", PR_ProductionType_f, NULL);
    Cmd_AddCommand("prod_up", PR_ProductionUp_f, "Move production item up in the queue");
    Cmd_AddCommand("prod_down", PR_ProductionDown_f, "Move production item down in the queue");
    Cmd_AddCommand("prod_change", PR_ProductionChange_f, "Change production amount");
    Cmd_AddCommand("prod_inc", PR_ProductionIncrease_f, "Increase production amount");
    Cmd_AddCommand("prod_dec", PR_ProductionDecrease_f, "Decrease production amount");
    Cmd_AddCommand("prod_stop", PR_ProductionStop_f, "Stop production");
    Cmd_AddCommand("prodlist_rclick", PR_ProductionListRightClick_f, NULL);
    Cmd_AddCommand("prodlist_click", PR_ProductionListClick_f, NULL);
}

void PR_ShutdownCallbacks (void)
{
    Cmd_RemoveCommand("prod_init");
    Cmd_RemoveCommand("prod_type");
    Cmd_RemoveCommand("prod_up");
    Cmd_RemoveCommand("prod_down");
    Cmd_RemoveCommand("prod_change");
    Cmd_RemoveCommand("prod_inc");
    Cmd_RemoveCommand("prod_dec");
    Cmd_RemoveCommand("prod_stop");
    Cmd_RemoveCommand("prodlist_rclick");
    Cmd_RemoveCommand("prodlist_click");
}