pmtplayback.c

Go to the documentation of this file.

class PMTPlayback : PMTF
{
    ref array<ParticleSource> m_ParticleSources = new array<ParticleSource>();
    
    // TestOnePlaying
    int m_OnePlayingManagerID;
    bool m_bOnePlayingTestSuccess = false;
    
    // TestOnePlayingStandAloneAutoDestroy
    int m_OnePlayingSAADPSID;
    bool m_bOnePlayingSAADEnded = false;
    
    // TestOnePlayingStandAlone
    int m_OnePlayingSAPSID;
    bool m_bOnePlayingSAEnded = false;
    
    // TestStop
    int m_StopPSID;
    float m_StopAccumulatedTime;
    static const float STOP_ACCUMULATED_TIME_STOP_CUTOFF = 2;
    static const float STOP_ACCUMULATED_TIME_PLAY_CUTOFF = 3;
    bool m_bStopWasStopped = false;
    bool m_bStopWasResumed = false;
    bool m_bStopEnded = false;
    
    //---------------------------------------------------------------------------
    // Ctor - Decides the tests to run
    //---------------------------------------------------------------------------
    void PMTPlayback()
    {
        //AddInitTest("TestOnePlaying");
        //AddInitTest("TestOnePlayingStandAloneAutoDestroy");
        //AddInitTest("TestOnePlayingStandAlone");
        //AddInitTest("TestWiggleStress");
        AddInitTest("TestStopping");
    }
    
    //---------------------------------------------------------------------------
    // Tests
    //---------------------------------------------------------------------------
    // Test one particle playing
    TFResult TestOnePlaying()
    {
        ParticleManager pm = CreatePMFixedBlocking(1);
        m_OnePlayingManagerID = InsertManager(pm);
 
        DayZPlayer player = GetGame().GetPlayer();
        
        ParticleSource p = pm.CreateParticleById(ParticleList.EXPLOSION_LANDMINE, new ParticleProperties(player.GetPosition() + player.GetDirection() * 3, true));
        p.GetEvents().Event_OnParticleEnd.Insert(PassOnePlaying);
        
        AddFrameTest("CheckOnePlaying");
 
        return BTFR(p.IsParticlePlaying());
    }
    
    //---------------------------------------------------------------------------
    // Test one standalone particle playing which will auto destroy
    TFResult TestOnePlayingStandAloneAutoDestroy()
    {
        DayZPlayer player = GetGame().GetPlayer();
        
        ParticleSource p = ParticleSource.CreateParticle(ParticleList.EXPLOSION_LANDMINE, player.GetPosition() + player.GetDirection() * 3 + player.GetDirectionAside() * 3, true);
        p.GetEvents().Event_OnParticleEnd.Insert(OnePlayingSAADEnded);
        
        m_OnePlayingSAADPSID = m_ParticleSources.Insert(p);
        
        AddFrameTest("CheckOnePlayingSAAD");
 
        return BTFR(p.IsParticlePlaying());
    }
    
    //---------------------------------------------------------------------------
    // Test one standalone particle playing which will not auto destroy
    TFResult TestOnePlayingStandAlone()
    {
        DayZPlayer player = GetGame().GetPlayer();
        
        ParticleSource p = ParticleSource.CreateParticle(ParticleList.EXPLOSION_LANDMINE, player.GetPosition() + player.GetDirection() * 3 - player.GetDirectionAside() * 3, true);
        p.GetEvents().Event_OnParticleEnd.Insert(OnePlayingSAEnded);
        p.DisableAutoDestroy();
        
        m_OnePlayingSAPSID = m_ParticleSources.Insert(p);
        
        AddFrameTest("CheckOnePlayingSA");
 
        return BTFR(p.IsParticlePlaying());
    }
    
    //---------------------------------------------------------------------------
    // Test wiggling
    TFResult TestWiggleStress()
    {
        DayZPlayer player = GetGame().GetPlayer();
        
        ParticleSource p = ParticleSource.CreateParticle(ParticleList.ROADFLARE_BURNING_MAIN, player.GetPosition() + player.GetDirection() * 4, true);
        p.SetWiggle(90, 0.1);
 
        return BTFR(p.IsParticlePlaying());
    }
    
    //---------------------------------------------------------------------------
    // Test stop
    TFResult TestStopping()
    {
        DayZPlayer player = GetGame().GetPlayer();
        
        //ParticleSource p = ParticleSource.CreateParticle(ParticleList.EXPLOSION_LANDMINE, player.GetPosition() + player.GetDirection() * 4, true);
        ParticleSource p = ParticleSource.CreateParticle(ParticleList.EXPLOSION_LANDMINE, vector.Zero, true, player);
        p.GetEvents().Event_OnParticleEnd.Insert(StopEnded);
        p.DisableAutoDestroy();
        
        m_StopPSID = m_ParticleSources.Insert(p);
        
        AddFrameTest("CheckStop");
 
        return BTFR(p.IsParticlePlaying());
    }
    
