ui_node_base.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 "../ui_main.h"
#include "../ui_parse.h"
#include "../ui_tooltip.h"
#include "../ui_nodes.h"
#include "../ui_render.h"
#include "ui_node_base.h"
#include "ui_node_abstractnode.h"

#include "../../client.h"
#include "../../campaign/cp_campaign.h"

#define EXTRADATA_TYPE baseExtraData_t
#define EXTRADATA(node) UI_EXTRADATA(node, baseExtraData_t)

static void UI_AbstractBaseNodeLoaded (uiNode_t * node)
{
    const int id = EXTRADATA(node).baseid;
    if (id < 0 || id >= MAX_BASES) {
        Com_Printf("UI_AbstractBaseNodeLoaded: Invalid baseid given %i", id);
    }
}

static void UI_BaseLayoutNodeDraw (uiNode_t * node)
{
    base_t *base;
    int height, width, y;
    int row, col;
    const vec4_t c_gray = {0.5, 0.5, 0.5, 1.0};
    vec2_t nodepos;
    int totalMarge;

    if (EXTRADATA(node).baseid >= MAX_BASES || EXTRADATA(node).baseid < 0)
        return;

    totalMarge = node->padding * (BASE_SIZE + 1);
    width = (node->size[0] - totalMarge) / BASE_SIZE;
    height = (node->size[1] - totalMarge) / BASE_SIZE;

    UI_GetNodeAbsPos(node, nodepos);

    base = B_GetBaseByIDX(EXTRADATA(node).baseid);

    y = nodepos[1] + node->padding;
    for (row = 0; row < BASE_SIZE; row++) {
        int x = nodepos[0] + node->padding;
        for (col = 0; col < BASE_SIZE; col++) {
            if (base->map[row][col].blocked) {
                UI_DrawFill(x, y, width, height, c_gray);
            } else if (base->map[row][col].building) {
                /* maybe destroyed in the meantime */
                if (base->founded)
                    UI_DrawFill(x, y, width, height, node->color);
            }
            x += width + node->padding;
        }
        y += height + node->padding;
    }
}

#define BASE_IMAGE_OVERLAY 20

static void UI_BaseMapGetCellAtPos (const uiNode_t *node, int x, int y, int *col, int *row)
{
    assert(col);
    assert(row);
    UI_NodeAbsoluteToRelativePos(node, &x, &y);
    if (x < 0 || y < 0 || x >= node->size[0] || y >= node->size[1]) {
        *col = -1;
        *row = -1;
        return;
    }
    *col = x / (node->size[0] / BASE_SIZE);
    *row = y / (node->size[0] / BASE_SIZE);
    assert(*col >= 0 && *col < BASE_SIZE);
    assert(*row >= 0 && *row < BASE_SIZE);
}

static inline qboolean UI_BaseMapIsCellFree (const base_t *base, int col, int row)
{
    return col >= 0 && col < BASE_SIZE
     && row >= 0 && row < BASE_SIZE
     && base->map[row][col].building == NULL
     && !base->map[row][col].blocked;
}

