long CNetDispatch::OnNetMsg( WPARAM wParam, LPARAM lParam )
{_STT();
CNetCom *pNc = (CNetCom*)lParam;
if ( pNc == NULL ) return FALSE;
// Attempt callback
return OnMsg( wParam, pNc );
}
bool UnitTest3b::States( State_Machine_Event event, MSG_Object * msg, int state, int substate )
{
BeginStateMachine
//Global message responses
///////////////////////////////////////////////////////////////
DeclareState( STATE_Initialize )
OnEnter
ChangeState( STATE_Chain1 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain1 )
OnMsg( MSG_UnitTestPing )
SendMsgDelayed( 1.0f, MSG_UnitTestAck, msg->GetSender() );
OnMsg( MSG_UnitTestAck )
SendMsg( MSG_UnitTestDone, msg->GetSender() );
OnCCMsg( MSG_UnitTestDone )
ChangeStateDelayed( 1.5f, STATE_Success );
OnCCMsg( MSG_UnitTestMessage )
ChangeState( STATE_Broken );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Success )
OnEnter
OutputDebugString( L"UnitTest3b Success\n" );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Broken )
OnEnter
OutputDebugString( L"UnitTest3b Broken\n" );
EndStateMachine
}
void MsgLogic()
{
PACKET_COMMAND* pack = NULL;
while ((pack = GETSERVERNET->getHeadPacket()))
{
OnMsg(pack);
SAFE_DELETE(pack);
}
}
bool UnitTest3a::States( State_Machine_Event event, MSG_Object * msg, int state, int substate )
{
BeginStateMachine
//Global message responses
///////////////////////////////////////////////////////////////
DeclareState( STATE_Initialize )
OnEnter
ChangeStateDelayed( 1.0f, STATE_Chain1 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain1 )
OnEnter
SendMsgBroadcastNow( MSG_UnitTestPing, OBJECT_Ignore_Type );
OnMsg( MSG_UnitTestAck )
BroadcastAddToList( msg->GetSender() );
SetCCReceiver( msg->GetSender() );
SendMsgBroadcastToList( MSG_UnitTestAck );
OnMsg( MSG_UnitTestDone )
ClearCCReceiver();
SendMsgDelayedToState( 1.0f, MSG_UnitTestMessage );
OnMsg( MSG_UnitTestMessage )
ChangeState( STATE_Success );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Success )
OnEnter
OutputDebugString( L"UnitTest3a Success\n" );
EndStateMachine
}
bool NetProtocol::Update(STATUS status, ShareNetSocketPtr& pNetSocket)
{
switch(status)
{
case IOS_DISCONNECT:
OnDisconnect(pNetSocket);
break;
case IOS_ACCEPT:
OnConnect(pNetSocket);
break;
case IOS_RECV:
case IOS_RECVFROM:
OnMsg(pNetSocket);
break;
}
return true;
}
int SMessageLoop::Run()
{
BOOL bDoIdle = TRUE;
int nIdleCount = 0;
BOOL bRet;
m_bRunning = TRUE;
m_bQuit = FALSE;
for(;;)
{
while(bDoIdle && !::PeekMessage(&m_msg, NULL, 0, 0, PM_NOREMOVE))
{
if(!OnIdle(nIdleCount++))
bDoIdle = FALSE;
if (m_bQuit) goto exit_loop;
}
bRet = ::GetMessage(&m_msg, NULL, 0, 0);
if(bRet == -1)
{
SLOGFMTE(_T("::GetMessage returned -1 (error)"));
continue; // error, don't process
}
else if(!bRet)
{
SLOGFMTT(_T("SMessageLoop::Run - exiting,code = %d"),(int)m_msg.wParam);
break; // WM_QUIT, exit message loop
}
OnMsg(&m_msg);
if(IsIdleMessage(&m_msg))
{
bDoIdle = TRUE;
nIdleCount = 0;
}
if (m_bQuit) break;
}
exit_loop:
m_bRunning = FALSE;
return (int)m_msg.wParam;
}
int SMessageLoop::Run()
{
BOOL bDoIdle = TRUE;
int nIdleCount = 0;
BOOL bRet;
for(;;)
{
while(bDoIdle && !::PeekMessage(&m_msg, NULL, 0, 0, PM_NOREMOVE))
{
if(!OnIdle(nIdleCount++))
bDoIdle = FALSE;
}
bRet = ::GetMessage(&m_msg, NULL, 0, 0);
if(bRet == -1)
{
STRACE(_T("::GetMessage returned -1 (error)"));
continue; // error, don't process
}
else if(!bRet)
{
STRACE(_T("SMessageLoop::Run - exiting"));
break; // WM_QUIT, exit message loop
}
OnMsg(&m_msg);
if(IsIdleMessage(&m_msg))
{
bDoIdle = TRUE;
nIdleCount = 0;
}
}
return (int)m_msg.wParam;
}
int CDOSObjectProxyService::DoMessageProcess(int ProcessPacketLimit)
{
FUNCTION_BEGIN;
int ProcessCount=0;
CDOSMessagePacket * pPacket;
while(m_MsgQueue.PopFront(pPacket))
{
//PrintDOSDebugLog(0,_T("发送了消息[%u]"),pPacket->GetMessage().GetMsgID());
OnMsg(&(pPacket->GetMessage()));
if(!((CDOSServer *)GetServer())->ReleaseMessagePacket(pPacket))
{
PrintDOSLog(0xff0000,_T("释放消息内存块失败！"));
}
ProcessCount++;
if(ProcessCount>=ProcessPacketLimit)
break;
}
return ProcessCount;
FUNCTION_END;
return 0;
}
int GTankGob::ProcessStateMachineMessage(State st, Message *pmsg)
{
BeginStateMachine
OnMsg(kmidFire)
UnitGob *puntTarget = (UnitGob *)ggobm.GetGob(m_gidTarget);
if (puntTarget != NULL) {
// Fire off the shot!
WCoord wdxRnd = ((GetRandom() & 7) - 3) * kwcTile16th;
WCoord wdyRnd = ((GetRandom() & 7) - 3) * kwcTile16th;
WPoint wpt;
puntTarget->GetCenter(&wpt);
Point ptSpecial;
m_aniTurret.GetSpecialPoint(&ptSpecial, kifrmTankAction);
CreateBulletGob(m_wx + WcFromPc(ptSpecial.x), m_wy + WcFromPc(ptSpecial.y), wpt.wx + wdxRnd, wpt.wy + wdyRnd,
GetDamageTo(puntTarget) / 3, m_gid, puntTarget->GetId());
}
#if 0
EndStateMachineInherit(MobileUnitGob)
#else
return knHandled;
}
/**
* State machine
*/
bool SMRandomPath::States( State_Machine_Event event, MSG_Object* msg, int state, int substate )
{
BeginStateMachine
// global message responses
OnMsg(MSG_Damaged)
// update health and seek player
m_owner->SetHealth( m_owner->GetHealth() - msg->GetIntData() );
PushStateMachine( *new SMCombat( m_owner, g_database.Find(m_idPlayer)->GetID(), true) );
OnMsg(MSG_Reset)
// reset machine
ChangeState(STATE_PickPath);
/*-------------------------------------------------------------------------*/
DeclareState( STATE_PickPath )
OnEnter
// start path computation request
g_world.AddPathRequest(m_owner->GetGridPosition(), g_world.GetRandomMapLocation(), m_owner->GetID());
OnMsg(MSG_PathComputed)
// follow path
ChangeStateDelayed(1.0f, STATE_FollowPath);
/*-------------------------------------------------------------------------*/
DeclareState( STATE_FollowPath )
OnEnter
// set velocity
m_owner->SetVelocity(5.0f);
m_owner->SetAcceleration(0.5f);
OnUpdate
PathWaypointList* waypointList = g_world.GetWaypointList(m_owner->GetID());
// check if player nearby
D3DXVECTOR3 vPlayerDist = m_owner->GetPosition() - g_database.Find(m_idPlayer)->GetPosition();
if( D3DXVec3Length( &vPlayerDist ) < 4.0f && g_database.Find(m_idPlayer)->GetHealth() > 0 )
{
ChangeState( STATE_SwitchToCombat );
}
// if out of waypoints, pick new path
else if(waypointList->empty())
{
ChangeState( STATE_PickPath );
}
// move towards waypoint
else
{
// determine direction (ignore height)
D3DXVECTOR2 vDirection = (*waypointList->begin()) - m_owner->GetGridPosition();
// determine if the object has arrived
if( D3DXVec2Length( &vDirection ) < 0.1f )
{
// pop off waypoint
waypointList->pop_front();
}
else
{
// set object direction towards position
D3DXVec2Normalize(&vDirection, &vDirection);
m_owner->SetGridDirection(vDirection);
}
}
OnExit
// remove any waypoints
g_world.ClearWaypointList(m_owner->GetID());
// stop object
m_owner->ResetMovement();
/*-------------------------------------------------------------------------*/
DeclareState( STATE_SwitchToCombat )
OnEnter
// push combat state machine
PushStateMachine( *new SMCombat( m_owner, g_database.Find(m_idPlayer)->GetID(), false) );
/*-------------------------------------------------------------------------*/
EndStateMachine
}
int ReplicatorGob::ProcessStateMachineMessage(State st, Message *pmsg)
{
BeginStateMachine
OnMsg(kmidPlaySfx)
gsndm.PlaySfx((Sfx)pmsg->PlaySfx.sfx);
State(kstIdle)
OnUpdate
// If a mobile unit is at either output, ask it to move on
TPoint tpt;
GetTilePosition(&tpt);
Gid gid;
// Clear left and right output bays
Player *pplrNeedCredits = NULL;
bool fJammed = ClearOutputBay(tpt.tx + kdtxReplicatorOutput1, tpt.ty + kdtyReplicatorOutput1, tpt.tx + kdtxReplicatorOutput1 - 1, tpt.ty + kdtyReplicatorOutput1 + 1);
fJammed = ClearOutputBay(tpt.tx + kdtxReplicatorOutput2, tpt.ty + kdtyReplicatorOutput2, tpt.tx + kdtxReplicatorOutput2 + 1, tpt.ty + kdtyReplicatorOutput2 + 1) || fJammed;
// If there's nothing clogging the outputs we can consider the input
if (m_fEnabled && !fJammed) {
// loop through all the gobs on this tile to find the mobile unit and ignore ourself, or
// shots flying by
for (gid = ggobm.GetFirstGid(tpt.tx + kdtxReplicatorInput, tpt.ty + kdtyReplicatorInput); gid != kgidNull; gid = ggobm.GetNextGid(gid)) {
MobileUnitGob *pmunt = (MobileUnitGob *)ggobm.GetGob(gid);
if (pmunt == NULL)
continue;
if (!(pmunt->GetFlags() & kfGobMobileUnit))
continue;
// Something there! If it's ready, clone it.
if (!(pmunt->GetMobileUnitFlags() & kfMuntAtReplicatorInput))
continue;
// At the limit?
// TUNE:
#define kctIntervalLimitNotify 600
if (!ggobm.IsBelowLimit(knLimitMobileUnit, pmunt->GetOwner())) {
if (pmunt->GetOwner() == gpplrLocal) {
static long s_tLastNotify;
long tCurrent = gtimm.GetTickCount();
if (abs((int)(s_tLastNotify - tCurrent)) >= kctIntervalLimitNotify) {
s_tLastNotify = tCurrent;
ShowAlert(kidsUnitLimitReached);
}
}
continue;
}
// Does the player have enough credits to perform the replication?
MobileUnitConsts *pmuntc = (MobileUnitConsts *)pmunt->GetConsts();
Player *pplr = pmunt->GetOwner();
int cCredits = pplr->GetCredits();
int nCost = pmuntc->GetCost();
int cReplicationCost = GetReplicationCost(nCost);
if (cCredits < cReplicationCost) {
pplrNeedCredits = pplr;
break;
}
// Take the money!
pplr->SetCredits(cCredits - cReplicationCost, true);
// Remove highlight
pmunt->Hilight(false);
// Start the replicating animation
m_fReplicating = true;
m_ifrmLights = -1;
MobileUnitGob *pmuntClone = (MobileUnitGob *)CreateGob(pmunt->GetType());
if (pmuntClone != NULL) {
pmuntClone->Init(WcFromTc(tpt.tx + kdtxReplicatorOutput2), WcFromTc(tpt.ty + kdtyReplicatorOutput2), pmunt->GetOwner(), pmunt->GetHealth(), 0, NULL);
// Clone acquires the selection state of the original
if (pmunt->GetFlags() & kfGobSelected)
pmuntClone->Select(true);
// Replicated GalaxMiners lose their load of Galaxite
// UNDONE: if there is more of this special casing go with virtual UnitGob::Replicate()
if (pmunt->GetType() == kgtGalaxMiner)
((MinerGob *)pmunt)->SetGalaxiteAmount(0);
// If this unit is a member of a group add its clone to the group too
UnitGroup *pug = gsim.GetLevel()->GetUnitGroupMgr()->GetUnitGroup(pmunt->GetId());
if (pug != NULL)
pug->AddUnit(pmuntClone, true);
}
// Warp the original Unit to the left output port
TerrainMap *ptrmap = gsim.GetLevel()->GetTerrainMap();
ptrmap->ClearFlags(tpt.tx + kdtxReplicatorInput, tpt.ty + kdtyReplicatorInput, 1, 1, kbfMobileUnit);
ptrmap->SetFlags(tpt.tx + kdtxReplicatorOutput1, tpt.ty + kdtyReplicatorOutput1, 1, 1, kbfMobileUnit);
pmunt->SetPosition(WcFromTc(tpt.tx + kdtxReplicatorOutput1) + kwcTileHalf, WcFromTc(tpt.ty + kdtyReplicatorOutput1) + kwcTileHalf);
// Clear the bit
pmunt->SetMobileUnitFlags(pmunt->GetMobileUnitFlags() & ~kfMuntAtReplicatorInput);
// Let player know the replication process has happened
// play cool replication sound effect
gsndm.PlaySfx(ksfxReplicatorBuild);
// wait a quarter second and let the new unit announce itself
Sfx sfx = SfxFromCategory(pmuntc->sfxcSelect);
Message msgT;
memset(&msgT, 0, sizeof(msgT));
msgT.mid = kmidPlaySfx;
msgT.smidSender = m_gid;
msgT.smidReceiver = m_gid;
msgT.PlaySfx.sfx = sfx;
gsmm.SendDelayedMsg(&msgT, 24);
// Play it again in another quarter of a second to sound cool
memset(&msgT, 0, sizeof(msgT));
msgT.mid = kmidPlaySfx;
msgT.smidSender = m_gid;
msgT.smidReceiver = m_gid;
msgT.PlaySfx.sfx = sfx;
gsmm.SendDelayedMsg(&msgT, 48);
break;
}
}
if (m_fReplicating) {
m_ifrmLights++;
int nStrip = m_pmuntc->panid->GetStripIndex("l 0");
if (m_ifrmLights / 2 >= m_pmuntc->panid->GetFrameCount(nStrip)) {
m_ifrmLights = -1;
m_fReplicating = false;
}
MarkRedraw();
}
WaitingForCredits(pplrNeedCredits != NULL, false, pplrNeedCredits);
m_unvl.MinSkip();
DefUpdate();
#if 0
EndStateMachineInherit(StructGob)
#else
return knHandled;
}
void OnUserNotice(User* user, void* dest, int target_type, const std::string& text, char status, const CUList& exempt_list)
{
OnMsg(user, dest, target_type, text, status, "NOTICE");
}
void OnUserMessage(User* user, void* dest, int target_type, const std::string& text, char status, const CUList& exempt_list)
{
OnMsg(user, dest, target_type, text, status, "PRIVMSG");
}
bool UnitTest4::States( State_Machine_Event event, MSG_Object * msg, int state, int substate )
{
BeginStateMachine
//Global message responses
OnMsg( MSG_UnitTestMessage )
ChangeState( STATE_Broken );
OnMsg( MSG_UnitTestBroken )
ChangeState( STATE_Broken );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Initialize )
OnEnter
ChangeState( STATE_Chain1 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain1 )
OnEnter
SendMsgDelayedToSubstate( 1.0f, MSG_UnitTestMessage );
OnMsg( MSG_UnitTestMessage )
ChangeSubstate( SUBSTATE_Inside1 );
OnExit
SendMsgDelayedToStateMachine( 2.0f, MSG_UnitTestMessage2 ); //Should get caught in STATE_Chain3
DeclareSubstate( SUBSTATE_Inside1 )
OnEnter
SendMsgDelayedToSubstate( 1.0f, MSG_UnitTestMessage );
OnMsg( MSG_UnitTestMessage )
SendMsgDelayedToSubstate( 1.0f, MSG_UnitTestBroken ); //Should never be delivered due to scoping
ChangeSubstateDelayed( 0.5f, SUBSTATE_Inside2 );
DeclareSubstate( SUBSTATE_Inside2 )
OnEnter
SendMsgDelayedToSubstate( 1.0f, MSG_UnitTestMessage2 );
OnMsg( MSG_UnitTestMessage2 )
ChangeSubstate( SUBSTATE_Inside3 );
OnExit
SendMsgDelayedToState( 1.0f, MSG_UnitTestMessage3 );
DeclareSubstate( SUBSTATE_Inside3 )
OnMsg( MSG_UnitTestMessage3 )
ChangeState( STATE_Chain2 ); //Should trigger OnExit in both substate and state
OnExit
SendMsgDelayedToStateMachine( 1.0f, MSG_UnitTestMessage ); //Should get caught in STATE_Chain2
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain2 )
OnMsg( MSG_UnitTestMessage )
ChangeState( STATE_Chain3 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain3 )
OnMsg( MSG_UnitTestMessage2 )
ChangeState( STATE_Chain4 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain4 )
OnEnter
SendMsgDelayedToState( 1.0f, MSG_UnitTestMessage );
OnMsg( MSG_UnitTestMessage )
ChangeState( STATE_Chain5 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain5 )
OnEnter
ChangeSubstate( SUBSTATE_Inside1 );
DeclareSubstate( SUBSTATE_Inside1 )
OnEnter
ChangeSubstate( SUBSTATE_Inside2 );
OnExit
SendMsgDelayedToState( 1.0f, MSG_UnitTestMessage );
DeclareSubstate( SUBSTATE_Inside2 )
OnEnter
ChangeStateDelayed( 2.0f, STATE_Broken );
OnMsg( MSG_UnitTestMessage )
ChangeState( STATE_Chain6 );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Chain6 )
OnEnter
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage, MSG_Data(1) );
OnMsg( MSG_UnitTestMessage )
if( msg->IsIntData() && msg->GetIntData() == 1 ) {
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage2, MSG_Data(1.0f) );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage2 )
if( msg->IsFloatData() && msg->GetFloatData() == 1.0f ) {
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage3, MSG_Data(true) );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage3 )
if( msg->IsBoolData() && msg->GetBoolData() == true ) {
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage4, MSG_Data(m_owner->GetID()) );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage4 )
if( msg->IsObjectIDData() && msg->GetObjectIDData() == m_owner->GetID() ) {
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage5, MSG_Data(m_owner) );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage5 )
if( msg->IsPointerData() && msg->GetPointerData() == m_owner ) {
D3DXVECTOR2 v = D3DXVECTOR2( 10.0f, 5.0f );
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage6, MSG_Data( v ) );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage6 )
if( msg->IsVector2Data() && msg->GetVector2Data().x == 10.0f && msg->GetVector2Data().y == 5.0f ) {
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage7, MSG_Data( D3DXVECTOR3( 2.0f, 4.0f, 6.0f ) ) );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage7 )
if( msg->IsVector3Data() && msg->GetVector3Data().x == 2.0f && msg->GetVector3Data().y == 4.0f && msg->GetVector3Data().z == 6.0f ) {
SendMsgDelayedToState( 0.2f, MSG_UnitTestMessage8 );
}
else {
ChangeState( STATE_Broken );
}
OnMsg( MSG_UnitTestMessage8 )
if( msg->IsValidData() ) {
ChangeState( STATE_Broken );
}
else {
ChangeState( STATE_Success );
}
///////////////////////////////////////////////////////////////
DeclareState( STATE_Success )
OnEnter
OutputDebugString( L"UnitTest4 Success\n" );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Broken )
OnEnter
OutputDebugString( L"UnitTest4 Broken\n" );
EndStateMachine
}
bool Example::States( State_Machine_Event event, MSG_Object * msg, int state, int substate )
{
BeginStateMachine
//Global message response section
OnMsg( MSG_Reset )
ResetStateMachine();
OnMsg( MSG_MouseClick )
m_owner->GetMovement().SetTarget( msg->GetVector3Data() );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Initialize )
OnEnter
m_owner->GetMovement().SetIdleSpeed();
ChangeStateDelayed( 1.0f, STATE_Idle );
//m_owner->GetTiny().SetDiffuse(1.0f, 0.0f, 0.0f); //Color Tiny (Example)
///////////////////////////////////////////////////////////////
DeclareState( STATE_PickPlayerToChase )
OnEnter
m_owner->GetMovement().SetWalkSpeed();
m_curTarget = GetFarthestAgent();
if( m_curTarget == 0 ) {
ChangeState( STATE_MoveToRandomTarget );
}
SendMsgToStateMachineNow( MSG_SetTargetPosition );
OnMsg( MSG_SetTargetPosition )
GameObject* go = g_database.Find( m_curTarget );
if( go ) {
D3DXVECTOR3 target = go->GetBody().GetPos();
m_owner->GetMovement().SetTarget( target );
}
SendMsgToState( MSG_SetTargetPosition );
OnMsg( MSG_Arrived )
ChangeState( STATE_Idle );
///////////////////////////////////////////////////////////////
DeclareState( STATE_Idle )
OnEnter
m_owner->GetMovement().SetIdleSpeed();
if( rand()%2 == 0 ) {
ChangeStateDelayed( RandDelay( 1.0f, 2.0f ), STATE_MoveToRandomTarget );
}
else {
ChangeStateDelayed( RandDelay( 1.0f, 2.0f ), STATE_PickPlayerToChase );
}
///////////////////////////////////////////////////////////////
DeclareState( STATE_MoveToRandomTarget )
OnEnter
m_owner->GetMovement().SetJogSpeed();
D3DXVECTOR3 target( 0, 0, 0 );
target.x = (float) ( rand() % 256 ) / 256.f;
target.z = (float) ( rand() % 256 ) / 256.f;
m_owner->GetMovement().SetTarget( target );
OnMsg( MSG_Arrived )
ChangeState( STATE_Idle );
EndStateMachine
}
