CWE-ou-minkata/Sources/Plasma/PubUtilLib/plModifier/plResponderSDLModifier.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 "plResponderSDLModifier.h"
#include "plSDL/plSDL.h"
#include "plResponderModifier.h"

// static vars
char plResponderSDLModifier::kStrCurState[]="curState";
char plResponderSDLModifier::kStrEnabled[]="enabled";
char plResponderSDLModifier::kStrCurCommand[]="curCommand";
char plResponderSDLModifier::kStrNetRequest[]="netRequest";
char plResponderSDLModifier::kStrCompletedEvents[]="completedEvents";
char plResponderSDLModifier::kStrPlayerKey[]="playerKey";
char plResponderSDLModifier::kStrTriggerer[]="triggerer";

plKey plResponderSDLModifier::GetStateOwnerKey() const
{
	return fResponder ? fResponder->GetKey() : nil;
}

//
// get current state from responder
// fill out state data rec
//
void plResponderSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
{
	hsAssert(fResponder, "nil responder?");

	dstState->FindVar(kStrCurState)->Set((int)fResponder->fCurState);
	dstState->FindVar(kStrEnabled)->Set(fResponder->fEnabled);
	
	dstState->FindVar(kStrCurCommand)->Set((int)fResponder->fCurCommand);	
	dstState->FindVar(kStrNetRequest)->Set(fResponder->fNetRequest);

	int i;
	int num=fResponder->fCompletedEvents.GetNumBitVectors();
	dstState->FindVar(kStrCompletedEvents)->Alloc(num);
	for(i=0;i<num; i++)
	{
		int ev = fResponder->fCompletedEvents.GetBitVector(i);
		dstState->FindVar(kStrCompletedEvents)->Set(ev, i);
	}
	
	dstState->FindVar(kStrPlayerKey)->Set(fResponder->fPlayerKey);
	dstState->FindVar(kStrTriggerer)->Set(fResponder->fTriggerer);
}

//
// apply incoming state to responder
//
void plResponderSDLModifier::ISetCurrentStateFrom(const plStateDataRecord* srcState)
{
	hsAssert(fResponder, "nil responder?");

	int curState = fResponder->fCurState;
	int curCommand = fResponder->fCurCommand;
	bool enabled = fResponder->fEnabled;
	bool netRequest = fResponder->fNetRequest;
	hsBitVector completedEvents = fResponder->fCompletedEvents;
	plKey playerKey = fResponder->fPlayerKey;
	plKey triggerer = fResponder->fTriggerer;

	plStateDataRecord::SimpleVarsList vars;
	int numVars = srcState->GetUsedVars(&vars);

	for (int i = 0; i < numVars; i++)
	{
		if (vars[i]->IsNamed(kStrCurState))
		{
			vars[i]->Get(&curState);
		}
		else if (vars[i]->IsNamed(kStrEnabled))
		{
			vars[i]->Get(&enabled);
		}
		else if (vars[i]->IsNamed(kStrCurCommand))
		{
			vars[i]->Get(&curCommand);
		}
		else if (vars[i]->IsNamed(kStrNetRequest))
		{
			vars[i]->Get(&netRequest);			
		}
		else if (vars[i]->IsNamed(kStrCompletedEvents))
		{
			int numEvents = vars[i]->GetCount();
			completedEvents.SetNumBitVectors(numEvents);

			for (int j = 0; j < numEvents; j++)
			{
				int bv;
				vars[i]->Get(&bv, j);
				completedEvents.SetBitVector(j, bv);
			}
		}
		else if (vars[i]->IsNamed(kStrPlayerKey))
		{
			vars[i]->Get(&playerKey);
		}
		else if (vars[i]->IsNamed(kStrTriggerer))
		{
			vars[i]->Get(&triggerer);
		}
		else
		{
			hsAssert(false, "Unknown var name");
		}
	}

	if (numVars)
	{
		bool stateValid = (curState >= 0 && curState < fResponder->fStates.Count());
		hsAssert(stateValid, "Received invalid responder state");
		if (!stateValid)
			return;

		bool cmdValid = curCommand == -1 || (curCommand >= 0 && curCommand < fResponder->fStates[curState].fCmds.Count());
		hsAssert(stateValid, "Received invalid responder command");
		if (!cmdValid)
			return;

		// Could try to validate the completed events, but if someone hacked that
		// all they could do is set events that we don't look at

		fResponder->fCurState = curState;
		fResponder->fCurCommand = curCommand;
		fResponder->fEnabled = enabled;
		fResponder->fNetRequest = netRequest;
		fResponder->fCompletedEvents = completedEvents;
		fResponder->fPlayerKey = playerKey;
		fResponder->fTriggerer = triggerer;

		fResponder->Restore();
	}
}