openmohaa/code/fgame/actorpath.cpp

/*
===========================================================================
Copyright (C) 2015 the OpenMoHAA team

This file is part of OpenMoHAA source code.

OpenMoHAA source code 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.

OpenMoHAA source code 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 OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

// actor.cpp:

#include "actor.h"

ActorPath::ActorPath()
{
    m_FallHeight       = 96;
    m_path             = NULL;
    m_pathlen          = 0;
    m_fLookAhead       = 4096.0f;
    m_bChangeLookAhead = true;

    Clear();
}

ActorPath::~ActorPath()
{
    if (m_path) {
        delete[] m_path;
    }
}

void ActorPath::Clear(void)
{
    m_startpathpos = 0;
    m_pathpos      = 0;
    m_Side         = false;
    m_Time         = -10000000;
    m_delta[0]     = 0;
    m_delta[1]     = 0;
}

bool ActorPath::DoesTheoreticPathExist(
    float *start, float *end, class SimpleActor *ent, float maxPath, float *vLeashHome, float fLeashDistSquared
)
{
    return PathSearch::FindPath(start, end, ent, maxPath, NULL, 0, m_FallHeight) != 0;
}

void ActorPath::FindPath(
    float *start, float *end, Entity *ent, float maxPath, float *vLeashHome, float fLeashDistSquared
)
{
    int depth = PathManager.FindPath(start, end, ent, maxPath, vLeashHome, fLeashDistSquared, m_FallHeight);

    if (depth) {
        if (depth > m_pathlen) {
            if (m_path) {
                delete[] m_path;
            }

            m_pathlen = 10 * ((depth - 1) / 10) + 10;
            m_path    = new PathInfo[m_pathlen];
        }

        m_startpathpos = PathManager.GeneratePath(m_path);
        m_pathpos      = m_startpathpos;
        m_TotalDist    = PathManager.total_dist;
        m_Side         = false;
        m_Time         = level.inttime;
        UpdatePos(start);
    } else {
        Clear();
    }
}

void ActorPath::FindPathAway(
    float  *start,
    float  *avoid,
    float  *vPreferredDir,
    Entity *ent,
    float   fMinSafeDist,
    float  *vLeashHome,
    float   fLeashDistSquared
)
{
    int depth = PathManager.FindPathAway(
        start, avoid, vPreferredDir, ent, fMinSafeDist, vLeashHome, fLeashDistSquared, m_FallHeight
    );

    if (depth) {
        if (depth > m_pathlen) {
            if (m_path) {
                delete[] m_path;
            }

            m_pathlen = 10 * (depth - 1) / 10 + 10;
            m_path    = new PathInfo[m_pathlen];
        }

        m_startpathpos = PathManager.GeneratePathAway(m_path);
        m_pathpos      = m_startpathpos;
        m_TotalDist    = PathManager.total_dist;
        m_Side         = false;
        m_Time         = level.inttime;
        UpdatePos(start);
    } else {
        Clear();
    }
}

void ActorPath::FindPathNear(
    float  *start,
    float  *nearby,
    Entity *ent,
    float   maxPath,
    float   fRadiusSquared,
    float  *vLeashHome,
    float   fLeashDistSquared
)
{
    int depth = PathManager.FindPathNear(
        start, nearby, ent, maxPath, fRadiusSquared, vLeashHome, fLeashDistSquared, m_FallHeight
    );

    if (depth) {
        if (depth > m_pathlen) {
            if (m_path) {
                delete[] m_path;
            }

            m_pathlen = 10 * (depth - 1) / 10 + 10;
            m_path    = new PathInfo[m_pathlen];
        }

        m_startpathpos = PathManager.GeneratePathNear(m_path);
        m_pathpos      = m_startpathpos;
        m_TotalDist    = PathManager.total_dist;
        m_Side         = false;
        m_Time         = level.inttime;
        UpdatePos(start);
    } else {
        Clear();
    }
}

void ActorPath::ReFindPath(float *start, Entity *ent)
{
    vec3_t point;
    // this is a critical bug in all versions of mohaa, it passes directly m_path->point
    // but m_path can be deleted afterwards, leaving a dangling pointer to the path_end
    // global variable
    VectorCopy(m_path->point, point);
    int depth = PathManager.FindPath(start, point, ent, 0, NULL, 0, m_FallHeight);

    if (depth) {
        if (depth > m_pathlen) {
            if (m_path) {
                delete[] m_path;
            }

            m_pathlen = 10 * (depth - 1) / 10 + 10;
            m_path    = new PathInfo[m_pathlen];
        }

        m_startpathpos = PathManager.GeneratePath(m_path);
        m_pathpos      = m_startpathpos;
        m_TotalDist    = PathManager.total_dist;
        m_Side         = false;
        m_Time         = level.inttime;
        UpdatePos(start);
    } else {
        Clear();
    }
}

float ActorPath::PathLookAhead(float total_area, Vector& end, float *origin)
{
    float     area = total_area;
    float     s;
    float     t;
    float     normal[2];
    float     delta[2];
    Vector    pos;
    float     fallheight;
    PathInfo *current_path = m_pathpos;

    while (1) {
        pos = current_path->point;

        if (current_path == m_path) {
            break;
        }

        fallheight = current_path->point[2] - origin[2];

        if (fallheight > 94.0f || fallheight < -94.0f) {
            VectorCopy(current_path->point, end);
            m_HasCompleteLookahead = false;
            return area;
        }

        current_path--;

        normal[0] = current_path->point[1] - pos[1];
        normal[1] = pos[0] - current_path->point[0];

        VectorNormalize2D(normal);

        delta[0] = current_path->point[0] - origin[0];
        delta[1] = current_path->point[1] - origin[1];

        t = fabs(DotProduct2D(delta, normal)) * current_path->dist;

        if (t >= area) {
            t = area / t;
            s = 1.0f - t;

            end[0]                 = current_path->point[0] * t + pos[0] * s;
            end[1]                 = current_path->point[1] * t + pos[1] * s;
            end[2]                 = current_path->point[2] * t + pos[2] * s;
            m_HasCompleteLookahead = false;
            return 0;
        }

        area -= t;
    }

    VectorCopy(current_path->point, end);
    m_HasCompleteLookahead = true;

    return area;
}

void ActorPath::UpdatePos(float *origin, float fNodeRadius)
{
    Vector    end;
    float     s = 0;
    float     t = 0;
    vec2_t    delta;
    float     current_dot  = 0;
    float     previous_dot = 0;
    Vector    pos;
    PathInfo *current_path = NULL;
    vec2_t    dir;
    Vector    end2;
    vec2_t    delta2;
    vec2_t    dir2;

    if (m_pathpos == m_path) {
        end                    = m_pathpos->point;
        m_bChangeLookAhead     = true;
        m_HasCompleteLookahead = true;
        m_delta[0]             = end[0] - origin[0];
        m_delta[1]             = end[1] - origin[1];
        VectorNormalize2D2(m_delta, dir);
    } else if (m_fLookAhead >= 4096.0f) {
        if (m_fLookAhead - 4096.0f >= PathLookAhead(m_fLookAhead, end, origin)) {
            Vector mins = Vector(-15, -15, 0);
            Vector maxs = Vector(15, 15, 60);
            Vector e    = end + Vector(0, 0, 32);

            pos = origin + Vector(0, 0, 32);

            if (G_SightTrace(
                    pos,
                    mins,
                    maxs,
                    e,
                    (gentity_t *)NULL, // g_entities[ 0 ].entity
                    0,
                    MASK_PLAYERSOLID,
                    false,
                    "Actor::UpdatePos 2"
                )
                != true) {
                if (m_bChangeLookAhead) {
                    m_fLookAhead -= 2048.0f;
                    m_bChangeLookAhead = false;
                } else {
                    m_fLookAhead *= 0.5f;
                }

                if (m_fLookAhead < 4096.0f) {
                    m_fLookAhead = 4096.0f;
                }

                PathLookAhead(4096.0f, end, origin);
                goto __setdelta;
            }
        }

        m_fLookAhead += 1024.0f;

        if (m_fLookAhead > 65536.0f) {
            m_fLookAhead = 65536.0f;
        }

        m_bChangeLookAhead = true;

    __setdelta:

        m_delta[0] = end[0] - origin[0];
        m_delta[1] = end[1] - origin[1];

        VectorNormalize2D2(m_delta, dir);
    } else if (PathLookAhead(4096.0f, end, origin) < 4096.0f - m_fLookAhead) {
        PathLookAhead(m_fLookAhead, end2, origin);

        Vector mins = Vector(-15, -15, 0);
        Vector maxs = Vector(15, 15, 60);
        Vector e    = end2 + Vector(0, 0, 32);

        pos = origin + Vector(0, 0, 32);

        if (G_SightTrace(pos, mins, maxs, e, (gentity_t *)NULL, 0, MASK_MONSTERSOLID, false, "Actor::UpdatePos 1")
            != true) {
            m_fLookAhead += 1024.0f;

            if (m_fLookAhead > 4096.0f) {
                m_fLookAhead = 4096.0f;
            }
        } else {
            m_fLookAhead -= 1024.0f;

            if (m_fLookAhead < 1024.0f) {
                m_fLookAhead = 1024.0f;
            }

            PathLookAhead(m_fLookAhead, end2, origin);
        }

        delta[0] = end2[0] - origin[0];
        delta[1] = end2[1] - origin[1];
        VectorNormalize2D2(delta, dir2);

        m_delta[0] = end[0] - origin[0];
        m_delta[1] = end[1] - origin[1];
        VectorNormalize2D2(m_delta, dir);

        if (DotProduct2D(dir, dir2) > 0.7f) {
            m_delta[0] = delta[0];
            m_delta[1] = delta[1];
        }

        m_bChangeLookAhead = true;
    } else {
        m_fLookAhead -= 1024.0f;

        if (m_fLookAhead < 1024.0f) {
            m_fLookAhead = 1024.0f;
        }

        m_delta[0] = end[0] - origin[0];
        m_delta[1] = end[1] - origin[1];
        VectorNormalize2D2(m_delta, dir);

        m_bChangeLookAhead = true;
    }

    current_path = m_pathpos;

    while (1) {
        delta2[0]   = current_path->point[0] - origin[0];
        delta2[1]   = current_path->point[1] - origin[1];
        current_dot = DotProduct2D(delta2, dir) - fNodeRadius;

        if (current_dot >= 0.0f) {
            break;
        }

        previous_dot = current_dot;

        if (current_path == LastNode()) {
            break;
        }

        current_path--;
    }

    if (current_path != m_pathpos) {
        m_pathpos = current_path + 1;

        t = previous_dot / (previous_dot - current_dot);
        s = 1.0f - t;

        /*m_pathpos->point[ 0 ] = m_pathpos->point[ 0 ] * s + current_path->point[ 0 ] * t;
		m_pathpos->point[ 1 ] = m_pathpos->point[ 1 ] * s + current_path->point[ 1 ] * t;
		m_pathpos->point[ 2 ] = m_pathpos->point[ 2 ] * s + current_path->point[ 2 ] * t;*/

        VectorCopy(current_path->point, m_pathpos->point);

        current_path->dist *= s;

        m_Side = true;
    } else {
        m_Side = false;
    }
}

