checkentities.cpp

Go to the documentation of this file.

/*
All original material Copyright (C) 2002-2020 UFO: Alien Invasion.

Copyright (C) 1997-2001 Id Software, Inc.

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 "checkentities.h"
#include "../../../shared/mathlib.h"
#include "../../../shared/entitiesdef.h"
#include "../common/shared.h"
#include "../bsp.h"
#include "checklib.h"

#define MIN_TILE_SIZE 256 
static int numToMoveToWorldspawn = 0;

static void Check_MapSize (vec3_t mapSize);
mapbrush_t** Check_ExtraBrushesForWorldspawn (int* numBrushes);


static bool Check_IsInfoStart(const char* classname)
{
    return Q_strstart(classname, "info_") && strstr(classname, "_start");
}

static bool Check_InfoStartAligned (const entityDef_t* ed, const entity_t* e)
{
    static int size[6];
    const entityKeyDef_t* sizeKd = ED_GetKeyDefEntity(ed, "size", 1); /* 1 means find abstract version of key */
    if (ED_GetIntVector(sizeKd, size, (int)(sizeof(size) / sizeof(int))) == ED_ERROR)
        Sys_Error("%s", ED_GetLastError());

    return (((int)e->origin[0] - size[0]) % UNIT_SIZE == 0)
        && (((int)e->origin[1] - size[1]) % UNIT_SIZE == 0);
}

static bool Check_TargetExists (const epair_t* kvp)
{
    const char* thisKey = kvp->key;
    const char* value = kvp->value;
    const char* otherKey = Q_streq("target", thisKey) ? "targetname" : "target";

    for (int i = 0; i < num_entities; i++) {
        const entity_t* e = &entities[i];
        const char* searchVal = ValueForKey(e, otherKey);

        if (searchVal && Q_streq(searchVal, value))
            return true;
    }

    return false;
}

static void Check_EntityWithBrushes (entity_t* e, const char* classname, int entnum)
{
    if (!e->numbrushes) {
        Check_Printf(VERB_CHECK, true, entnum, -1, "%s with no brushes given - will be deleted\n", classname);
        e->skip = true;
        return;
    }

    if (e->numbrushes > 1 && Q_streq(classname, "func_breakable")) {
        Check_Printf(VERB_CHECK, false, entnum, -1, "func_breakable with more than one brush given (might break pathfinding)\n");
    }

    if (e->numbrushes == 1 && Q_streq(classname, "func_group")) {
        Check_Printf(VERB_CHECK, true, entnum, -1, "%s with one brush only - will be moved to worldspawn\n", classname);
        numToMoveToWorldspawn++;
        e->skip = true;
    }
}

void CheckEntities (void)
{
    Check_InitEntityDefs();

    for (int i = 0; i < num_entities; i++) {
        entity_t* e = &entities[i];
        const char* name = ValueForKey(e, "classname");
        const entityDef_t* ed = ED_GetEntityDef(name);
        const epair_t* kvp;
        const entityKeyDef_t* kd;

        if (!ed) { /* check that a definition exists */
            Check_Printf(VERB_CHECK, false, i, -1, "Not defined in entities.ufo: %s\n", name);
            continue;
        }

        /* check alignment of info_.+_start */
        if (Check_IsInfoStart(name) && !Check_InfoStartAligned(ed, e))
            Check_Printf(VERB_CHECK, false, i, -1, "Misaligned %s\n", name);

        if (Q_strstart(name, "func_")) /* func_* entities should have brushes */
            Check_EntityWithBrushes(e, name, i);

        /* check all keys in the entity - make sure they are OK */
        for (kvp = e->epairs; kvp; kvp = kvp->next) {
            kd = ED_GetKeyDefEntity(ed, kvp->key, 0); /* zero means ignore abstract (radiant only) keys */

            if (!kd) { /* make sure it has a definition */
                Check_Printf(VERB_CHECK, false, i, -1, "Not defined in entities.ufo: %s in %s\n", kvp->key, name);
                continue;
            }

            if (ED_CheckKey(kd, kvp->value) == ED_ERROR) { /* check values against type and range definitions in entities.ufo */
                Check_Printf(VERB_CHECK, false, i, -1, "%s\n", ED_GetLastError());
                continue;
            }

            if (Q_streq("target", kvp->key) || Q_streq("targetname", kvp->key)) {
                if (!Check_TargetExists(kvp)) {
                    Check_Printf(VERB_CHECK, false, i, -1,
                        "%s with %s of %s: no corresponding entity with %s with matching value\n",
                        ed->classname, kvp->key, kvp->value, Q_streq("target", kvp->key) ? "targetname" : "target");
                }
            }
        }

        /* check keys in the entity definition - make sure mandatory ones are present */
        for (kd = ed->keyDefs; kd->name; kd++) {
            if (!(kd->flags & ED_MANDATORY))
                continue;
            const char* keyNameInEnt = ValueForKey(e, kd->name);
            if (Q_strvalid(keyNameInEnt))
                continue;
            const char* defaultVal = kd->defaultVal;
            const bool hasDefault = defaultVal ? true : false;
            Check_Printf(VERB_CHECK, hasDefault, i, -1, "Mandatory key missing from entity: %s in %s", kd->name, name);
            if (defaultVal) {
                Check_Printf(VERB_CHECK, hasDefault, i, -1, ", supplying default: %s", defaultVal);
                SetKeyValue(e, kd->name, defaultVal);
            }
            Check_Printf(VERB_CHECK, hasDefault, i, -1, "\n");
        }
    }
}


