3
-Slow
-0
-canJump
-1
canSprint
1
+canJump
+1
+Slow
+0
#include <events.hpp>
+class Engine : public entityx::Receiver<Engine> {
+private:
+ bool gameRunning;
+
+public:
+ entityx::SystemManager systems;
+
+ explicit Engine(void);
+
+ void init(void);
+ void render(entityx::TimeDelta dt);
+ void update(entityx::TimeDelta dt);
+
+ template<typename T>
+ inline T* getSystem(void) {
+ return dynamic_cast<T*>(systems.system<T>().get());
+ }
+
+ /*void configure(entityx::EventManager &ev) {
+ (void)ev;
+ }*/
+
+ inline void receive(const GameEndEvent &gee) {
+ gameRunning = !(gee.really);
+ }
+
+ inline bool shouldRun(void) const {
+ return gameRunning;
+ }
+};
+
+
namespace game {
extern entityx::EventManager events;
extern entityx::EntityManager entities;
+ extern Engine engine;
+
inline void endGame(void) {
events.emit<GameEndEvent>();
}
}
+
+
#endif // ENGINE_HPP_
#include <SDL2/SDL.h>
- struct MouseScrollEvent {
+#include <string>
+
+struct MouseScrollEvent {
MouseScrollEvent(int sd = 0)
: scrollDistance(sd) {}
bool really;
};
+struct BGMToggleEvent {
+ BGMToggleEvent(std::string f)
+ : file(f) {}
+
+ std::string file;
+}
+
#endif // EVENTS_HPP_
* This pair contains a pointer to the new world, and the new set of
* coordinates the player should be at in that world.
*/
-typedef std::pair<World *, vec2> WorldSwitchInfo;
+using WorldSwitchInfo = std::pair<World *, vec2>;
/**
* Alters how bright world elements are drawn.
~Village(void){}
};
+
+#include <entityx/entityx.h>
+
+constexpr const char* WorldWeatherString[3] = {
+ "None",
+ "Rainy",
+ "Snowy"
+};
+
+class WorldSystem : public entityx::System<WorldSystem>, public entityx::Receiver<WorldSystem> {
+private:
+ WorldWeather weather;
+
+ Mix_Music *bgmObj;
+
+public:
+ explicit WorldSystem(void);
+
+ void configure(entityx::EventManager &ev) {
+ ev.subscribe<BGMToggleEvent>(*this);
+ }
+
+ void receive(const BGMToggleEvent &bte);
+
+ void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+
+ inline const std::string getWeatherStr(void) const
+ { return WorldWeatherString[static_cast<int>(weather)]; }
+
+ inline const WorldWeather& getWeatherId(void) const
+ { return weather; }
+
+ void setWeather(const std::string &s);
+};
+
+
/**
* The world class.
* This class handles entity creation, management, and deletion. Most
* drawing.
*/
class World {
-friend class ItemLight;
+//friend class ItemLight;
protected:
/**
* An array of all the world's ground data, populated through
* World::generate().
- *
* @see generate()
*/
std::vector<WorldData> worldData;
- /**
- * Contains the current state of weather in the world.
- */
- WorldWeather weather;
-
/**
* Contains the size of the 'worldData' array.
*/
*/
WorldBGType bgType;
- /**
- * SDL_Mixer's object for the loaded BGM.
- */
- Mix_Music *bgmObj;
-
/**
* The filename of the world's BGM file.
*
** MAIN ************************************************************************
********************************************************************************/
-namespace game {
- entityx::EventManager events;
- entityx::EntityManager entities (events);
-}
-
-class Engine : public entityx::Receiver<Engine> {
-private:
- bool gameRunning;
-
-public:
- entityx::SystemManager systems;
-
- explicit Engine(void)
- : gameRunning(true), systems(game::entities, game::events) {}
-
- void init(void) {
- game::config::read();
- game::events.subscribe<GameEndEvent>(*this);
-
- systems.add<WindowSystem>();
- systems.add<InputSystem>();
- systems.add<InventorySystem>();
- systems.add<PlayerSystem>(&player);
-
- systems.configure();
- }
-
- void render(entityx::TimeDelta dt) {
- systems.update<WindowSystem>(dt);
- }
-
- void update(entityx::TimeDelta dt) {
- systems.update<InputSystem>(dt);
- systems.update<InventorySystem>(dt);
- systems.update<PlayerSystem>(dt);
-
- currentWorld->update(player, dt);
- currentWorld->detect(player);
- }
-
- void configure(entityx::EventManager &ev) {
- (void)ev;
- }
-
- void receive(const GameEndEvent &gee) {
- gameRunning = !(gee.really);
- }
-
- inline bool shouldRun(void) const {
- return gameRunning;
- }
-};
-
-Engine engine;
-
int main(int argc, char *argv[])
{
static bool worldReset = false, worldDontReallyRun = false;
}
}
- engine.init();
+ game::engine.init();
// initialize GLEW
#ifndef __WIN32__
// the main loop, in all of its gloriousness..
std::thread([&]{
- while (engine.shouldRun()) {
+ while (game::engine.shouldRun()) {
mainLoop();
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
// the debug loop, gets debug screen values
std::thread([&]{
- while (engine.shouldRun()) {
+ while (game::engine.shouldRun()) {
fps = 1000 / game::time::getDeltaTime();
debugY = player->loc.y;
}
}).detach();
- while (engine.shouldRun()) {
- engine.render(0);
+ while (game::engine.shouldRun()) {
+ game::engine.render(0);
render();
}
if (game::time::tickHasPassed())
logic();
- engine.update(game::time::getDeltaTime());
+ game::engine.update(game::time::getDeltaTime());
}
}
debugY, // The player's y coordinate
game::time::getTickCount(),
game::config::VOLUME_MASTER,
- currentWorld->getWeatherStr().c_str(),
+ game::engine.getSystem<WorldSystem>()->getWeatherStr().c_str(),
currentXML.c_str()
);
ui::fadeUpdate();
// create weather particles if necessary
- auto weather = currentWorld->getWeatherId();
+ auto weather = game::engine.getSystem<WorldSystem>()->getWeatherId();
if (weather == WorldWeather::Rain) {
for (unsigned int r = (randGet() % 25) + 11; r--;) {
currentWorld->addParticle(randGet() % currentWorld->getTheWidth() - (currentWorld->getTheWidth() / 2),
--- /dev/null
+#include <engine.hpp>
+
+#include <config.hpp>
+#include <world.hpp>
+#include <ui.hpp>
+#include <inventory.hpp>
+#include <entities.hpp>
+#include <window.hpp>
+
+extern World *currentWorld;
+
+Engine::Engine(void)
+ : gameRunning(true), systems(game::entities, game::events)
+{
+}
+
+void Engine::init(void) {
+ game::config::read();
+ game::events.subscribe<GameEndEvent>(*this);
+
+ systems.add<WindowSystem>();
+ systems.add<InputSystem>();
+ systems.add<InventorySystem>();
+ systems.add<WorldSystem>();
+ systems.add<PlayerSystem>(&player);
+
+ systems.configure();
+}
+
+void Engine::render(entityx::TimeDelta dt)
+{
+ systems.update<WindowSystem>(dt);
+}
+
+void Engine::update(entityx::TimeDelta dt)
+{
+ systems.update<InputSystem>(dt);
+ systems.update<InventorySystem>(dt);
+ systems.update<PlayerSystem>(dt);
+
+ currentWorld->update(player, dt);
+ currentWorld->detect(player);
+}
+
+
+namespace game {
+ entityx::EventManager events;
+ entityx::EntityManager entities (events);
+
+ Engine engine;
+}
#include <gametime.hpp>
#include <render.hpp>
+#include <engine.hpp>
// local library headers
#include <tinyxml2.h>
extern bool inBattle; // ui.cpp?
extern std::string xmlFolder;
-static const std::array<std::string, 3> WorldWeatherString {
- "None",
- "Rainy",
- "Snowy"
-};
-
// particle mutex
std::mutex partMutex;
s.x = (randGet() % (static_cast<int>(-worldStart) * 2)) + worldStart;
s.y = (randGet() % game::SCREEN_HEIGHT) + 100;
}
-
- weather = WorldWeather::None;
}
static Color ambient;
// used for alpha values of background textures
int alpha;
+ switch (game::engine.getSystem<WorldSystem>()->getWeatherId()) {
+ case WorldWeather::Snowy:
+ alpha = 150;
+ break;
+ case WorldWeather::Rain:
+ alpha = 0;
+ break;
+ default:
+ alpha = 255 - worldShade * 4;
+ break;
+ }
+
// shade value for GLSL
float shadeAmbient = std::max(0.0f, static_cast<float>(-worldShade) / 50 + 0.5f); // 0 to 1.5f
if (shadeAmbient > 0.9f)
shadeAmbient = 1;
- // the sunny wallpaper is faded with the night depending on tickCount
- switch (weather) {
- case WorldWeather::Snowy:
- alpha = 150;
- break;
- case WorldWeather::Rain:
- alpha = 0;
- break;
- default:
- alpha = 255 - worldShade * 4;
- break;
- }
-
glActiveTexture(GL_TEXTURE0);
glUniform1i(Render::worldShader.uniform[WU_texture], 0);
bgFilesIndoors.push_back(prefix + s);
}
-/**
- * Pretty self-explanatory.
- */
-std::string World::getWeatherStr(void) const
-{
- return WorldWeatherString[static_cast<int>(weather)];
-}
-
-const WorldWeather& World::getWeatherId(void) const
-{
- return weather;
-}
-
-void World::setWeather(const std::string &s)
-{
- for (unsigned int i = WorldWeatherString.size(); i--;) {
- if (WorldWeatherString[i] == s) {
- weather = static_cast<WorldWeather>(i);
- return;
- }
- }
- weather = WorldWeather::None;
-}
-
/**
* Pretty self-explanatory.
*/
// weather tags
else if (name == "weather") {
- tmp->setWeather(wxml->GetText());
+ game::engine.getSystem<WorldSystem>()->setWeather(wxml->GetText());
}
// set spawn x for player
}
Village::Village(std::string meme, World *w)
+ : name(meme)
{
- name = meme;
start.x = w->getTheWidth() / 2.0f;
end.x = -start.x;
in = false;
}
+
+
+
+WorldSystem::WorldSystem(void)
+ : weather(WorldWeather::None) {}
+
+void WorldSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+ (void)en;
+ (void)ev;
+ (void)dt;
+}
+
+void WorldSystem::receive(const BGMToggleEvent &bte)
+{
+
+}
+
+void WorldSystem::setWeather(const std::string &s)
+{
+ for (unsigned int i = 3; i--;) {
+ if (WorldWeatherString[i] == s) {
+ weather = static_cast<WorldWeather>(i);
+ return;
+ }
+ }
+
+ weather = WorldWeather::None;
+}
<generation type="Random" width="1600"/>
<time>6000</time>
<spawnx>-300</spawnx>
- <npc name="Sanc" hasDialog="true" health="1" x="735" y="66.199104" dindex="9999"/>
- <npc name="Bob" hasDialog="true" spawnx="30" health="1" x="460.8461" y="67.399094" dindex="0"/>
+ <npc name="Sanc" hasDialog="true" health="1" x="713.36627" y="62.598007" dindex="9999"/>
+ <npc name="Bob" hasDialog="true" spawnx="30" health="1" x="102.43407" y="65.999008" dindex="0"/>
<structure type="1" spawnx="300" alive="1"/>
<structure inside="bobshouse.xml" type="1" spawnx="10" alive="1"/>
<chest alive="1"/>
projects / clyne / gamedev.git / commitdiff