EventListeners = {
MoveLeftPressed = function(self)
self.Velocity.x = self.Velocity.x - 3.0
- --self.Velocity.y = self.Velocity.y - 1.0
- self.Render.flipx = true;
- game.dialogClear()
+ self.Render.flipx = true
end,
MoveLeftReleased = function(self)
self.Velocity.x = self.Velocity.x + 3.0
- --self.Velocity.y = self.Velocity.y + 1.0
end,
MoveRightPressed = function(self)
self.Velocity.x = self.Velocity.x + 3.0
- --self.Velocity.y = self.Velocity.y + 1.0
- self.Render.flipx = false;
+ self.Render.flipx = false
end,
MoveRightReleased = function(self)
self.Velocity.x = self.Velocity.x - 3.0
- --self.Velocity.y = self.Velocity.y - 1.0
end,
JumpKeyPressed = function(self)
if self.Physics.standing == true then
game.play(self.Position, self.Audio)
- --self.Velocity.y = self.Velocity.y + 9
end
end,
JumpKeyReleased = function(self)
- game.dialog(30, 150, 400, 100)
+ game.dialog(30, 50, 400, 100)
game.puts("dialog", 36, 52, "Hey. Hag?")
+ end,
+ MousePressed = function(self, mx, my)
+ if mx > 30 and mx < 430 and my > 50 and my < 150 then
+ game.dialogClear()
+ end
end
},
Position = {
- 15.0, 20.0
+ x = 15.0,
+ y = 20.0
},
Velocity = {
x = 0.0,
systems.add<GameRunSystem>();
systems.add<InputSystem>();
- systems.add<PlayerSystem>(entities);
+ systems.add<PlayerSystem>();
systems.add<WorldSystem>();
systems.add<RenderSystem>();
systems.add<ScriptSystem>(entities, *(systems.system<WorldSystem>().get()));
put("default", 0, 0, "fps: "s + std::to_string(fps));
entities.each<Player, Position>(
- [this](entityx::Entity, Player &p, Position &pos){
- (void)p;
+ [this](entityx::Entity, Player&, Position &pos){
std::string pr = "pos: " + std::to_string(pos.x)
+ "," + std::to_string(pos.y);
systems.system<TextSystem>()->put("default", 0, 24, pr);
--- /dev/null
+/**
+ * Copyright (C) 2022 Clyne Sullivan
+ *
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef EVENTS_INPUT_HPP_
+#define EVENTS_INPUT_HPP_
+
+#include <SDL2/SDL.h>
+
+/**
+ * @class KeyUpEvent
+ * Stores info regarding key releases.
+ */
+struct KeyUpEvent
+{
+ SDL_Keycode sym;
+ Uint16 mod;
+
+ explicit KeyUpEvent(const SDL_Keysym& keysym) :
+ sym(keysym.sym), mod(keysym.mod) {}
+};
+
+/**
+ * @class KeyDownEvent
+ * Stores info regarding key presses.
+ */
+struct KeyDownEvent {
+ SDL_Keycode sym;
+ Uint16 mod;
+
+ explicit KeyDownEvent(const SDL_Keysym& keysym) :
+ sym(keysym.sym), mod(keysym.mod) {}
+};
+
+struct MouseUpEvent {
+ Uint8 button;
+ Sint32 x;
+ Sint32 y;
+
+ explicit MouseUpEvent(const SDL_MouseButtonEvent& mbe) :
+ button(mbe.button), x(mbe.x), y(mbe.y) {}
+};
+
+struct MouseDownEvent {
+ Uint8 button;
+ Sint32 x;
+ Sint32 y;
+
+ explicit MouseDownEvent(const SDL_MouseButtonEvent& mbe) :
+ button(mbe.button), x(mbe.x), y(mbe.y) {}
+};
+
+#endif // EVENTS_INPUT_HPP_
+
#include <GL/glew.h>
+// TODO this is only for UI renders...
struct NewRenderEvent
{
GLuint vbo;
* @file input.cpp
* Handles user input received from SDL.
*
- * Copyright (C) 2020 Clyne Sullivan
+ * Copyright (C) 2022 Clyne Sullivan
*
* 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
* Prepares the system for running.
*/
void InputSystem::configure([[maybe_unused]] entityx::EntityManager& entities,
- [[maybe_unused]] entityx::EventManager& events) {}
+ [[maybe_unused]] entityx::EventManager& events)
+{
+ bindings.emplace(Binding {SDLK_a, 0}, "MoveLeft");
+ bindings.emplace(Binding {SDLK_d, 0}, "MoveRight");
+ bindings.emplace(Binding {SDLK_SPACE, 0}, "JumpKey");
+}
/**
* Updates the system by checking for SDL events.
*/
void InputSystem::update(entityx::EntityManager& entities,
entityx::EventManager& events,
- [[maybe_unused]] entityx::TimeDelta dt)
+ entityx::TimeDelta)
{
+ std::string listener;
+
for (SDL_Event event; SDL_PollEvent(&event);) {
- switch (event.type) {
- case SDL_KEYUP:
- if (auto key = event.key; key.repeat == 0)
- events.emit<KeyUpEvent>(key.keysym);
- break;
- case SDL_KEYDOWN:
- if (auto key = event.key; key.repeat == 0)
- events.emit<KeyDownEvent>(key.keysym);
- break;
- case SDL_MOUSEBUTTONDOWN:
+ std::function tryListener =
+ [&listener](entityx::Entity, EventListener& el, Scripted& s) {
+ el.tryListener(listener, s.caller);
+ };
+
+ if (event.type == SDL_KEYUP) {
+ if (event.key.repeat == 0) {
+ auto b = bindings.find({event.key.keysym.sym, event.key.keysym.mod});
+
+ if (b != bindings.end())
+ listener = b->second + "Released";
+ else
+ events.emit<KeyUpEvent>(event.key.keysym);
+ }
+ } else if (event.type == SDL_KEYDOWN) {
+ if (event.key.repeat == 0) {
+ auto b = bindings.find({event.key.keysym.sym, event.key.keysym.mod});
+
+ if (b != bindings.end())
+ listener = b->second + "Pressed";
+ else
+ events.emit<KeyDownEvent>(event.key.keysym);
+ }
+ } else if (event.type == SDL_MOUSEBUTTONDOWN) {
if (!isMouseDown) {
isMouseDown = true;
- entities.each<EventListener>(
- [&event](entityx::Entity e, EventListener& el) {
- el.tryListener("MousePressed",
- e.component<Scripted>()->caller,
- event.button.x,
- event.button.y,
- event.button.button);
- });
+ listener = "MousePressed";
+
+ tryListener =
+ [&listener, m = event.button]
+ (entityx::Entity, EventListener& el, Scripted& s) {
+ el.tryListener(listener, s.caller,
+ m.x, m.y, m.button);
+ };
}
- break;
- case SDL_MOUSEBUTTONUP:
+ } else if (event.type == SDL_MOUSEBUTTONUP) {
if (isMouseDown) {
isMouseDown = false;
- entities.each<EventListener>(
- [&event](entityx::Entity e, EventListener& el) {
- el.tryListener("MouseReleased",
- e.component<Scripted>()->caller,
- event.button.x,
- event.button.y,
- event.button.button);
- });
+ listener = "MouseReleased";
+
+ tryListener =
+ [&listener, m = event.button]
+ (entityx::Entity, EventListener& el, Scripted& s) {
+ el.tryListener(listener, s.caller,
+ m.x, m.y, m.button);
+ };
}
- break;
- default:
- break;
+ }
+
+ if (!listener.empty()) {
+ entities.each<EventListener, Scripted>(tryListener);
+ listener.clear();
}
}
}
* @file input.hpp
* Handles user input received from SDL.
*
- * Copyright (C) 2019 Clyne Sullivan
+ * Copyright (C) 2022 Clyne Sullivan
*
* 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
#ifndef SYSTEM_INPUT_HPP_
#define SYSTEM_INPUT_HPP_
-#include <entityx/entityx.h>
-#include <SDL2/SDL.h>
-
-/**
- * @class KeyUpEvent
- * Stores info regarding key releases.
- */
-struct KeyUpEvent
-{
- SDL_Keycode sym;
- Uint16 mod;
+#include "events/input.hpp"
- explicit KeyUpEvent(const SDL_Keysym& keysym) :
- sym(keysym.sym), mod(keysym.mod) {}
-};
-
-/**
- * @class KeyDownEvent
- * Stores info regarding key presses.
- */
-struct KeyDownEvent {
- SDL_Keycode sym;
- Uint16 mod;
-
- explicit KeyDownEvent(const SDL_Keysym& keysym) :
- sym(keysym.sym), mod(keysym.mod) {}
-};
-
-struct MouseUpEvent {
- Uint8 button;
- Sint32 x;
- Sint32 y;
-
- explicit MouseUpEvent(const SDL_MouseButtonEvent& mbe) :
- button(mbe.button), x(mbe.x), y(mbe.y) {}
-};
-
-struct MouseDownEvent {
- Uint8 button;
- Sint32 x;
- Sint32 y;
+#include <entityx/entityx.h>
- explicit MouseDownEvent(const SDL_MouseButtonEvent& mbe) :
- button(mbe.button), x(mbe.x), y(mbe.y) {}
-};
+#include <map>
/**
* @class InputSystem
entityx::TimeDelta dt) final;
private:
+ // TODO add 'mod' to comparison check
+ // TODO allow binding configuration
+ struct Binding {
+ SDL_Keycode sym = 0;
+ Uint16 mod = 0;
+
+ auto operator<=>(const Binding& other) const {
+ return sym <=> other.sym;
+ }
+ };
+
+ std::map<Binding, std::string> bindings;
bool isMouseDown;
};
* @file player.cpp
* Manages player input.
*
- * Copyright (C) 2019 Clyne Sullivan
+ * Copyright (C) 2022 Clyne Sullivan
*
* 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
#include "components/Script.hpp"
#include "components/Velocity.hpp"
-void PlayerSystem::configure([[maybe_unused]] entityx::EntityManager& entities,
+void PlayerSystem::configure(entityx::EntityManager&,
entityx::EventManager& events)
{
events.subscribe<entityx::ComponentAddedEvent<Player>>(*this);
events.subscribe<entityx::ComponentRemovedEvent<Player>>(*this);
- events.subscribe<KeyUpEvent>(*this);
- events.subscribe<KeyDownEvent>(*this);
}
-void PlayerSystem::update([[maybe_unused]] entityx::EntityManager& entites,
- [[maybe_unused]] entityx::EventManager& events,
- [[maybe_unused]] entityx::TimeDelta dt)
+void PlayerSystem::update(entityx::EntityManager&,
+ entityx::EventManager&,
+ entityx::TimeDelta)
{
}
player.invalidate();
}
-void PlayerSystem::receive(const KeyDownEvent& kue)
-{
- if (player.valid()) {
- if (kue.sym == SDLK_a) {
- entities.each<EventListener>(
- [](entityx::Entity e, EventListener& el) {
- el.tryListener("MoveLeftPressed",
- e.component<Scripted>()->caller);
- });
- } else if (kue.sym == SDLK_d) {
- entities.each<EventListener>(
- [](entityx::Entity e, EventListener& el) {
- el.tryListener("MoveRightPressed",
- e.component<Scripted>()->caller);
- });
- } else if (kue.sym == SDLK_SPACE) {
- entities.each<EventListener>(
- [](entityx::Entity e, EventListener& el) {
- el.tryListener("JumpKeyPressed",
- e.component<Scripted>()->caller);
- });
- }
- }
-}
-
-void PlayerSystem::receive(const KeyUpEvent& kue)
-{
- if (player.valid()) {
- if (kue.sym == SDLK_a) {
- entities.each<EventListener>(
- [](entityx::Entity e, EventListener& el) {
- el.tryListener("MoveLeftReleased",
- e.component<Scripted>()->caller);
- });
- } else if (kue.sym == SDLK_d) {
- entities.each<EventListener>(
- [](entityx::Entity e, EventListener& el) {
- el.tryListener("MoveRightReleased",
- e.component<Scripted>()->caller);
- });
- } else if (kue.sym == SDLK_SPACE) {
- entities.each<EventListener>(
- [](entityx::Entity e, EventListener& el) {
- el.tryListener("JumpKeyReleased",
- e.component<Scripted>()->caller);
- });
- }
- }
-}
-
* @file player.hpp
* Manages player input.
*
- * Copyright (C) 2019 Clyne Sullivan
+ * Copyright (C) 2022 Clyne Sullivan
*
* 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
/**
* @class PlayerSystem
* Controls player entity movement.
+ * TODO is this system necessary?
*/
class PlayerSystem : public entityx::System<PlayerSystem>,
public entityx::Receiver<PlayerSystem>
{
private:
- /**
- * Defines player's horizontal movement velocity.
- */
- constexpr static double GROUND_VELOCITY = 100;
-
- entityx::EntityManager& entities;
entityx::Entity player;
public:
- PlayerSystem(entityx::EntityManager& _entities) :
- entities(_entities) {}
-
/**
* Prepares the system for running.
*/
* Invalidates the system's player entity (assume player is gone).
*/
void receive(const entityx::ComponentRemovedEvent<Player>& cre);
-
- /**
- * Applies velocity based on key press.
- */
- void receive(const KeyDownEvent& kue);
-
- /**
- * Removes applied velocity
- */
- void receive(const KeyUpEvent& kue);
};
#endif // SYSTEM_PLAYER_HPP_
+/**
+ * @file ui.cpp
+ *
+ * Copyright (C) 2022 Clyne Sullivan
+ *
+ * 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/>.
+ */
+
#include "ui.hpp"
#include "text.hpp"
void UISystem::createDialogBox(float x, float y, float w, float h)
{
// Queue for generation in the main thread.
- m_boxes.emplace_back(0, x, -y, w, h);
+ // TODO Should y inversion be hidden in the render system?
+ m_boxes.emplace_back(0, x, -y - h, w, h);
}
void UISystem::update(entityx::EntityManager&,
/**
* @file ui.hpp
*
- *
* Copyright (C) 2022 Clyne Sullivan
*
* This program is free software: you can redistribute it and/or modify
projects / clyne / gamedev2.git / commitdiff