void Game::setupSpaces()
{
//Set up gameplay space
this->gameplay = new Space("GAMEPLAY", *this->inputHandler);
this->gameplay->entityManager = EntityManager();
TransformSystem* gameplayTransformSystem = new TransformSystem();
StateSystem* gameplayStateSystem = new StateSystem();
PlayerInputSystem* gameplayPIS = new PlayerInputSystem();
MovementSystem* gameplayMovementSystem = new MovementSystem(gameplayTransformSystem);
PickupSystem* gameplayPickupSystem = new PickupSystem(gameplayTransformSystem, gameplayMovementSystem);
RenderSystem* gameplayRenderSystem = new RenderSystem(this->graphics, gameplayTransformSystem, gameplayStateSystem);
PlayerControlSystem* gameplayPCS = new PlayerControlSystem(
this->inputHandler,
gameplayTransformSystem,
gameplayMovementSystem,
gameplayStateSystem,
gameplayPIS,
gameplayPickupSystem
);
CollisionSystem* gameplayCollisionSystem = new CollisionSystem(gameplayTransformSystem, gameplayMovementSystem, gameplayPCS);
gameplay->addSystem(gameplayTransformSystem);
gameplay->addSystem(gameplayStateSystem);
gameplay->addSystem(gameplayPIS);
gameplay->addSystem(gameplayPCS);
gameplay->addSystem(gameplayCollisionSystem);
gameplay->addSystem(gameplayPickupSystem);
gameplay->addSystem(gameplayMovementSystem);
gameplay->renderSystem = gameplayRenderSystem;
this->gameplay->entityFactory = EntityFactory(
&this->gameplay->entityManager,
this->inputHandler,
gameplayCollisionSystem,
gameplayMovementSystem,
gameplayPCS,
gameplayPIS,
gameplayRenderSystem,
gameplayStateSystem,
gameplayTransformSystem
);
gameplayPCS->entityFactory = &this->gameplay->entityFactory;
gameplayPickupSystem->collisionSystem = gameplayCollisionSystem;
//Set up menu
/*
this->mainmenu = new Space("MAINMENU", *this->inputHandler);
this->mainmenu->entityManager = EntityManager();
this->mainmenu->entityFactory = EntityFactory(
&this->mainmenu->entityManager,
this->inputHandler
);
TransformSystem menuTransformSystem = new TransformSystem();
mainmenu->addSystem(menuTransformSystem);
mainmenu->renderSystem = new RenderSystem(this->graphics, *menuTransformSystem);*/
}
//-----------------------------------------------------------------------------
// Expose IEntityFactory.
//-----------------------------------------------------------------------------
void export_entity_factory(scope _factories)
{
class_<IEntityFactory, boost::noncopyable> EntityFactory("EntityFactory", no_init);
// Methods...
EntityFactory.def("create",
&IEntityFactory::Create,
reference_existing_object_policy()
);
EntityFactory.def("destroy", &IEntityFactory::Destroy);
// Properties...
EntityFactory.add_property("size", &IEntityFactory::GetEntitySize);
// Add memory tools...
EntityFactory ADD_MEM_TOOLS(IEntityFactory);
}
ArmyEngine::ArmyEngine() :
window(sf::RenderWindow(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), WINDOW_TITLE)),
componentFactory(ComponentFactory()),
entityFactory(EntityFactory()) {
//removing the cursor
this->window.setMouseCursorVisible(false);
//First, assign the window to all of the required entities that have dependance on it.
// event manager needs the window to get the events
auto eventManager = EventManager::getInstance();
eventManager->setWindow(&(this->window));
// assign stateSystem
this->stateSystem = std::shared_ptr<StateSystem>(new StateSystem());
//assign and create our eventSystem
this->eventSystem = std::shared_ptr<EventSystem>(new EventSystem());
// spriteSystem needs the window to draw
auto spriteSystem = std::shared_ptr<systemType> (new SpriteSystem(window));
//Assign the systems to our system manager
auto systemManager = SystemManager::getInstance();
systemManager->addSystem(std::static_pointer_cast<systemType> (this->eventSystem));
systemManager->addSystem(spriteSystem);
systemManager->addSystem(std::shared_ptr<systemType>(new InputSystem()));
systemManager->addSystem(std::shared_ptr<systemType> (new CollisionSystem()));
systemManager->addSystem(std::static_pointer_cast<systemType> (this->stateSystem));
//default event handling
//by default, closing will end the program
this->addEventCallback(EnumEventType::EVENT_CLOSED,
[&] (int ID) {
window.close();
return 0;
});
}
void System::ShootingSystem::update(int elapsedMs, World &world, Room &room)
{
for(auto entity : world.getEntitiesForType(ComponentTypes::CANSHOOT))
{
CanShoot *c = (CanShoot *) entity->getComponent(ComponentTypes::CANSHOOT);
Ammo *ammo = (Ammo *) entity->getComponent(ComponentTypes::AMMO);
if(ammo == nullptr) {
continue;
}
if(ammo->ammo == 0) {
continue;
}
if(world.wasKeyPressed(SDLK_SPACE))
{
//TODO: Invert this if.
if(c->currentMs == 0 || c->currentMs >= c->msBetweenShots) {
ammo->ammo--;
c->currentMs = 0;
EntityFactory factory = EntityFactory();
Position *initialPosition = new Position();
Position *p = (Position *)entity->getComponent(ComponentTypes::POSITION);
initialPosition->x = p->x;
initialPosition->y = p->y;
Entity *bullet = factory.createBullet(initialPosition, getInitialVelocity(entity));
world.addEntity(bullet);
engine->getSoundEngine()->playSound("Shoot.wav", 1);
}
c->currentMs += elapsedMs;
}
}
}
//-----------------------------------------------------------------------
Root::Root(const String& pluginFileName, const String& configFileName,
const String& logFileName)
: mLogManager(0)
, mRenderSystemCapabilitiesManager(0)
, mNextFrame(0)
, mFrameSmoothingTime(0.0f)
, mNextMovableObjectTypeFlag(1)
, mIsInitialised(false)
{
// superclass will do singleton checking
String msg;
// Init
mActiveRenderer = 0;
mVersion = StringConverter::toString(OGRE_VERSION_MAJOR) + "." +
StringConverter::toString(OGRE_VERSION_MINOR) + "." +
StringConverter::toString(OGRE_VERSION_PATCH) +
OGRE_VERSION_SUFFIX + " " +
"(" + OGRE_VERSION_NAME + ")";
mConfigFileName = configFileName;
// Create log manager and default log file if there is no log manager yet
if(LogManager::getSingletonPtr() == 0)
{
mLogManager = OGRE_NEW LogManager();
mLogManager->createLog(logFileName, true, true);
}
// Dynamic library manager
mDynLibManager = OGRE_NEW DynLibManager();
mArchiveManager = OGRE_NEW ArchiveManager();
// ResourceGroupManager
mResourceGroupManager = OGRE_NEW ResourceGroupManager();
// ResourceBackgroundQueue
mResourceBackgroundQueue = OGRE_NEW ResourceBackgroundQueue();
// Create SceneManager enumerator (note - will be managed by singleton)
mSceneManagerEnum = OGRE_NEW SceneManagerEnumerator();
mCurrentSceneManager = NULL;
mShadowTextureManager = OGRE_NEW ShadowTextureManager();
mRenderSystemCapabilitiesManager = OGRE_NEW RenderSystemCapabilitiesManager();
// ..material manager
mMaterialManager = OGRE_NEW MaterialManager();
// Mesh manager
mMeshManager = OGRE_NEW MeshManager();
// Skeleton manager
mSkeletonManager = OGRE_NEW SkeletonManager();
// ..particle system manager
mParticleManager = OGRE_NEW ParticleSystemManager();
// Compiler manager
//mCompilerManager = OGRE_NEW ScriptCompilerManager();
mTimer = OGRE_NEW Timer();
// Overlay manager
mOverlayManager = OGRE_NEW OverlayManager();
mPanelFactory = OGRE_NEW PanelOverlayElementFactory();
mOverlayManager->addOverlayElementFactory(mPanelFactory);
mBorderPanelFactory = OGRE_NEW BorderPanelOverlayElementFactory();
mOverlayManager->addOverlayElementFactory(mBorderPanelFactory);
mTextAreaFactory = OGRE_NEW TextAreaOverlayElementFactory();
mOverlayManager->addOverlayElementFactory(mTextAreaFactory);
// Font manager
mFontManager = OGRE_NEW FontManager();
#if OGRE_PROFILING
// Profiler
mProfiler = OGRE_NEW Profiler();
Profiler::getSingleton().setTimer(mTimer);
#endif
mFileSystemArchiveFactory = OGRE_NEW FileSystemArchiveFactory();
ArchiveManager::getSingleton().addArchiveFactory( mFileSystemArchiveFactory );
mZipArchiveFactory = OGRE_NEW ZipArchiveFactory();
ArchiveManager::getSingleton().addArchiveFactory( mZipArchiveFactory );
#if OGRE_NO_FREEIMAGE == 0
// Register image codecs
FreeImageCodec::startup();
#endif
#if OGRE_NO_DEVIL == 0
// Register image codecs
ILCodecs::registerCodecs();
#endif
#if OGRE_NO_DDS_CODEC == 0
// Register image codecs
DDSCodec::startup();
#endif
mHighLevelGpuProgramManager = OGRE_NEW HighLevelGpuProgramManager();
mExternalTextureSourceManager = OGRE_NEW ExternalTextureSourceManager();
mCompositorManager = OGRE_NEW CompositorManager();
mCompilerManager = OGRE_NEW ScriptCompilerManager();
// Auto window
mAutoWindow = 0;
// instantiate and register base movable factories
mEntityFactory = OGRE_NEW EntityFactory();
addMovableObjectFactory(mEntityFactory);
mLightFactory = OGRE_NEW LightFactory();
addMovableObjectFactory(mLightFactory);
mBillboardSetFactory = OGRE_NEW BillboardSetFactory();
addMovableObjectFactory(mBillboardSetFactory);
mManualObjectFactory = OGRE_NEW ManualObjectFactory();
addMovableObjectFactory(mManualObjectFactory);
mBillboardChainFactory = OGRE_NEW BillboardChainFactory();
addMovableObjectFactory(mBillboardChainFactory);
mRibbonTrailFactory = OGRE_NEW RibbonTrailFactory();
addMovableObjectFactory(mRibbonTrailFactory);
// Load plugins
if (!pluginFileName.empty())
loadPlugins(pluginFileName);
LogManager::getSingleton().logMessage("*-*-* OGRE Initialising");
msg = "*-*-* Version " + mVersion;
LogManager::getSingleton().logMessage(msg);
// Can't create managers until initialised
mControllerManager = 0;
mFirstTimePostWindowInit = false;
}
