CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plAvatar/plArmatureEffects.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 "plAvCallbackAction.h"

#include "plStatusLog/plStatusLog.h"
#include "plArmatureEffects.h"
#include "pfMessage/plArmatureEffectMsg.h"
#include "plMessage/plAnimCmdMsg.h"
#include "plMessage/plAvatarMsg.h"
#include "plArmatureMod.h"
#include "pnSceneObject/plAudioInterface.h"
#include "plAudio/plSound.h"
#include "plAudio/plAudioSystem.h"
#include "pfAudio/plRandomSoundMod.h"
#include "hsResMgr.h"
#include "plgDispatch.h"

const char *plArmatureEffectsMgr::SurfaceStrings[] = 
{
	"Dirt",
	"Puddle",
	"Water",
	"Tile",
	"Metal",
	"WoodBridge",
	"RopeLadder",
	"Grass",
	"Brush",
	"HardWood",
	"Rug",
	"Stone",
	"Mud",
	"MetalLadder",
	"WoodLadder",
	"DeepWater",
	"Maintainer(Glass)",
	"Maintainer(Stone)",
	"Swimming",
	"(none)" // Keep this one last
};


void plArmatureEffectsMgr::Read(hsStream *s, hsResMgr *mgr)
{
	hsKeyedObject::Read(s, mgr);

	int numEffects = s->ReadSwap32();
	while (numEffects > 0)
	{
		plRefMsg *msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1);
		hsgResMgr::ResMgr()->ReadKeyNotifyMe(s, msg, plRefFlags::kActiveRef);
		numEffects--;
	}
	
	plgDispatch::Dispatch()->RegisterForExactType(plAvatarStealthModeMsg::Index(), GetKey());
}

void plArmatureEffectsMgr::Write(hsStream *s, hsResMgr *mgr)
{
	hsKeyedObject::Write(s, mgr);

	s->WriteSwap32(fEffects.GetCount());
	int i;
	for (i = 0; i < fEffects.GetCount(); i++)
		mgr->WriteKey(s, fEffects[i]->GetKey());
}

hsBool plArmatureEffectsMgr::MsgReceive(plMessage* msg)
{
	plEventCallbackInterceptMsg *iMsg = plEventCallbackInterceptMsg::ConvertNoRef(msg);
	if (iMsg)
	{
		if (fEnabled)
			iMsg->SendMessage();
	}

	plArmatureEffectMsg *eMsg = plArmatureEffectMsg::ConvertNoRef(msg);
	plArmatureEffectStateMsg *sMsg = plArmatureEffectStateMsg::ConvertNoRef(msg);
	if (eMsg || sMsg)
	{
		// Always handle state messages, but only trigger actual effects if we're enabled
		if (sMsg || fEnabled)
		{
			int i;
			for (i = 0; i < fEffects.GetCount(); i++)
				fEffects[i]->HandleTrigger(msg);
		}

		return true;
	}

	plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
	if (refMsg)
	{
		plArmatureEffect *effect = plArmatureEffect::ConvertNoRef(refMsg->GetRef());
		if (effect)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fEffects.Append(effect);
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )	
				fEffects.RemoveItem(effect);

			return true;
		}
	}

	plAvatarStealthModeMsg *stealthMsg = plAvatarStealthModeMsg::ConvertNoRef(msg);
	if (stealthMsg && stealthMsg->GetSender() == fArmature->GetTarget(0)->GetKey())
	{
		if (stealthMsg->fMode == plAvatarStealthModeMsg::kStealthCloaked)
			fEnabled = false;
		else
			fEnabled = true;

		return true;
	}

	return hsKeyedObject::MsgReceive(msg);
}

UInt32 plArmatureEffectsMgr::GetNumEffects()
{
	return fEffects.GetCount();
}

plArmatureEffect *plArmatureEffectsMgr::GetEffect(UInt32 num)
{
	return fEffects[num];
}

void plArmatureEffectsMgr::ResetEffects()
{
	int i;
	for (i = 0; i < fEffects.GetCount(); i++)
		fEffects[i]->Reset();
}

/////////////////////////////////////////////////////////////////////////////
//
//		Actual Effects
//
/////////////////////////////////////////////////////////////////////////////

plArmatureEffectFootSound::plArmatureEffectFootSound()
{
	plArmatureEffectFootSurface *surface = TRACKED_NEW plArmatureEffectFootSurface;
	surface->fID = plArmatureEffectsMgr::kFootNoSurface;
	surface->fTrigger = nil;
	fSurfaces.Append(surface);
	int i;
	for (i = 0; i < plArmatureEffectsMgr::kMaxSurface; i++)
	{
		fMods[i] = nil;
	}
	SetFootType(kFootTypeShoe);
}

plArmatureEffectFootSound::~plArmatureEffectFootSound() 
{
	int i;
	for (i = 0; i < fSurfaces.GetCount(); i++)
		delete fSurfaces[i];
}

