You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
387 lines
10 KiB
387 lines
10 KiB
/*==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 "hsTypes.h" |
|
#include "plLogicModBase.h" |
|
#include "plgDispatch.h" |
|
#include "hsResMgr.h" |
|
#include "hsTimer.h" |
|
#include "../pnSceneObject/plSceneObject.h" |
|
#include "../pnNetCommon/plGenericVar.h" |
|
#include "../pnNetCommon/plNetApp.h" |
|
#include "../pnNetCommon/plNetSharedState.h" |
|
#include "../../PubUtilLib/plNetMessage/plNetMessage.h" // breaks project dependancy levels |
|
#include "../pnMessage/plNotifyMsg.h" |
|
#include "../pnMessage/plEnableMsg.h" |
|
#include "../pnMessage/plServerReplyMsg.h" |
|
|
|
void plLogicModBase::ConsoleTrigger(plKey playerKey) |
|
{ |
|
// Setup the event data in case this is a OneShot responder that needs it |
|
proPickedEventData *ed = TRACKED_NEW proPickedEventData; |
|
ed->fPicker = playerKey; |
|
ed->fPicked = nil; |
|
fNotify->AddEvent(ed); |
|
|
|
Trigger(false); |
|
|
|
// Whoops, trigger and untrigger use the same message, so if we do this right away |
|
// it will just untrigger twice. So...uhh, we don't untrigger! |
|
// UnTrigger(); |
|
} |
|
|
|
void plLogicModBase::ConsoleRequestTrigger() |
|
{ |
|
RequestTrigger(); |
|
} |
|
|
|
plLogicModBase::plLogicModBase() : |
|
fCounter(0), |
|
fCounterLimit(0), |
|
fTimer(0.0f), |
|
fNotify(nil), |
|
fDisabled(false) |
|
{ |
|
fNotify = TRACKED_NEW plNotifyMsg; |
|
} |
|
|
|
plLogicModBase::~plLogicModBase() |
|
{ |
|
int i; |
|
for (i = 0; i < fCommandList.Count(); i++ ) |
|
{ |
|
hsRefCnt_SafeUnRef(fCommandList[i]); |
|
} |
|
|
|
hsRefCnt_SafeUnRef(fNotify); |
|
} |
|
|
|
void plLogicModBase::AddTarget(plSceneObject* so) |
|
{ |
|
plSingleModifier::AddTarget(so); |
|
} |
|
|
|
void plLogicModBase::RegisterForMessageType(UInt16 hClass) |
|
{ |
|
plgDispatch::Dispatch()->RegisterForExactType( hClass, GetKey() ); |
|
} |
|
|
|
// |
|
// Update generic shared state (which reflects trigger state) on server |
|
// by sending TestAndSet request. By locking and unlocking the sharedState, |
|
// we can guarantee that only one logicMod instance can trigger at a time. |
|
// The server will confirm or deny our request to lock and set the state. |
|
// |
|
void plLogicModBase::IUpdateSharedState(bool triggered) const |
|
{ |
|
plNetSharedState ss("TrigState"); |
|
plGenericVar* sv = TRACKED_NEW plGenericVar("Triggered"); |
|
sv->Value().SetBool(triggered); // attempting to set trig state to true |
|
ss.AddVar(sv); |
|
|
|
bool lock = triggered; |
|
|
|
// if unlocking, then the server does not need to store this state, since it's back to its default state |
|
ss.SetServerMayDelete(!lock); |
|
|
|
plNetMsgTestAndSet ts; |
|
ts.SetNetProtocol(kNetProtocolCli2Game); |
|
ts.CopySharedState(&ss); |
|
ts.ObjectInfo()->SetFromKey(GetKey()); |
|
ts.SetLockRequest(lock); // if triggering, lock state, else unlock state |
|
plNetClientApp::GetInstance()->SendMsg(&ts); |
|
plNetClientApp::GetInstance()->DebugMsg("\tLM: Attempting to set logic mod shared lock to %s, t=%f\n", |
|
triggered ? "Triggered" : "UnTriggered", hsTimer::GetSysSeconds()); |
|
} |
|
|
|
hsBool plLogicModBase::MsgReceive(plMessage* msg) |
|
{ |
|
// read messages: |
|
plServerReplyMsg* pSMsg = plServerReplyMsg::ConvertNoRef(msg); |
|
if (pSMsg) |
|
{ |
|
hsAssert(pSMsg->GetType() != plServerReplyMsg::kUnInit, "uninit server reply msg"); |
|
|
|
#if 1 |
|
char str[256]; |
|
sprintf(str, "LM: LogicModifier %s recvd trigger request reply:%s, wasRequesting=%d, t=%f\n", GetKeyName(), |
|
pSMsg->GetType() == plServerReplyMsg::kDeny ? "denied" : "confirmed", |
|
HasFlag(kRequestingTrigger), hsTimer::GetSysSeconds()); |
|
plNetClientApp::GetInstance()->DebugMsg(str); |
|
#endif |
|
|
|
if (pSMsg->GetType() == plServerReplyMsg::kDeny) |
|
{ |
|
if (HasFlag(kRequestingTrigger)) |
|
{ |
|
plNetClientApp::GetInstance()->DebugMsg("\tLM: Denied, clearing requestingTrigger"); |
|
ClearFlag(kRequestingTrigger); |
|
} |
|
else |
|
plNetClientApp::GetInstance()->DebugMsg("\tLM: Denied, but not requesting?"); |
|
} |
|
else |
|
{ |
|
hsBool netRequest=false; // we're triggering as a result of a local activation |
|
PreTrigger(netRequest); |
|
IUpdateSharedState(false /* untriggering */); |
|
} |
|
return true; |
|
} |
|
|
|
plEnableMsg* pEnable = plEnableMsg::ConvertNoRef(msg); |
|
if (pEnable) |
|
{ |
|
if (pEnable->Cmd(plEnableMsg::kDisable)) |
|
fDisabled = true; |
|
else |
|
if (pEnable->Cmd(plEnableMsg::kEnable)) |
|
{ |
|
ClearFlag(kTriggered); |
|
ClearFlag(kRequestingTrigger); |
|
|
|
fDisabled = false; |
|
} |
|
return true; |
|
} |
|
|
|
return plSingleModifier::MsgReceive(msg); |
|
} |
|
|
|
void plLogicModBase::RequestTrigger(hsBool netRequest) |
|
{ |
|
if (HasFlag(kTriggered)) |
|
{ |
|
#if 1 |
|
char str[256]; |
|
sprintf(str, "LM: %s ignoring RequestTrigger(), already triggered, t=%f\n", GetKeyName(), |
|
hsTimer::GetSysSeconds()); |
|
plNetClientApp::GetInstance()->DebugMsg(str); |
|
#endif |
|
return; |
|
} |
|
|
|
if (HasFlag(kRequestingTrigger)) |
|
{ |
|
#if 1 |
|
char str[256]; |
|
sprintf(str, "LM: %s ignoring RequestTrigger(), already requesting trigger, t=%f\n", GetKeyName(), |
|
hsTimer::GetSysSeconds()); |
|
plNetClientApp::GetInstance()->DebugMsg(str); |
|
#endif |
|
|
|
return; |
|
} |
|
if ( plNetApp::GetInstance()->GetFlagsBit(plNetClientApp::kLocalTriggers)) |
|
{ |
|
PreTrigger(false); |
|
} |
|
else |
|
{ |
|
IUpdateSharedState(true /* triggering */); // request arbitration from server |
|
SetFlag(kRequestingTrigger); |
|
|
|
#if 1 |
|
char str[256]; |
|
sprintf(str, "LM: %s Setting RequestingTriggert=%f\n", GetKeyName(), hsTimer::GetSysSeconds()); |
|
plNetClientApp::GetInstance()->DebugMsg(str); |
|
#endif |
|
|
|
} |
|
} |
|
|
|
// |
|
// return false is counter test fails |
|
// |
|
hsBool plLogicModBase::IEvalCounter() |
|
{ |
|
if (fCounterLimit > 0) |
|
{ |
|
fCounter = fCounter + 1; |
|
if (fCounter != fCounterLimit) |
|
{ |
|
Reset(false); |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
void plLogicModBase::PreTrigger(hsBool netRequest) |
|
{ |
|
if (fDisabled) |
|
return; |
|
|
|
Trigger(netRequest); |
|
} |
|
|
|
void plLogicModBase::Trigger(hsBool netRequest) |
|
{ |
|
#if 1 |
|
char str[256]; |
|
sprintf(str, "LogicModifier %s is triggering, activatorType=%d\n", |
|
GetKeyName(), HasFlag(kTypeActivator)); |
|
plNetClientApp::GetInstance()->DebugMsg(str); |
|
#endif |
|
|
|
ClearFlag(kRequestingTrigger); |
|
if (!HasFlag(kMultiTrigger)) |
|
SetFlag(kTriggered); |
|
fNotify->SetSender(this->GetKey()); |
|
fNotify->SetState(1.0f); |
|
fNotify->AddActivateEvent(true); |
|
// hsRefCnt_SafeRef(fNotify); |
|
plgDispatch::MsgSend( fNotify ); |
|
CreateNotifyMsg(); |
|
if (HasFlag(kOneShot)) |
|
fDisabled = true; |
|
} |
|
|
|
void plLogicModBase::UnTrigger() |
|
{ |
|
if (!HasFlag(kTriggered)) |
|
return; |
|
|
|
#ifdef HS_DEBUGGING |
|
char str[256]; |
|
sprintf(str, "LogicModifier %s is Un-triggering, activatorType=%d\n", |
|
GetKeyName(), HasFlag(kTypeActivator)); |
|
plNetClientApp::GetInstance()->DebugMsg(str); |
|
#endif |
|
fNotify->SetSender(this->GetKey()); |
|
fNotify->SetState(0.0f); |
|
fNotify->AddActivateEvent(false); |
|
// hsRefCnt_SafeRef(fNotify); |
|
plgDispatch::MsgSend( fNotify ); |
|
CreateNotifyMsg(); |
|
Reset(true); |
|
} |
|
|
|
void plLogicModBase::Reset(bool bCounterReset) |
|
{ |
|
ClearFlag(kTriggered); |
|
if (bCounterReset) |
|
fCounter = 0; |
|
} |
|
|
|
void plLogicModBase::CreateNotifyMsg() |
|
{ |
|
fNotify = TRACKED_NEW plNotifyMsg; |
|
for (int i = 0; i < fReceiverList.Count(); i++) |
|
fNotify->AddReceiver(fReceiverList[i]); |
|
} |
|
|
|
void plLogicModBase::AddNotifyReceiver(plKey receiver) |
|
{ |
|
fReceiverList.Append(receiver); |
|
fNotify->AddReceiver(receiver); |
|
} |
|
|
|
void plLogicModBase::Read(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plSingleModifier::Read(stream, mgr); |
|
int n = stream->ReadSwap32(); |
|
fCommandList.SetCountAndZero(n); |
|
for(int i = 0; i < n; i++ ) |
|
{ |
|
plMessage* pMsg = plMessage::ConvertNoRef(mgr->ReadCreatable(stream)); |
|
fCommandList[i] = pMsg; |
|
} |
|
if (fNotify) |
|
delete fNotify; |
|
plNotifyMsg* pNMsg = plNotifyMsg::ConvertNoRef(mgr->ReadCreatable(stream)); |
|
fNotify = pNMsg; |
|
|
|
fFlags.Read(stream); |
|
fDisabled = stream->Readbool(); |
|
for (int d = 0; d < fNotify->GetNumReceivers(); d++) |
|
fReceiverList.Append(fNotify->GetReceiver(d)); |
|
} |
|
|
|
void plLogicModBase::Write(hsStream* stream, hsResMgr* mgr) |
|
{ |
|
plSingleModifier::Write(stream, mgr); |
|
stream->WriteSwap32(fCommandList.GetCount()); |
|
for(int i = 0; i < fCommandList.GetCount(); i++ ) |
|
mgr->WriteCreatable( stream, fCommandList[i] ); |
|
mgr->WriteCreatable( stream, fNotify ); |
|
fFlags.Write(stream); |
|
stream->Writebool(fDisabled); |
|
} |
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Maintainers Marker Component |
|
// |
|
// |
|
#if 0 |
|
#include "../plModifier/plMaintainersMarkerModifier.h" |
|
|
|
//Class that accesses the paramblock below. |
|
class plMaintainersMarkerComponent : public plComponent |
|
{ |
|
public: |
|
plMaintainersMarkerComponent(); |
|
void DeleteThis() { delete this; } |
|
hsBool SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg); |
|
hsBool PreConvert(plMaxNode *pNode, plErrorMsg *pErrMsg); |
|
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg); |
|
}; |
|
|
|
//Max desc stuff necessary. |
|
CLASS_DESC(plMaintainersMarkerComponent, gMaintainersDesc, "Maintainers Marker", "MaintainersMarker", COMP_TYPE_TYPE, Class_ID(0x7d7f1f72, 0x405355f5)) |
|
|
|
//The MAX paramblock stuff below |
|
ParamBlockDesc2 gMaintainersBk |
|
( |
|
1, _T("maintainersMarker"), 0, &gMaintainersDesc, P_AUTO_CONSTRUCT, plComponent::kRefComp, |
|
end |
|
); |
|
|
|
plMaintainersMarkerComponent::plMaintainersMarkerComponent() |
|
{ |
|
fClassDesc = &gMaintainersDesc; |
|
fClassDesc->MakeAutoParamBlocks(this); |
|
} |
|
|
|
hsBool plMaintainersMarkerComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg) |
|
{ |
|
node->SetForceLocal(true); |
|
return true; |
|
} |
|
hsBool plMaintainersMarkerComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg) |
|
{ |
|
plMaintainersMarkerModifier* pSpawn = TRACKED_NEW plMaintainersMarkerModifier; |
|
node->AddModifier(pSpawn); |
|
return true; |
|
} |
|
|
|
hsBool plMaintainersMarkerComponent::PreConvert(plMaxNode *pNode, plErrorMsg *pErrMsg) |
|
{ |
|
return true; |
|
} |
|
#endif
|
|
|