bool ActorPath::Complete(const float *origin) const
{
    if (!m_HasCompleteLookahead) {
        return false;
    }

    if (!m_path) {
        return true;
    }

    if (fabs(origin[0] - m_path->point[0]) < 16.0f && fabs(origin[1] - m_path->point[1]) < 16.0f) {
        return true;
    }

    return false;
}

PathInfo *ActorPath::StartNode(void) const
{
    return m_startpathpos;
}

PathInfo *ActorPath::CurrentNode(void) const
{
    return m_pathpos;
}

int ActorPath::CurrentNodeIndex(void) const
{
    return m_pathpos ? m_pathpos - m_path : -1;
}

PathInfo *ActorPath::NextNode(void) const
{
    return m_pathpos == m_path ? NULL : m_pathpos - 1;
}

PathInfo *ActorPath::LastNode(void) const
{
    return m_path;
}

Vector ActorPath::CurrentPathDir(void) const
{
    return Vector(m_pathpos->dir[0], m_pathpos->dir[1], 0);
}

float *ActorPath::CurrentPathGoal(void) const
{
    return m_pathpos->point;
}

int ActorPath::Time(void) const
{
    return m_Time;
}

Vector ActorPath::CurrentDelta(void) const
{
    return Vector(m_delta[0], m_delta[1], 0);
}