    //---------------------------------------------------------------------------
    // OnFrame Checks
    //---------------------------------------------------------------------------
    TFResult CheckOnePlaying()
    {
        ParticleManager pm;
        if (GetManager(m_OnePlayingManagerID, pm))
        {
            if (pm)
            {
                ParticleSource p = pm.GetParticle(0);
                if (p.IsParticlePlaying())
                {
                    return NTFR(TFR.PENDING);
                }
                else
                {
                    return BTFR(m_bOnePlayingTestSuccess);
                }
            }
            else
            {
                return BTFR(Assert(false));
            }
        }
        else
        {
            return BTFR(Assert(false));
        }
    }
    
    //---------------------------------------------------------------------------
    TFResult CheckOnePlayingSAAD()
    {
        if (m_ParticleSources.IsValidIndex(m_OnePlayingSAADPSID))
        {
            ParticleSource p = m_ParticleSources[m_OnePlayingSAADPSID];
            if (p)
            {
                if (p.IsParticlePlaying())
                {
                    return NTFR(TFR.PENDING);
                }
                else
                {
                    if (m_bOnePlayingSAADEnded)
                    {
                        // There might be one frame where it is still alive before getting cleaned up
                        return NTFR(TFR.PENDING);
                    }
                    else
                    {
                        // Should be gone when no longer playing
                        return BTFR(Assert(false));
                    }
                }
            }
            else
            {
                // Make sure the particle ended, if it did, then success!
                return BTFR(m_bOnePlayingSAADEnded);
            }
        }
        else
        {
            return BTFR(Assert(false));
        }
    }
    
    //---------------------------------------------------------------------------
    TFResult CheckOnePlayingSA()
    {
        if (m_ParticleSources.IsValidIndex(m_OnePlayingSAPSID))
        {
            ParticleSource p = m_ParticleSources[m_OnePlayingSAPSID];
            if (p)
            {
                if (p.IsParticlePlaying())
                {
                    return NTFR(TFR.PENDING);
                }
                else
                {
                    // Clean up the Particle, no leaking from tests!
                    GetGame().ObjectDelete(p);
                    // Make sure the particle ended, if it did, then success!
                    return BTFR(m_bOnePlayingSAEnded);
                }
            }
            else
            {
                // It should not be gone, no autodestroy
                return BTFR(Assert(false));
            }
        }
        else
        {
            return BTFR(Assert(false));
        }
    }
    
    //---------------------------------------------------------------------------
    TFResult CheckStop(float dt)
    {
        m_StopAccumulatedTime += dt;
        
        if (m_ParticleSources.IsValidIndex(m_StopPSID))
        {
            ParticleSource p = m_ParticleSources[m_StopPSID];
            if (p)
            {
                if (p.IsParticlePlaying())
                {
                    if (!m_bStopWasStopped && m_StopAccumulatedTime > STOP_ACCUMULATED_TIME_STOP_CUTOFF)
                    {
                        p.StopParticle();
                        m_StopAccumulatedTime = 0;
                        m_bStopWasStopped = true;
                    }
                    
                    return NTFR(TFR.PENDING);
                }
                else
                {
                    // Means it was stopped before it was supposed to
                    // Possibly because particle length is shorter than STOP_ACCUMULATED_TIME_CUTOFF
                    if (!Assert(m_bStopWasStopped))
                    {
                        return BTFR(false);
                    }
                    else if (!m_bStopWasResumed && m_StopAccumulatedTime > STOP_ACCUMULATED_TIME_PLAY_CUTOFF)
                    {
                        p.PlayParticle();
                        m_bStopWasResumed = true;                       
                    }
                    else if (m_bStopEnded)
                    {
                        // Clean up the Particle, no leaking from tests!
                        GetGame().ObjectDelete(p);
                        return BTFR(true);
                    }   
                    
                    return NTFR(TFR.PENDING);                       
                }
            }
            else
            {
                // It should not be gone, no autodestroy
                return BTFR(Assert(false));
            }
        }
        else
        {
            return BTFR(Assert(false));
        }
    }
    
    //---------------------------------------------------------------------------
    // Passes
    //---------------------------------------------------------------------------
    void PassOnePlaying(ParticleSource p)
    {
        m_bOnePlayingTestSuccess = true;
    }
    
    //---------------------------------------------------------------------------
    // Helpers
    //---------------------------------------------------------------------------
    void OnePlayingSAADEnded(ParticleSource p)
    {
        m_bOnePlayingSAADEnded = true;
    }
 
    //---------------------------------------------------------------------------
    void OnePlayingSAEnded(ParticleSource p)
    {
        m_bOnePlayingSAEnded = true;
    }
 
    //---------------------------------------------------------------------------
    void StopEnded(ParticleSource p)
    {
        m_bStopEnded = true;
    }
}