static void UI_BaseMapNodeDraw (uiNode_t * node)
{
    int width, height, row, col;
    char image[MAX_QPATH];      
    const building_t *building;
    const building_t *secondBuilding = NULL;
    const base_t *base = B_GetCurrentSelectedBase();
    qboolean used[MAX_BUILDINGS];

    if (!base) {
        UI_PopWindow(qfalse);
        return;
    }

    /* reset the used flag */
    memset(used, 0, sizeof(used));

    width = node->size[0] / BASE_SIZE;
    height = node->size[1] / BASE_SIZE + BASE_IMAGE_OVERLAY;

    for (row = 0; row < BASE_SIZE; row++) {
        for (col = 0; col < BASE_SIZE; col++) {
            vec2_t pos;
            UI_GetNodeAbsPos(node, pos);
            pos[0] += col * width;
            pos[1] += row * (height - BASE_IMAGE_OVERLAY);

            /* base tile */
            image[0] = '\0';
            if (base->map[row][col].blocked) {
                building = NULL;
                Q_strncpyz(image, "base/invalid", sizeof(image));
            } else if (!base->map[row][col].building) {
                building = NULL;
                Q_strncpyz(image, "base/grid", sizeof(image));
            } else {
                building = base->map[row][col].building;
                secondBuilding = NULL;
                assert(building);

                /* some buildings are drawn with two tiles - e.g. the hangar is no square map tile.
                 * These buildings have the needs parameter set to the second building part which has
                 * its own image set, too. We are searching for this second building part here. */
                if (!B_BuildingGetUsed(used, building->idx)) {
                    if (building->needs)
                        B_BuildingSetUsed(used, building->idx);
                    if (building->image)
                        Q_strncpyz(image, building->image, sizeof(image));
                } else {
                    secondBuilding = B_GetBuildingTemplate(building->needs);
                    if (!secondBuilding)
                        Com_Error(ERR_DROP, "Error in ufo-scriptfile - could not find the needed building");
                    Q_strncpyz(image, secondBuilding->image, sizeof(image));
                }
            }

            /* draw tile */
            if (image[0] != '\0')
                UI_DrawNormImageByName(pos[0], pos[1], width, height, 0, 0, 0, 0, image);

            /* only draw for first part of building */
            if (building && !secondBuilding) {
                switch (building->buildingStatus) {
                case B_STATUS_DOWN:
                case B_STATUS_CONSTRUCTION_FINISHED:
                    break;
                case B_STATUS_UNDER_CONSTRUCTION:
                {
                    const int time = building->buildTime - (ccs.date.day - building->timeStart);
                    UI_DrawString("f_small", ALIGN_UL, pos[0] + 10, pos[1] + 10, pos[0] + 10, node->size[0], 0, va(ngettext("%i day left", "%i days left", time), time), 0, 0, NULL, qfalse, 0);
                    break;
                }
                default:
                    break;
                }
            }
        }
    }

    if (!node->state)
        return;

    UI_BaseMapGetCellAtPos(node, mousePosX, mousePosY, &col, &row);
    if (col == -1)
        return;

    /* if we are building */
    if (ccs.baseAction == BA_NEWBUILDING) {
        qboolean isLarge;
        assert(base->buildingCurrent);
        if (!UI_BaseMapIsCellFree(base, col, row))
            return;

        isLarge = base->buildingCurrent->needs != NULL;

        /* large building */
        if (isLarge) {
            if (UI_BaseMapIsCellFree(base, col + 1, row)) {
                /* ok */
            } else if (UI_BaseMapIsCellFree(base, col - 1, row)) {
                /* fix col at the left cell */
                col--;
            } else {
                col = -1;
            }
        }
        if (col != -1) {
            vec2_t pos;
            UI_GetNodeAbsPos(node, pos);
            if (isLarge) {
                UI_DrawNormImageByName(pos[0] + col * width, pos[1] + row * (height - BASE_IMAGE_OVERLAY), width + width, height, 0, 0, 0, 0, "base/hover2");
            } else
                UI_DrawNormImageByName(pos[0] + col * width, pos[1] + row * (height - BASE_IMAGE_OVERLAY), width, height, 0, 0, 0, 0, "base/hover");
        }
    }
}

static void UI_BaseMapNodeDrawTooltip (uiNode_t *node, int x, int y)
{
    int col, row;
    building_t *building;
    const int itemToolTipWidth = 250;
    char *tooltipText;
    base_t *base = B_GetCurrentSelectedBase();

    UI_BaseMapGetCellAtPos(node, x, y, &col, &row);
    if (col == -1)
        return;

    building = base->map[row][col].building;
    if (!building)
        return;

    tooltipText = _(building->name);
    if (!B_CheckBuildingDependencesStatus(base, building))
        tooltipText = va("%s\n%s %s", tooltipText, _("not operational, depends on"), _(building->dependsBuilding->name));
    UI_DrawTooltip(tooltipText, x, y, itemToolTipWidth);
}

