CWE-ou-minkata/Sources/Plasma/FeatureLib/pfCharacter/pfMarkerMgr.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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 3 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, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pfMarkerMgr.h"
#include "pfMessage/pfMarkerMsg.h"
#include "pfMarkerInfo.h"

#include "plModifier/plCloneSpawnModifier.h"
#include "plStatusLog/plStatusLog.h"

#include "plMessage/plLoadCloneMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "pnMessage/plNotifyMsg.h"

#include "plNetClient/plNetClientMgr.h"
#include "plgDispatch.h"

////////////////////////////////////////////////////////////////////////////////

pfMarkerMgr* pfMarkerMgr::fInstance = nil;
const UInt32 pfMarkerMgr::kNoMarkerSelected = (UInt32)(-1);

pfMarkerMgr* pfMarkerMgr::Instance()
{
    if (!pfMarkerMgr::fInstance)
    {
        pfMarkerMgr::fInstance = TRACKED_NEW pfMarkerMgr;
        pfMarkerMgr::fInstance->IInit();
    }

    return pfMarkerMgr::fInstance;
}

void pfMarkerMgr::Shutdown()
{
    if (pfMarkerMgr::fInstance)
    {
        pfMarkerMgr::fInstance->IShutdown();
        pfMarkerMgr::fInstance = nil;
    }
}

////////////////////////////////////////////////////////////////////////////////

pfMarkerMgr::pfMarkerMgr(): fSelectedMarker(kNoMarkerSelected), fShowingLocalMarkers(false), fMarkersRespawn(false)
{
    fLog = plStatusLogMgr::GetInstance().CreateStatusLog(20, "Marker.log", plStatusLog::kAlignToTop | plStatusLog::kFilledBackground);
    pfMarkerInfo::Init();
}

pfMarkerMgr::~pfMarkerMgr()
{
    delete fLog;
}

void pfMarkerMgr::IInit()
{
    fMyKey = RegisterAs(kMarkerMgr_KEY);
    plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
}

void pfMarkerMgr::IShutdown()
{
    std::map<UInt32, pfMarkerInfo*>::iterator curMarker = fMarkers.begin();
    while (curMarker != fMarkers.end())
    {
        curMarker->second->Remove();
        DEL(curMarker->second);
        ++curMarker;
    }
    fMarkers.clear();

    plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey());
    UnRegisterAs(kMarkerMgr_KEY);
}

pfMarkerInfo* pfMarkerMgr::IFindMarker(plKey markerKey, UInt32& id)
{
    std::map<UInt32, pfMarkerInfo*>::iterator curMarker = fMarkers.begin();
    while (curMarker != fMarkers.end())
    {
        if (curMarker->second->GetKey() == markerKey)
        {
            id = curMarker->first;
            return curMarker->second;
        }
        ++curMarker;
    }
    id = kNoMarkerSelected;
    return nil;
}

void pfMarkerMgr::IUpdate()
{
    // Update all markers
    std::map<UInt32, pfMarkerInfo*>::iterator curMarker = fMarkers.begin();
    while (curMarker != fMarkers.end())
    {
        curMarker->second->Update(hsTimer::GetSeconds());
        ++curMarker;
    }
}

void pfMarkerMgr::IMarkerHit(plKey markerKey, plKey playerKey)
{
    if (playerKey != plNetClientMgr::GetInstance()->GetLocalPlayerKey())
        return; // not the local player, abort

    // make sure the marker isn't frozen
    UInt32 id;
    pfMarkerInfo* hitMarker = IFindMarker(markerKey, id);
    if (!hitMarker)
        return; // abort, something weird is going on
    if (hitMarker->IsFrozen())
        return; // marker frozen, abort

    // tell people about it
    pfMarkerMsg* msg = TRACKED_NEW pfMarkerMsg;
    msg->fType = pfMarkerMsg::kMarkerCaptured;
    msg->fMarkerID = id;
    msg->Send();
}

void pfMarkerMgr::AddMarker(double x, double y, double z, UInt32 id, bool justCreated)
{
    if (fMarkers.find(id) != fMarkers.end())
    {
        // delete existing one if we're changing its location
        fMarkers[id]->Remove();
        DEL(fMarkers[id]);
    }

    hsPoint3 pos((hsScalar)x, (hsScalar)y, (hsScalar)z);
    fMarkers[id] = TRACKED_NEW pfMarkerInfo(pos, justCreated);
    fMarkers[id]->Spawn(pfMarkerInfo::kMarkerOpen);
}

void pfMarkerMgr::RemoveMarker(UInt32 id)
{
    if (fMarkers.find(id) == fMarkers.end())
        return;
    fMarkers[id]->Remove();
    DEL(fMarkers[id]);
    fMarkers.erase(id);
}