bool ActorPath::IsAccurate(void) const
{
    return m_pathpos->bAccurate;
}

float ActorPath::TotalDist(void) const
{
    return m_TotalDist;
}

void ActorPath::SetFallHeight(float fHeight)
{
    m_FallHeight = fHeight;
}

float ActorPath::GetFallHeight(void) const
{
    return m_FallHeight;
}

void ActorPath::TrimPathFromEnd(int nNodesPop)
{
    int iLastPos = m_path - m_pathpos;

    if (iLastPos - nNodesPop > 0) {
        for (int i = 0; i < iLastPos; i++) {
            m_path[i] = m_path[i + nNodesPop];
        }
    } else {
        Clear();
    }
}

void ActorPath::Shorten(float fDistRemove)
{
    if (m_path->dist > fDistRemove) {
        m_path->point[0] += m_path->dir[0] * -fDistRemove;
        m_path->point[1] += m_path->dir[1] * -fDistRemove;
        m_path->point[2] += m_path->point[2] * -fDistRemove;
        m_path->dist -= fDistRemove;
    } else {
        while (fDistRemove - m_path->dist > m_path->dist) {
            TrimPathFromEnd(1);

            if (!m_pathpos) {
                return;
            }
        }
    }
}

bool ActorPath::HasCompleteLookahead(void) const
{
    return m_HasCompleteLookahead;
}

bool ActorPath::IsSide(void) const
{
    return m_Side;
}

void ActorPath::ForceShortLookahead(void)
{
    m_fLookAhead = 4096.0f;
}