CWE-ou-minkata/Sources/Plasma/FeatureLib/pfAnimation/plRandomCommandMod.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 <stdlib.h>

#include "hsTypes.h"
#include "plRandomCommandMod.h"
#include "pnSceneObject/plSceneObject.h"
#include "plMessage/plAnimCmdMsg.h"
#include "pnMessage/plEventCallbackMsg.h"
#include "plgDispatch.h"
#include "hsTimer.h"
#include "hsUtils.h"

static const hsScalar kRandNormalize = 1.f / 32767.f;

plRandomCommandMod::plRandomCommandMod()
{
    fState = 0;
    fMode = kNormal;
    fCurrent = -1;

    fMinDelay = 0;
    fMaxDelay = 0;
}

plRandomCommandMod::~plRandomCommandMod()
{
}

// return how many are left to choose from
int plRandomCommandMod::IExcludeSelections(int ncmds)
{
    if( fMode & kCoverall )
    {
        int nLeft = ncmds;

        fExcluded.SetBit(fCurrent);

        // Count how many haven't been played.
        int i;
        for( i = ncmds-1; i >= 0; --i )
        {
            if( fExcluded.IsBitSet(i) )
                nLeft--;
        }

        // If we're out of cmds, and OneCycle is set,
        // we're out of cmds until the next play.
        // Go ahead and reset for that.
        // If we're out and OneCycle isn't set, then go ahead 
        // and set up for a new cycle.
        if( !nLeft )
        {
            fExcluded.Clear();
            if( fMode & kNoRepeats )
                fExcluded.SetBit(fCurrent);

            if( fMode & kOneCycle )
                return 0;

            nLeft = ncmds;
            if( ( fMode & kNoRepeats ) && ncmds > 1 )
                nLeft--;
        }

        return nLeft;
    }
    double currTime = hsTimer::GetSysSeconds();
    fExcluded.Clear();
    int i;
    for( i = 0; i < fEndTimes.GetCount(); i++ )
    {
        if( fEndTimes[i] > currTime )
        {
            ncmds--;
            fExcluded.SetBit(i);
        }
    }
    if( fMode & kNoRepeats )
    {
        ncmds--;
        fExcluded.SetBit(fCurrent);
        return ncmds;
    }

    return ncmds;
}

hsScalar plRandomCommandMod::IGetDelay(hsScalar len) const
{
    hsScalar r = float(hsRand() * kRandNormalize);

    hsScalar delay = fMinDelay + (fMaxDelay - fMinDelay) * r;

    if( fMode & kDelayFromEnd )
        delay += len;

    if( delay < 0 )
        delay = fmodf(len, -delay);

    return delay;
}

hsBool plRandomCommandMod::ISelectNext(int ncmds)
{
    if( fMode & kSequential )
    {
        if( ++fCurrent >= ncmds )
        {
            if( fMode & kOneCycle )
            {
                fCurrent = -1;
                return false;
            }
            fCurrent = 0;
        }
        return true;
    }
    hsScalar r = float(hsRand() * kRandNormalize);

    int nSelect = ncmds;
    
    if( fCurrent >= 0 )
        nSelect = IExcludeSelections(ncmds);

    if( !nSelect )
        return false;

    int nth = int(r * (float(nSelect)-1.e-3f));
    
    int iNext = 0;
    int i;
    for( i = 0; i < ncmds; i++ )
    {
        if( !fExcluded.IsBitSet(i) )
        {
            if( !nth-- )
            {
                iNext = i;
                break;
            }
        }
    }
    fCurrent = iNext;

    return true;
}

void plRandomCommandMod::IStart() 
{ 
    if( !IStopped() )
        return;

    fState &= ~kStopped; 
    IPlayNextIfMaster();
}

void plRandomCommandMod::IStop() 
{ 
    fState |= kStopped; 
}

hsBool plRandomCommandMod::IStopped() const 
{ 
    return 0 != (fState & kStopped); 
}

void plRandomCommandMod::IPlayNextIfMaster()
{
    if( !fTarget )
        IRetry(2.f);
    
    if( fTarget->IsLocallyOwned() == plSynchedObject::kNo )     // if this object is a proxy, it should just wait for network cmds 
        return;

    if( IStopped() )
        return;

    IPlayNext();
}

hsBool plRandomCommandMod::MsgReceive(plMessage* msg)
{
    // plAnimCmdMsg - interpret start/stop appropriately.
    // could overinterpret set loop points to limit range of
    // cmds we use to a window of the total set.
    plAnimCmdMsg* anim = plAnimCmdMsg::ConvertNoRef(msg);
    if( anim )
    {
        if( anim->GetSender() != GetKey() )
        {
#if 0
            hsStatusMessageF("someone triggered me, remote=%d\n", 
                msg->HasBCastFlag(plMessage::kNetNonLocal));
#endif
            if( anim->Cmd(plAnimCmdMsg::kContinue) )
                IStart();
            if( anim->Cmd(plAnimCmdMsg::kStop) )
                IStop();
            if( anim->Cmd(plAnimCmdMsg::kToggleState) )
            {
                if( IStopped() )
                    IStart();
                else
                    IStop();
            }
        }
        else
        {
            
#if 0
            hsStatusMessageF("play next if master, remote=%d\n", 
                msg->HasBCastFlag(plMessage::kNetNonLocal));
#endif
            IPlayNextIfMaster();
        }
        return true;
    }

    // Don't understand, pass on to base class.
    return plSingleModifier::MsgReceive(msg);
}

void plRandomCommandMod::IReset()
{
    fCurrent = -1;
    fExcluded.Clear();

    if( !IStopped() )
        IRetry(0);
}

void plRandomCommandMod::Read(hsStream* s, hsResMgr* mgr)
{
    plSingleModifier::Read(s, mgr);

    fMode = s->ReadByte();
    fState = s->ReadByte();

    fMinDelay = s->ReadSwapScalar();
    fMaxDelay = s->ReadSwapScalar();

    IReset();
}

void plRandomCommandMod::Write(hsStream* s, hsResMgr* mgr)
{
    plSingleModifier::Write(s, mgr);

    s->WriteByte(fMode);
    s->WriteByte(fState);

    s->WriteSwapScalar(fMinDelay);
    s->WriteSwapScalar(fMaxDelay);
}

void plRandomCommandMod::IRetry(hsScalar secs)
{
    IStop();

    double t = hsTimer::GetSysSeconds() + secs;

    plAnimCmdMsg* msg = TRACKED_NEW plAnimCmdMsg(nil, GetKey(), &t);
    msg->SetCmd(plAnimCmdMsg::kContinue);
    plgDispatch::MsgSend(msg);
}