void pfMarkerMgr::RemoveAllMarkers()
{
    std::map<UInt32, pfMarkerInfo*>::iterator curMarker = fMarkers.begin();
    while (curMarker != fMarkers.end())
    {
        curMarker->second->Remove();
        DEL(curMarker->second);
        ++curMarker;
    }
    fMarkers.clear();
}

void pfMarkerMgr::ClearSelectedMarker()
{
    if (fSelectedMarker != kNoMarkerSelected)
    {
        if (fMarkers.find(fSelectedMarker) != fMarkers.end())
            fMarkers[fSelectedMarker]->SetType(pfMarkerInfo::kMarkerOpen);
        fSelectedMarker = kNoMarkerSelected;
    }
}

void pfMarkerMgr::SetSelectedMarker(UInt32 id)
{
    ClearSelectedMarker();

    if (id != kNoMarkerSelected)
    {
        if (fMarkers.find(id) != fMarkers.end())
        {
            fMarkers[id]->SetType(pfMarkerInfo::kMarkerLocalSelected);
            fSelectedMarker = id;
        }
    }
}

UInt32 pfMarkerMgr::GetSelectedMarker()
{
    return fSelectedMarker;
}

// for QUEST games (no teams)
void pfMarkerMgr::CaptureMarker(UInt32 id, bool captured)
{
    if (fMarkers.find(id) == fMarkers.end())
        return;

    if (fMarkersRespawn)
        fMarkers[id]->SetFrozen(hsTimer::GetSeconds());
    else
        fMarkers[id]->Show(!captured);

    fMarkers[id]->PlayHitSound();
    fMarkers[id]->SetType(captured ? pfMarkerInfo::kMarkerGreen : pfMarkerInfo::kMarkerOpen);
}

// for TEAM games (0 = not captured)
void pfMarkerMgr::CaptureMarker(UInt32 id, int team)
{
    if (fMarkers.find(id) == fMarkers.end())
        return;

    if (fMarkersRespawn)
        fMarkers[id]->SetFrozen(hsTimer::GetSeconds());
    else
        fMarkers[id]->Show(team == 0); // 0 = uncaptured

    fMarkers[id]->PlayHitSound();
    if (team == 0)
        fMarkers[id]->SetType(pfMarkerInfo::kMarkerOpen);
    else if (team == 1)
        fMarkers[id]->SetType(pfMarkerInfo::kMarkerGreen);
    else
        fMarkers[id]->SetType(pfMarkerInfo::kMarkerRed);
}

void pfMarkerMgr::LocalShowMarkers(bool show)
{
    fShowingLocalMarkers = show;
    if (show)
    {
        std::map<UInt32, pfMarkerInfo*>::iterator curMarker = fMarkers.begin();
        while (curMarker != fMarkers.end())
            curMarker->second->Show(true);
    }
    else
    {
        std::map<UInt32, pfMarkerInfo*>::iterator curMarker = fMarkers.begin();
        while (curMarker != fMarkers.end())
            curMarker->second->Show(false);
    }
}

bool pfMarkerMgr::AreLocalMarkersShowing()
{
    return fShowingLocalMarkers;
}

hsBool pfMarkerMgr::MsgReceive(plMessage* msg)
{
    plEvalMsg* evalMsg = plEvalMsg::ConvertNoRef(msg);
    if (evalMsg)
    {
        IUpdate();
        return true;
    }

    // Somebody hit a marker
    plNotifyMsg* notify = plNotifyMsg::ConvertNoRef(msg);
    if (notify)
    {
        proCollisionEventData* cEvent = (proCollisionEventData*)notify->FindEventRecord(proEventData::kCollision);
        if (cEvent)
        {
            plKey markerKey = cEvent->fHittee;
            plKey playerKey = cEvent->fHitter;
            if (plNetClientMgr::GetInstance()->IsAPlayerKey(cEvent->fHittee))
            {
                // swap the above, since the hittee is actually the player
                playerKey = cEvent->fHittee;
                markerKey = cEvent->fHitter;
            }

            IMarkerHit(markerKey, playerKey);
        }

        return true;
    }

    plLoadCloneMsg* cloneMsg = plLoadCloneMsg::ConvertNoRef(msg);
    if (cloneMsg)
    {
        plKey cloneKey = cloneMsg->GetCloneKey();
        if (cloneMsg->GetIsLoading() && cloneKey)
        {
            UInt32 id;
            pfMarkerInfo* marker = IFindMarker(cloneKey, id);
            marker->InitSpawned(cloneKey);
        }

        return true;
    }

    return hsKeyedObject::MsgReceive(msg);
}