void Check_Stats(void) {
    vec3_t worldSize;
    int j;
    int* entNums;

    Check_InitEntityDefs();

    entNums = Mem_AllocTypeN(int, numEntityDefs);

    Check_MapSize(worldSize);
    Verb_Printf(VERB_NORMAL, "        Number of brushes: %i\n",nummapbrushes);
    Verb_Printf(VERB_NORMAL, "         Number of planes: %i\n",nummapplanes);
    Verb_Printf(VERB_NORMAL, "    Number of brush sides: %i\n",nummapbrushsides);
    Verb_Printf(VERB_NORMAL, "         Map size (units): %.0f %.0f %.0f\n", worldSize[0], worldSize[1], worldSize[2]);
    Verb_Printf(VERB_NORMAL, "        Map size (fields): %.0f %.0f %.0f\n", worldSize[0] / UNIT_SIZE, worldSize[1] / UNIT_SIZE, worldSize[2] / UNIT_HEIGHT);
    Verb_Printf(VERB_NORMAL, "         Map size (tiles): %.0f %.0f %.0f\n", worldSize[0] / (MIN_TILE_SIZE), worldSize[1] / (MIN_TILE_SIZE), worldSize[2] / UNIT_HEIGHT);
    Verb_Printf(VERB_NORMAL, "       Number of entities: %i\n", num_entities);

    /* count number of each type of entity */
    for (int i = 0; i < num_entities; i++) {
        const char* name = ValueForKey(&entities[i], "classname");

        for (j = 0; j < numEntityDefs; j++)
            if (Q_streq(name, entityDefs[j].classname)) {
                entNums[j]++;
                break;
            }
        if (j == numEntityDefs) {
            Com_Printf("Check_Stats: entity '%s' not recognised\n", name);
        }
    }

    /* print number of each type of entity */
    for (j = 0; j < numEntityDefs; j++)
        if (entNums[j])
            Com_Printf("%27s: %i\n", entityDefs[j].classname, entNums[j]);

    Mem_Free(entNums);
}


static void Check_MapSize (vec3_t mapSize)
{
    AABB mapBox;

    mapBox.setNegativeVolume();

    for (int i = 0; i < nummapbrushes; i++) {
        const mapbrush_t* brush = &mapbrushes[i];

        for (int bi = 0; bi < brush->numsides; bi++) {
            const winding_t* winding = brush->original_sides[bi].winding;

            for (int vi = 0; vi < winding->numpoints; vi++)
                mapBox.add(winding->p[vi]);
        }
    }
    mapBox.getDiagonal(mapSize);
}

mapbrush_t** Check_ExtraBrushesForWorldspawn (int* numBrushes)
{
    int i, j;
    mapbrush_t** brushesToMove;

    *numBrushes = numToMoveToWorldspawn;

    if (!numToMoveToWorldspawn)
        return nullptr;

    brushesToMove = Mem_AllocTypeN(mapbrush_t* , numToMoveToWorldspawn);
    if (!brushesToMove)
        Sys_Error("Check_ExtraBrushesForWorldspawn: out of memory");

    /* 0 is the world - start at 1 */
    for (i = 1, j = 0; i < num_entities; i++) {
        const entity_t* e = &entities[i];
        const char* name = ValueForKey(e, "classname");

        if (e->numbrushes == 1 && Q_streq(name, "func_group")) {
            assert(j < numToMoveToWorldspawn);
            brushesToMove[j++] = &mapbrushes[e->firstbrush];
        }
    }

    return brushesToMove;
}