void plArmatureEffectFootSound::Read(hsStream* s, hsResMgr* mgr)
{
	plArmatureEffect::Read(s, mgr);

	int count = s->ReadByte();
	int i;
	for (i = 0; i < count; i++)
	{
		plGenRefMsg *msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, i, -1);
		mgr->ReadKeyNotifyMe(s, msg, plRefFlags::kActiveRef);
	}
}

UInt32 plArmatureEffectFootSound::IFindSurfaceByTrigger(plKey trigger)
{
	UInt32 i;

	// Skip index 0. It's the special "NoSurface" that should always be at the stack bottom
	for (i = 1; i < fSurfaces.GetCount(); i++)
	{
		if (fSurfaces[i]->fTrigger == trigger)
			return i;
	}

	return -1;
}

void plArmatureEffectFootSound::Write(hsStream* s, hsResMgr* mgr)
{
	plArmatureEffect::Write(s, mgr);

	s->WriteByte(plArmatureEffectsMgr::kMaxSurface);
	int i;
	for (i = 0; i < plArmatureEffectsMgr::kMaxSurface; i++)
		mgr->WriteKey(s, (fMods[i] ? fMods[i]->GetKey() : nil));
}

hsBool plArmatureEffectFootSound::MsgReceive(plMessage* msg)
{
	plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
	if (refMsg)
	{
		plRandomSoundMod *rsMod = plRandomSoundMod::ConvertNoRef(refMsg->GetRef());
		if (rsMod)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
			{
				fMods[refMsg->fWhich] = rsMod;
			}
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )	
				fMods[refMsg->fWhich] = nil;

			return true;
		}
	}

	return plArmatureEffect::MsgReceive(msg);
}

hsBool plArmatureEffectFootSound::HandleTrigger(plMessage* msg)
{
	plArmatureEffectMsg *eMsg = plArmatureEffectMsg::ConvertNoRef(msg);
	if (eMsg)
	{
		UInt32 curSurfaceIndex = fSurfaces[fSurfaces.GetCount() - 1]->fID;

		if (curSurfaceIndex < plArmatureEffectsMgr::kMaxSurface && fMods[curSurfaceIndex] != nil)
		{
			if (plgAudioSys::Active() && fActiveSurfaces.IsBitSet(curSurfaceIndex))
			{
				fMods[curSurfaceIndex]->SetCurrentGroup(eMsg->fTriggerIdx);
				plAnimCmdMsg *animMsg = TRACKED_NEW plAnimCmdMsg;
				animMsg->AddReceiver(fMods[curSurfaceIndex]->GetKey());
				animMsg->SetCmd(plAnimCmdMsg::kContinue);
				plgDispatch::MsgSend(animMsg);
			}
		}

		return true;
	}

	plArmatureEffectStateMsg *sMsg = plArmatureEffectStateMsg::ConvertNoRef(msg);
	if (sMsg)
	{
		// It doesn't matter if we're adding or removing a surface, our load/unload is the same:
		// unload the old surface and load the new one
		
		if (sMsg->fAddSurface)
		{
			if (IFindSurfaceByTrigger(sMsg->GetSender()) == -1) // Check that it's not a repeat msg
			{
				plStatusLog::AddLineS("audio.log", "FTSP: Switching to surface - %s", 
									  plArmatureEffectsMgr::SurfaceStrings[sMsg->fSurface]);
				plArmatureEffectFootSurface *surface = TRACKED_NEW plArmatureEffectFootSurface;
				surface->fID = sMsg->fSurface;
				surface->fTrigger = sMsg->GetSender();
				fSurfaces.Append(surface);
			}	
		}
		else
		{
			UInt32 index = IFindSurfaceByTrigger(sMsg->GetSender());
			if (index != -1)
			{
				if (index == fSurfaces.GetCount() - 1) // It's the top on the stack
					plStatusLog::AddLineS("audio.log", "FTSP: Switching to surface - %s", 
										  plArmatureEffectsMgr::SurfaceStrings[fSurfaces[index - 1]->fID]);
				delete fSurfaces[index];
				fSurfaces.Remove(index);
			}
		}
		return true;
	}

	return false;
}

void plArmatureEffectFootSound::Reset()
{
	while (fSurfaces.GetCount() > 1)
		delete fSurfaces.Pop();
}

void plArmatureEffectFootSound::SetFootType(UInt8 type)
{
	if (type == kFootTypeBare)
	{
		fActiveSurfaces.Clear();
		fActiveSurfaces.SetBit(plArmatureEffectsMgr::kFootDeepWater);
		fActiveSurfaces.SetBit(plArmatureEffectsMgr::kFootPuddle);
		fActiveSurfaces.SetBit(plArmatureEffectsMgr::kFootWater);
		fActiveSurfaces.SetBit(plArmatureEffectsMgr::kFootSwimming);
	}
	else
	{
		fActiveSurfaces.Set(plArmatureEffectsMgr::kMaxSurface);
	}
}