static void UI_BaseMapNodeClick (uiNode_t *node, int x, int y)
{
    int row, col;
    base_t *base = B_GetCurrentSelectedBase();

    assert(base);
    assert(node);
    assert(node->root);

    UI_BaseMapGetCellAtPos(node, x, y, &col, &row);
    if (col == -1)
        return;

    if (ccs.baseAction == BA_NEWBUILDING) {
        assert(base->buildingCurrent);
        if (!base->map[row][col].building && !base->map[row][col].blocked) {
            if (!base->buildingCurrent->needs
             || (col < BASE_SIZE - 1 && !base->map[row][col + 1].building && !base->map[row][col + 1].blocked)
             || (col > 0 && !base->map[row][col - 1].building && !base->map[row][col - 1].blocked))
            /* Set position for a new building */
            B_SetBuildingByClick(base, base->buildingCurrent, row, col);
        }
        return;
    }

    if (base->map[row][col].building) {
        const building_t *entry = base->map[row][col].building;
        if (!entry)
            Com_Error(ERR_DROP, "UI_BaseMapNodeClick: no entry at %i:%i", x, y);

        assert(!base->map[row][col].blocked);

        B_BuildingOpenAfterClick(base, entry);
        ccs.baseAction = BA_NONE;
        return;
    }
}

static void UI_BaseMapNodeRightClick (uiNode_t *node, int x, int y)
{
    int row, col;
    base_t *base = B_GetCurrentSelectedBase();

    assert(base);
    assert(node);
    assert(node->root);

    UI_BaseMapGetCellAtPos(node, x, y, &col, &row);
    if (col == -1)
        return;

    if (base->map[row][col].building) {
        building_t *entry = base->map[row][col].building;
        if (!entry)
            Sys_Error("UI_BaseMapNodeRightClick: no entry at %i:%i\n", x, y);

        assert(!base->map[row][col].blocked);
        B_MarkBuildingDestroy(base, entry);
        return;
    }
}

static void UI_BaseMapNodeMiddleClick (uiNode_t *node, int x, int y)
{
    int row, col;
    base_t *base = B_GetCurrentSelectedBase();

    assert(base);
    assert(node);
    assert(node->root);

    UI_BaseMapGetCellAtPos(node, x, y, &col, &row);
    if (col == -1)
        return;

    if (base->map[row][col].building) {
        building_t *entry = base->map[row][col].building;
        if (!entry)
            Com_Error(ERR_DROP, "UI_BaseMapNodeMiddleClick: no entry at %i:%i", x, y);

        assert(!base->map[row][col].blocked);
        B_DrawBuilding(base, entry);
        return;
    }
}

static void UI_BaseLayoutNodeLoading (uiNode_t *node)
{
    node->padding = 3;
    Vector4Set(node->color, 1, 1, 1, 1);
}

static const value_t properties[] = {
    /* Identify the base, from a base ID, the node use. */
    {"baseid", V_INT, UI_EXTRADATA_OFFSETOF(baseExtraData_t, baseid), MEMBER_SIZEOF(baseExtraData_t, baseid)},
    {NULL, V_NULL, 0, 0}
};

void UI_RegisterAbstractBaseNode (uiBehaviour_t *behaviour)
{
    behaviour->name = "abstractbase";
    behaviour->isAbstract = qtrue;
    behaviour->properties = properties;
    behaviour->loaded = UI_AbstractBaseNodeLoaded;
    behaviour->extraDataSize = sizeof(EXTRADATA_TYPE);
}

void UI_RegisterBaseMapNode (uiBehaviour_t *behaviour)
{
    behaviour->name = "basemap";
    behaviour->extends = "abstractbase";
    behaviour->draw = UI_BaseMapNodeDraw;
    behaviour->leftClick = UI_BaseMapNodeClick;
    behaviour->rightClick = UI_BaseMapNodeRightClick;
    behaviour->drawTooltip = UI_BaseMapNodeDrawTooltip;
    behaviour->middleClick = UI_BaseMapNodeMiddleClick;
}

void UI_RegisterBaseLayoutNode (uiBehaviour_t *behaviour)
{
    behaviour->name = "baselayout";
    behaviour->extends = "abstractbase";
    behaviour->draw = UI_BaseLayoutNodeDraw;
    behaviour->loading = UI_BaseLayoutNodeLoading;
}