/*
===========================================================================
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
===========================================================================
*/

// actorenemy.h

#pragma once

#include "g_local.h"
#include "class.h"
#include "archive.h"

class Actor;
class Sentient;

class ActorEnemy : public Class
{
public:
    int               m_iAddTime;
    int               m_iNextEnemyTime; // Added in 2.0
    float             m_fLastLookTime;
    float             m_fVisibility;
    float             m_fTotalVisibility;
    int               m_iThreat;
    SafePtr<Sentient> m_pEnemy;
    float             m_fCurrentRangeSquared;
    Vector            m_vLastKnownPos;
    int               m_iLastSightChangeTime;
    bool              m_bVisible;

    float     UpdateVisibility(Actor *pSelf, bool *pbInFovAndRange, bool *pbVisible);
    int       UpdateThreat(Actor *pSelf);
    Sentient *GetEnemy(void) const;
    float     GetVisibility(void) const;
    int       GetThreat(void) const;
    float     GetRangeSquared(void) const;

    void Archive(Archiver&) override;

protected:
    float UpdateLMRF(Actor *pSelf, bool *pbInFovAndRange, bool *pbVisible);
};

inline void ActorEnemy::Archive(Archiver& arc)
{
    Class::Archive(arc);

    arc.ArchiveInteger(&m_iAddTime);
    arc.ArchiveFloat(&m_fLastLookTime);
    arc.ArchiveFloat(&m_fVisibility);
    arc.ArchiveFloat(&m_fTotalVisibility);
    arc.ArchiveInteger(&m_iThreat);
    arc.ArchiveSafePointer(&m_pEnemy);
    arc.ArchiveFloat(&m_fCurrentRangeSquared);
    arc.ArchiveVector(&m_vLastKnownPos);
    arc.ArchiveInteger(&m_iLastSightChangeTime);
    arc.ArchiveBool(&m_bVisible);
}

inline Sentient *ActorEnemy::GetEnemy(void) const
{
    return m_pEnemy;
}

inline float ActorEnemy::GetVisibility(void) const
{
    return m_fVisibility;
}

inline int ActorEnemy::GetThreat(void) const
{
    return m_iThreat;
}

inline float ActorEnemy::GetRangeSquared(void) const
{
    return m_fCurrentRangeSquared;
}

class ActorEnemySet : public Class
{
protected:
    Container<ActorEnemy> m_Enemies;
    int                   m_iCheckCount;
    SafePtr<Sentient>     m_pCurrentEnemy;
    float                 m_fCurrentVisibility;
    int                   m_iCurrentThreat;

public:
    ActorEnemySet();

    ActorEnemy *AddPotentialEnemy(Sentient *pEnemy);
    void        FlagBadEnemy(Sentient *pEnemy);
    void        CheckEnemies(Actor *pSelf);
    Sentient   *GetCurrentEnemy(void) const;
    float       GetCurrentVisibility(void) const;
    int         GetCurrentThreat(void) const;
    qboolean    IsEnemyConfirmed(void) const;
    bool        HasAlternateEnemy(void) const;
    void        RemoveAll(void);
    void        ConfirmEnemy(Actor *pSelf, Sentient *pEnemy);
    void        ConfirmEnemyIfCanSeeSharerOrEnemy(Actor *pSelf, Actor *pSharer, Sentient *pEnemy);
    bool        CaresAboutPerfectInfo(Sentient *pEnemy);

    void Archive(Archiver& arc) override;
};

inline Sentient *ActorEnemySet::GetCurrentEnemy(void) const
{
    return m_pCurrentEnemy;
}

inline float ActorEnemySet::GetCurrentVisibility(void) const
{
    return m_fCurrentVisibility;
}

inline int ActorEnemySet::GetCurrentThreat(void) const
{
    return m_iCurrentThreat;
}

inline qboolean ActorEnemySet::IsEnemyConfirmed(void) const
{
    return m_fCurrentVisibility > 0.999f;
}

inline void ActorEnemySet::Archive(Archiver& arc)
{
    Class::Archive(arc);

    m_Enemies.Archive(arc);
    arc.ArchiveInteger(&m_iCheckCount);
    arc.ArchiveSafePointer(&m_pCurrentEnemy);
    arc.ArchiveFloat(&m_fCurrentVisibility);
    arc.ArchiveInteger(&m_iCurrentThreat);
}