enginehost.h

Go to the documentation of this file.

/*
 * Copyright (c) since 2021 by PopolonY2k and Leidson Campos A. Ferreira
 * 
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef __ENGINEHOST_H__
#define __ENGINEHOST_H__
 
#include <string>
#include <array>
#include <functional>
#include <cstdint>
#include "tilemap/itilemaplistener.h"
#include "drawsurface/idrawsurface.h"
#include "scripting/scriptprocessor.h"
#include "sound/soundmanager.h"
#include "lua/luaengine.h"
#include "engine/spritepool.h"
#include "host/rendererprovider.h"
 
 
/*
 * Module definition
 */
#define MAX_STATE_HANDLERS             255
 
 
namespace Scarab  {
    namespace Host  {
        class EngineHost : public SunLight :: TileMap :: ITileMapListener,
                            public SunLight :: Scripting :: IScriptListener  {
 
            typedef std :: function<void( void )> FUNCTION_STATE_HANDLER;
            typedef std :: array<FUNCTION_STATE_HANDLER, MAX_STATE_HANDLERS> FunctionStateHandlers;
 
            uint16_t                                   m_CurrentSong;
            uint64_t                                   m_nClearInactiveSpriteQueueMilli;
            FUNCTION_STATE_HANDLER                     m_CurrentStateHandler;
            SunLight :: Scripting :: ScriptProcessor   m_ScriptProcessorMachine;
            SunLight :: Sound :: SoundManager          m_SoundManager;
            Scarab :: Lua :: LuaEngine                 m_LuaEngine;
            Engine :: SpritePool                       m_SpritePool;
 
            std :: string                              m_strEntryArg;
            std :: string                              m_strEntryOverride;
            std :: string                              m_strLastError;
            bool                                       m_bEntryScriptDone;
            FunctionStateHandlers                      m_aEngineStateHandlers;
 
            // Queue management update handlers
            void CheckSpritesQueueEmpty( void );
 
            // Script processing routines
            void RunScriptMachine( void );
 
            // Sound support
            bool PlaySound( uint16_t id, bool bIgnorePlaying = false );
            bool PauseSound( uint16_t id );
            bool StopSound( uint16_t id );
            bool ResumeSound( uint16_t id );
 
            // Script management routines
            bool LoadLuaScript( std :: string strFileName );
            bool RunLuaScriptMainEntryPoint( void );
            bool ResolveEntryScript( const std :: string& strEntryArg, std :: string& strOutScriptPath );
 
            // Machine state handlers
            void FatalErrorHandler( void );
            void InitEngineStateHandler( void );
            void RunStageStateHandler( void );
 
            public:
 
            EngineHost( Scarab :: Host :: RendererProvider *pRendererProvider,
                       std :: string strEntryArg,
                       std :: string strEntryOverride = std :: string() );
            virtual ~EngineHost( void );
 
            // Runs the entry script - before the window exists, see the definition
            void RunEntryScript( void );
 
            // Headless (--headless) only - see LuaAppApi::InstallVirtualClock
            void UseVirtualTime( void );
 
            // World listener event handler implementation
            void OnUpdate( SunLight :: TileMap :: ITileMap& tileMap );
            void OnStop( void );
 
            void OnCommand( SunLight :: Scripting :: Commands cmd, uint16_t nEventId );
            void OnError( std :: string strError );
        };
    }
}
 
#endif /* __ENGINEHOST_H__ */