Merge remote-tracking branch 'origin/master' into Menu
# Conflicts: # src/Engine/Rendering/Texture.cpp # src/Game/Game.cpp
This commit is contained in:
Tleety
@@ -1,6 +1,6 @@
|
||||
project(TacticalZ-Game)
|
||||
|
||||
find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono)
|
||||
find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono program_options)
|
||||
|
||||
set(INCLUDE_PATH ${CMAKE_SOURCE_DIR}/include/Game)
|
||||
include_directories(
|
||||
@@ -22,13 +22,17 @@ file(GLOB SOURCE_FILES_Events
|
||||
)
|
||||
source_group(Events FILES ${SOURCE_FILES_Events})
|
||||
|
||||
file(GLOB SOURCE_FILES_Network
|
||||
"${INCLUDE_PATH}/Network/*.h"
|
||||
"Network/*.cpp"
|
||||
)
|
||||
source_group(Network FILES ${SOURCE_FILES_Network})
|
||||
set(SOURCE_FILES
|
||||
${SOURCE_FILES}
|
||||
"Game.cpp"
|
||||
${SOURCE_FILES_Systems}
|
||||
${SOURCE_FILES_Events}
|
||||
|
||||
|
||||
${SOURCE_FILES_Network}
|
||||
)
|
||||
|
||||
set(LIBRARIES
|
||||
|
||||
+66
-33
@@ -16,13 +16,17 @@
|
||||
#include "Game/Systems/PickupSpawnSystem.h"
|
||||
#include "Game/Systems/WeaponSystem.h"
|
||||
#include "Rendering/AnimationSystem.h"
|
||||
#include "Game/Systems/PlayerHUDSystem.h"
|
||||
#include "Rendering/BoneAttachmentSystem.h"
|
||||
#include "Game/Systems/PlayerHUD.h"
|
||||
#include "Game/Systems/LifetimeSystem.h"
|
||||
#include "../Engine/Core/UniformScaleSystem.h"
|
||||
#include "Rendering/AnimationSystem.h"
|
||||
#include "Network/MultiplayerSnapshotFilter.h"
|
||||
|
||||
Game::Game(int argc, char* argv[])
|
||||
{
|
||||
parseArgs(argc, argv);
|
||||
|
||||
ResourceManager::RegisterType<ConfigFile>("ConfigFile");
|
||||
ResourceManager::RegisterType<Sound>("Sound");
|
||||
ResourceManager::RegisterType<Model>("Model");
|
||||
@@ -81,6 +85,18 @@ Game::Game(int argc, char* argv[])
|
||||
// Create the sound manager
|
||||
m_SoundManager = new SoundManager(m_World, m_EventBroker);
|
||||
|
||||
// Initialize network
|
||||
if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
|
||||
if (m_IsServer) {
|
||||
m_NetworkServer = new Server(m_World, m_EventBroker, m_NetworkPort);
|
||||
m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " SERVER");
|
||||
} else if (m_IsClient) {
|
||||
m_NetworkClient = new Client(m_World, m_EventBroker, std::make_unique<MultiplayerSnapshotFilter>(m_EventBroker));
|
||||
m_NetworkClient->Connect(m_NetworkAddress, m_NetworkPort);
|
||||
m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " CLIENT");
|
||||
}
|
||||
}
|
||||
|
||||
// Create Octrees
|
||||
// TODO: Perhaps the world bounds should be set in some non-arbitrary way instead of this.
|
||||
AABB boxContainingTheWorld(glm::vec3(-300), glm::vec3(300));
|
||||
@@ -88,20 +104,21 @@ Game::Game(int argc, char* argv[])
|
||||
m_OctreeTrigger = new Octree<EntityAABB>(boxContainingTheWorld, 4);
|
||||
m_OctreeFrustrumCulling = new Octree<EntityAABB>(boxContainingTheWorld, 4);
|
||||
// Create system pipeline
|
||||
m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker);
|
||||
m_SystemPipeline = new SystemPipeline(m_World, m_EventBroker, m_IsClient, m_IsServer);
|
||||
|
||||
// All systems with orderlevel 0 will be updated first.
|
||||
unsigned int updateOrderLevel = 0;
|
||||
m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
|
||||
++updateOrderLevel;
|
||||
m_SystemPipeline->AddSystem<SoundSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<RaptorCopterSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<ExplosionEffectSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<HealthSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<PlayerDeathSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer);
|
||||
m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer, m_OctreeCollision);
|
||||
m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<CapturePointHUDSystem>(updateOrderLevel);
|
||||
@@ -111,9 +128,9 @@ Game::Game(int argc, char* argv[])
|
||||
m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
|
||||
m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
|
||||
m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
|
||||
m_SystemPipeline->AddSystem<PlayerHUD>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
|
||||
m_SystemPipeline->AddSystem<PlayerHUDSystem>(updateOrderLevel);
|
||||
// Collision and TriggerSystem should update after player.
|
||||
++updateOrderLevel;
|
||||
m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
|
||||
@@ -124,12 +141,6 @@ Game::Game(int argc, char* argv[])
|
||||
++updateOrderLevel;
|
||||
m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
|
||||
|
||||
// Invoke network
|
||||
if (m_Config->Get<bool>("Networking.StartNetwork", false)) {
|
||||
//boost::thread workerThread(&Game::networkFunction, this);
|
||||
networkFunction();
|
||||
}
|
||||
|
||||
m_LastTime = glfwGetTime();
|
||||
}
|
||||
|
||||
@@ -140,6 +151,12 @@ Game::~Game()
|
||||
delete m_OctreeCollision;
|
||||
delete m_OctreeTrigger;
|
||||
delete m_SoundManager;
|
||||
if (m_NetworkClient != nullptr) {
|
||||
delete m_NetworkClient;
|
||||
}
|
||||
if (m_NetworkServer != nullptr) {
|
||||
delete m_NetworkServer;
|
||||
}
|
||||
delete m_World;
|
||||
delete m_FrameStack;
|
||||
delete m_InputProxy;
|
||||
@@ -170,40 +187,56 @@ void Game::Tick()
|
||||
m_SoundManager->Update(dt);
|
||||
|
||||
// Update network
|
||||
if (m_IsClientOrServer) {
|
||||
m_ClientOrServer->Update();
|
||||
m_EventBroker->Process<MultiplayerSnapshotFilter>();
|
||||
if (m_NetworkClient != nullptr) {
|
||||
m_NetworkClient->Update();
|
||||
}
|
||||
if (m_NetworkServer != nullptr) {
|
||||
m_NetworkServer->Update();
|
||||
}
|
||||
//m_SoundManager->Update(dt);
|
||||
|
||||
// Iterate through systems and update world!
|
||||
m_EventBroker->Process<SystemPipeline>();
|
||||
m_SystemPipeline->Update(dt);
|
||||
debugTick(dt);
|
||||
m_Renderer->Update(dt);
|
||||
GLERROR("Game::Tick m_RenderQueueFactory->Update");
|
||||
m_Renderer->Draw(*m_RenderFrame);
|
||||
m_RenderFrame->Clear();
|
||||
GLERROR("Game::Tick m_Renderer->Draw");
|
||||
m_EventBroker->Swap();
|
||||
m_EventBroker->Clear();
|
||||
}
|
||||
|
||||
void Game::debugTick(double dt)
|
||||
int Game::parseArgs(int argc, char* argv[])
|
||||
{
|
||||
m_EventBroker->Process<Game>();
|
||||
namespace po = boost::program_options;
|
||||
|
||||
po::options_description desc("Options");
|
||||
desc.add_options()
|
||||
("help", "Help")
|
||||
("server,s", po::bool_switch(&m_IsServer), "Launch game in server mode")
|
||||
("connect", po::value<std::string>(&m_NetworkAddress)->default_value(""), "Connect to this address in client mode")
|
||||
("port,p", po::value<int>(&m_NetworkPort), "Port to listen on or connect to");
|
||||
;
|
||||
|
||||
po::variables_map vm;
|
||||
try {
|
||||
po::store(po::parse_command_line(argc, argv, desc), vm);
|
||||
po::notify(vm);
|
||||
} catch (std::exception& e) {
|
||||
LOG_ERROR(e.what());
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (vm.count("help")) {
|
||||
std::cout << desc << std::endl;
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// HACK: Right now, client and server are mutually exclusive
|
||||
m_IsClient = true;
|
||||
if (m_IsServer) {
|
||||
m_IsClient = false;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Game::networkFunction()
|
||||
{
|
||||
bool isServer = m_Config->Get<bool>("Networking.IsServer", false);
|
||||
if (!isServer) {
|
||||
m_IsClientOrServer = true;
|
||||
m_ClientOrServer = new Client(m_Config);
|
||||
}
|
||||
if (isServer) {
|
||||
m_IsClientOrServer = true;
|
||||
m_ClientOrServer = new Server();
|
||||
}
|
||||
m_ClientOrServer->Start(m_World, m_EventBroker);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include "Network/MultiplayerSnapshotFilter.h"
|
||||
|
||||
MultiplayerSnapshotFilter::MultiplayerSnapshotFilter(EventBroker* eventBroker)
|
||||
: m_EventBroker(eventBroker)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &MultiplayerSnapshotFilter::OnPlayerSpawned);
|
||||
}
|
||||
|
||||
bool MultiplayerSnapshotFilter::FilterComponent(EntityWrapper entity, SharedComponentWrapper& component)
|
||||
{
|
||||
if (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (component.Info.Name == "Physics") {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (component.Info.Name == "Transform" || component.Info.Name == "Physics") {
|
||||
m_EventBroker->Publish(Events::Interpolate(entity, component));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MultiplayerSnapshotFilter::OnPlayerSpawned(Events::PlayerSpawned ePlayerSpawned)
|
||||
{
|
||||
if (ePlayerSpawned.PlayerID == -1) {
|
||||
m_LocalPlayer = ePlayerSpawned.Player;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
#include "Systems/CapturePointSystem.h"
|
||||
#include <algorithm>
|
||||
|
||||
CapturePointSystem::CapturePointSystem(World* world, EventBroker* eventBroker)
|
||||
: System(world, eventBroker)
|
||||
CapturePointSystem::CapturePointSystem(SystemParams params)
|
||||
: System(params)
|
||||
, PureSystem("CapturePoint")
|
||||
{
|
||||
//subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
#include "Systems/ExplosionEffectSystem.h"
|
||||
|
||||
void ExplosionEffectSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
|
||||
{
|
||||
if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
|
||||
(double)component["TimeSinceDeath"] = 0.f;
|
||||
}
|
||||
(double&)component["TimeSinceDeath"] += dt;
|
||||
|
||||
//if ((bool)Component["Gravity"] == true) {
|
||||
// (bool)Component["ExponentialAccelaration"] = false;
|
||||
//}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "Systems/HealthSystem.h"
|
||||
|
||||
HealthSystem::HealthSystem(World* m_World, EventBroker* eventBroker)
|
||||
: System(m_World, eventBroker)
|
||||
HealthSystem::HealthSystem(SystemParams params)
|
||||
: System(params)
|
||||
, PureSystem("Health")
|
||||
{
|
||||
//subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
|
||||
|
||||
@@ -1,84 +1,98 @@
|
||||
#include "Systems/InterpolationSystem.h"
|
||||
|
||||
InterpolationSystem::InterpolationSystem(World* world, EventBroker* eventBroker)
|
||||
: System(world, eventBroker)
|
||||
, PureSystem("Transform")
|
||||
InterpolationSystem::InterpolationSystem(SystemParams params)
|
||||
: System(params)
|
||||
{
|
||||
ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
|
||||
m_SnapshotInterval = config->Get<float>("Networking.SnapshotInterval", 0.05f);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EInterpolate, &InterpolationSystem::OnInterpolate);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &InterpolationSystem::OnPlayerSpawned);
|
||||
}
|
||||
|
||||
void InterpolationSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& transform, double dt)
|
||||
void InterpolationSystem::Update(double dt)
|
||||
{
|
||||
// Don't interpolate entities that might already have been removed
|
||||
if (!entity.Valid()) {
|
||||
return;
|
||||
// Position
|
||||
for (auto& kv : m_InterpolatePosition) {
|
||||
EntityWrapper entity = kv.first;
|
||||
if (!entity.Valid()) {
|
||||
continue;
|
||||
}
|
||||
auto& iPosition = kv.second;
|
||||
glm::vec3& position = iPosition.Component[iPosition.Field];
|
||||
|
||||
iPosition.Alpha += dt;
|
||||
float alpha = glm::min(iPosition.Alpha / m_SnapshotInterval, 1.0);
|
||||
position = iPosition.Start + ((iPosition.Goal - iPosition.Start) * alpha);
|
||||
}
|
||||
|
||||
if (m_NextTransform.find(transform.EntityID) != m_NextTransform.end()) { // Exists in map
|
||||
m_NextTransform[transform.EntityID].interpolationTime += static_cast<float>(dt);
|
||||
Transform sTransform = m_NextTransform[transform.EntityID];
|
||||
float time = sTransform.interpolationTime;
|
||||
if (time > m_SnapshotInterval) {
|
||||
if (m_LastReceivedTransform.find(transform.EntityID) != m_LastReceivedTransform.end()) {
|
||||
m_NextTransform[transform.EntityID] = m_LastReceivedTransform[transform.EntityID];
|
||||
m_NextTransform[transform.EntityID].interpolationTime = time - m_SnapshotInterval;
|
||||
sTransform = m_NextTransform[transform.EntityID];
|
||||
m_LastReceivedTransform.erase(transform.EntityID);
|
||||
} else {
|
||||
m_NextTransform.erase(transform.EntityID);
|
||||
}
|
||||
// Orientation
|
||||
for (auto& kv : m_InterpolateOrientation) {
|
||||
EntityWrapper entity = kv.first;
|
||||
if (!entity.Valid()) {
|
||||
continue;
|
||||
}
|
||||
if (transform.Info.Name == "Transform") {
|
||||
bool isLocalPlayer = entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer);
|
||||
// Position
|
||||
glm::vec3 nextPosition = sTransform.Position;
|
||||
glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
|
||||
// HACK: Don't force position for players
|
||||
if (!isLocalPlayer) {
|
||||
(glm::vec3&)transform["Position"] += vectorInterpolation<glm::vec3>(currentPosition, nextPosition, sTransform.interpolationTime);
|
||||
}
|
||||
// Orientation
|
||||
// Don't force orientation for players
|
||||
if (!isLocalPlayer) {
|
||||
glm::quat nextOrientation = sTransform.Orientation;
|
||||
glm::quat currentOrientation = glm::quat(static_cast<glm::vec3>(transform["Orientation"]));
|
||||
(glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / m_SnapshotInterval));
|
||||
}
|
||||
// Scale
|
||||
glm::vec3 nextScale = sTransform.Scale;
|
||||
glm::vec3 currentScale = static_cast<glm::vec3>(transform["Scale"]);
|
||||
(glm::vec3&)transform["Scale"] += vectorInterpolation<glm::vec3>(currentScale, nextScale, sTransform.interpolationTime);
|
||||
auto& iOrientation = kv.second;
|
||||
glm::vec3& orientation = iOrientation.Component[iOrientation.Field];
|
||||
|
||||
iOrientation.Alpha += dt / m_SnapshotInterval;
|
||||
iOrientation.Alpha = glm::min(iOrientation.Alpha, 1.0);
|
||||
orientation = glm::eulerAngles(glm::slerp(iOrientation.Start, iOrientation.Goal, (float)iOrientation.Alpha));
|
||||
}
|
||||
|
||||
// Velocity
|
||||
for (auto& kv : m_InterpolateVelocity) {
|
||||
EntityWrapper entity = kv.first;
|
||||
if (!entity.Valid()) {
|
||||
continue;
|
||||
}
|
||||
auto& iVelocity = kv.second;
|
||||
glm::vec3& position = iVelocity.Component[iVelocity.Field];
|
||||
|
||||
iVelocity.Alpha += dt;
|
||||
float alpha = glm::min(iVelocity.Alpha / m_SnapshotInterval, 1.0);
|
||||
position = iVelocity.Start + ((iVelocity.Goal - iVelocity.Start) * alpha);
|
||||
}
|
||||
}
|
||||
|
||||
bool InterpolationSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
|
||||
bool InterpolationSystem::OnInterpolate(Events::Interpolate& e)
|
||||
{
|
||||
m_LocalPlayer = e.Player;
|
||||
if (e.Component.Info.Name == "Transform") {
|
||||
auto cTransform = e.Entity["Transform"];
|
||||
|
||||
// Position
|
||||
Interpolation<glm::vec3> iPosition(
|
||||
cTransform,
|
||||
"Position",
|
||||
cTransform["Position"],
|
||||
e.Component["Position"]
|
||||
);
|
||||
m_InterpolatePosition.erase(e.Entity);
|
||||
m_InterpolatePosition.insert(std::make_pair(e.Entity, iPosition));
|
||||
|
||||
// Orientation
|
||||
Interpolation<glm::quat> iOrientation(
|
||||
cTransform,
|
||||
"Orientation",
|
||||
glm::quat((glm::vec3&)cTransform["Orientation"]),
|
||||
glm::quat((glm::vec3&)e.Component["Orientation"])
|
||||
);
|
||||
m_InterpolateOrientation.erase(e.Entity);
|
||||
m_InterpolateOrientation.insert(std::make_pair(e.Entity, iOrientation));
|
||||
} else if (e.Component.Info.Name == "Physics") {
|
||||
auto cPhysics = e.Entity["Physics"];
|
||||
if (!e.Entity.HasComponent("Player")) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Velocity
|
||||
Interpolation<glm::vec3> iVelocity(
|
||||
cPhysics,
|
||||
"Velocity",
|
||||
cPhysics["Velocity"],
|
||||
e.Component["Velocity"]
|
||||
);
|
||||
m_InterpolateVelocity.erase(e.Entity);
|
||||
m_InterpolateVelocity.insert(std::make_pair(e.Entity, iVelocity));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool InterpolationSystem::OnInterpolate(const Events::Interpolate & e)
|
||||
{
|
||||
Transform transform;
|
||||
int offset = 0;
|
||||
// Read the data
|
||||
memcpy(&transform.Position, e.DataArray.get() + offset, sizeof(glm::vec3));
|
||||
offset += sizeof(glm::vec3);
|
||||
glm::vec3 tempOrientation;
|
||||
memcpy(&tempOrientation, e.DataArray.get() + offset, sizeof(glm::vec3));
|
||||
transform.Orientation = glm::quat(tempOrientation);
|
||||
offset += sizeof(glm::vec3);
|
||||
memcpy(&transform.Scale, e.DataArray.get() + offset, sizeof(glm::vec3));
|
||||
transform.interpolationTime = 0.0f;
|
||||
|
||||
if (m_NextTransform.find(e.Entity) != m_NextTransform.end()) { // Did exist
|
||||
m_LastReceivedTransform[e.Entity] = transform;
|
||||
} else { // Did not
|
||||
m_NextTransform[e.Entity] = transform;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "Systems/PickupSpawnSystem.h"
|
||||
|
||||
PickupSpawnSystem::PickupSpawnSystem(World* m_World, EventBroker* eventBroker)
|
||||
: System(m_World, eventBroker)
|
||||
PickupSpawnSystem::PickupSpawnSystem(SystemParams params)
|
||||
: System(params)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &PickupSpawnSystem::OnTriggerTouch);
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "Systems/PlayerDeathSystem.h"
|
||||
|
||||
PlayerDeathSystem::PlayerDeathSystem(World* m_World, EventBroker* eventBroker)
|
||||
: System(m_World, eventBroker)
|
||||
PlayerDeathSystem::PlayerDeathSystem(SystemParams params)
|
||||
: System(params)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerDeathSystem::OnPlayerDeath);
|
||||
}
|
||||
|
||||
@@ -1,21 +1,6 @@
|
||||
#include "Game/Systems/PlayerHUD.h"
|
||||
#include "Game/Systems/PlayerHUDSystem.h"
|
||||
|
||||
PlayerHUD::PlayerHUD(World* world, EventBroker* eventBrokerer)
|
||||
:System(world, eventBrokerer)
|
||||
, m_World(world)
|
||||
, m_EventBroker(eventBrokerer)
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
PlayerHUD::~PlayerHUD()
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
void PlayerHUD::Update(double dt)
|
||||
void PlayerHUDSystem::Update(double dt)
|
||||
{
|
||||
auto healthHUDs = m_World->GetComponents("HealthHUD");
|
||||
if (healthHUDs == nullptr) {
|
||||
@@ -1,8 +1,7 @@
|
||||
#include "Systems/PlayerMovementSystem.h"
|
||||
|
||||
PlayerMovementSystem::PlayerMovementSystem(World* world, EventBroker* eventBroker)
|
||||
: System(world, eventBroker)
|
||||
, PureSystem("Player")
|
||||
PlayerMovementSystem::PlayerMovementSystem(SystemParams params)
|
||||
: System(params)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &PlayerMovementSystem::OnPlayerSpawned);
|
||||
}
|
||||
@@ -15,6 +14,12 @@ PlayerMovementSystem::~PlayerMovementSystem()
|
||||
}
|
||||
|
||||
void PlayerMovementSystem::Update(double dt)
|
||||
{
|
||||
updateMovementControllers(dt);
|
||||
updateVelocity(dt);
|
||||
}
|
||||
|
||||
void PlayerMovementSystem::updateMovementControllers(double dt)
|
||||
{
|
||||
for (auto& kv : m_PlayerInputControllers) {
|
||||
EntityWrapper player = kv.first;
|
||||
@@ -24,12 +29,20 @@ void PlayerMovementSystem::Update(double dt)
|
||||
continue;
|
||||
}
|
||||
|
||||
// Aim pitch
|
||||
EntityWrapper cameraEntity = player.FirstChildByName("Camera");
|
||||
if (cameraEntity.Valid()) {
|
||||
glm::vec3& cameraOrientation = cameraEntity["Transform"]["Orientation"];
|
||||
cameraOrientation.x += controller->Rotation().x;
|
||||
// Limit camera pitch so we don't break our necks
|
||||
cameraOrientation.x = glm::clamp(cameraOrientation.x, -glm::half_pi<float>(), glm::half_pi<float>());
|
||||
// Set third person model aim pitch
|
||||
EntityWrapper playerModel = player.FirstChildByName("PlayerModel");
|
||||
if (playerModel.Valid()) {
|
||||
ComponentWrapper cAnimationOffset = playerModel["AnimationOffset"];
|
||||
double time = (cameraOrientation.x + glm::half_pi<float>()) / glm::pi<float>();
|
||||
cAnimationOffset["Time"] = time;
|
||||
}
|
||||
}
|
||||
|
||||
ComponentWrapper& cTransform = player["Transform"];
|
||||
@@ -119,24 +132,74 @@ void PlayerMovementSystem::Update(double dt)
|
||||
EntityWrapper playerModel = player.FirstChildByName("PlayerModel");
|
||||
if (playerModel.Valid()) {
|
||||
ComponentWrapper cAnimation = playerModel["Animation"];
|
||||
std::string& animationName1 = cAnimation["AnimationName1"];
|
||||
std::string& animationName2 = cAnimation["AnimationName2"];
|
||||
double& animationTime1 = cAnimation["Time1"];
|
||||
double& animationTime2 = cAnimation["Time2"];
|
||||
double& animationSpeed1 = cAnimation["Speed1"];
|
||||
double& animationSpeed2 = cAnimation["Speed2"];
|
||||
double& animationWeight1 = cAnimation["Weight1"];
|
||||
double& animationWeight2 = cAnimation["Weight2"];
|
||||
|
||||
float movementLength = glm::length(groundVelocity);
|
||||
//TODO: add assault dash animation here
|
||||
if (glm::length(controller->Movement()) > 0.f) {
|
||||
if (controller->Crouching()) {
|
||||
cAnimation["AnimationName1"] = "Crouch Walk";
|
||||
(double&)cAnimation["Speed1"] = 1.f * -glm::sign(controller->Movement().z);
|
||||
double forwardMovement = controller->Movement().z;
|
||||
double strafeMovement = controller->Movement().x;
|
||||
|
||||
if (controller->Crouching() && animationName1 != "CrouchWalk") {
|
||||
animationName1 = "CrouchWalk";
|
||||
animationSpeed1 = 1.0 * -glm::sign(controller->Movement().z);
|
||||
} else {
|
||||
cAnimation["AnimationName1"] = "Run";
|
||||
(double&)cAnimation["Speed1"] = 2.f * -glm::sign(controller->Movement().z);
|
||||
if (glm::abs(forwardMovement) > 0) {
|
||||
if (animationName1 != "Run") {
|
||||
animationName1 = "Run";
|
||||
if (animationName2 == "StrafeLeft" || animationName2 == "StrafeRight") {
|
||||
animationTime1 = animationTime2;
|
||||
} else {
|
||||
animationTime1 = 0.0;
|
||||
}
|
||||
}
|
||||
animationSpeed1 = 2.f * -glm::sign(forwardMovement);
|
||||
}
|
||||
|
||||
if (glm::abs(strafeMovement) > 0) {
|
||||
if (animationName2 != "StrafeLeft" && animationName2 != "StrafeRight") {
|
||||
if (strafeMovement < 0) {
|
||||
animationName2 = "StrafeLeft";
|
||||
}
|
||||
if (strafeMovement > 0) {
|
||||
animationName2 = "StrafeRight";
|
||||
}
|
||||
if (animationName1 == "Run") {
|
||||
animationTime2 = animationTime1;
|
||||
} else {
|
||||
animationTime2 = 0.0;
|
||||
}
|
||||
}
|
||||
animationSpeed2 = 2.f * glm::abs(strafeMovement);
|
||||
}
|
||||
|
||||
double strafeWeight = glm::abs(strafeMovement) / (glm::abs(forwardMovement) + glm::abs(strafeMovement));
|
||||
animationWeight2 = strafeWeight;
|
||||
animationWeight1 = 1.0 - strafeWeight;
|
||||
}
|
||||
} else {
|
||||
if (controller->Crouching()) {
|
||||
cAnimation["AnimationName1"] = "Crouch";
|
||||
(double&)cAnimation["Speed"] = 1.f;
|
||||
animationName1 = "Crouch";
|
||||
animationName2 = "";
|
||||
animationSpeed1 = 1.0;
|
||||
animationSpeed2 = 0.0;
|
||||
animationWeight1 = 1.0;
|
||||
animationWeight2 = 0.0;
|
||||
} else {
|
||||
cAnimation["AnimationName1"] = "Hold Pos";
|
||||
(double&)cAnimation["Speed1"] = 1.f;
|
||||
animationName1 = "Idle";
|
||||
animationName2 = "";
|
||||
animationSpeed1 = 1.f;
|
||||
animationSpeed2 = 0.0;
|
||||
animationWeight1 = 1.0;
|
||||
animationWeight2 = 0.0;
|
||||
//cAnimation["AnimationName2"] = "Idle";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -147,14 +210,16 @@ void PlayerMovementSystem::Update(double dt)
|
||||
playerStep(dt);
|
||||
}
|
||||
|
||||
void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
|
||||
|
||||
void PlayerMovementSystem::updateVelocity(double dt)
|
||||
{
|
||||
ComponentWrapper& cTransform = entity["Transform"];
|
||||
if (!entity.HasComponent("Physics")) {
|
||||
// Only apply velocity to local player
|
||||
if (!LocalPlayer.Valid()) {
|
||||
return;
|
||||
}
|
||||
|
||||
ComponentWrapper& cPhysics = entity["Physics"];
|
||||
ComponentWrapper& cTransform = LocalPlayer["Transform"];
|
||||
ComponentWrapper& cPhysics = LocalPlayer["Physics"];
|
||||
glm::vec3& velocity = cPhysics["Velocity"];
|
||||
bool isOnGround = (bool)cPhysics["IsOnGround"];
|
||||
|
||||
@@ -172,6 +237,7 @@ void PlayerMovementSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
|
||||
velocity.z *= multiplier;
|
||||
}
|
||||
|
||||
// Gravity
|
||||
if (cPhysics["Gravity"]) {
|
||||
velocity.y -= 9.82f * (float)dt;
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "Systems/PlayerSpawnSystem.h"
|
||||
|
||||
PlayerSpawnSystem::PlayerSpawnSystem(World* m_World, EventBroker* eventBroker)
|
||||
: System(m_World, eventBroker)
|
||||
PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params)
|
||||
: System(params)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
|
||||
@@ -71,6 +71,9 @@ bool PlayerSpawnSystem::OnInputCommand(const Events::InputCommand& e)
|
||||
bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
|
||||
{
|
||||
// When a player is actually spawned (since the actual spawning is handled on the server)
|
||||
if (!IsClient) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if a player already exists
|
||||
if (m_PlayerEntities.count(e.PlayerID) != 0) {
|
||||
|
||||
@@ -1,19 +1,15 @@
|
||||
#include "Game/Systems/SoundSystem.h"
|
||||
|
||||
SoundSystem::SoundSystem(World* world, EventBroker* eventbroker)
|
||||
: System(world, eventbroker)
|
||||
SoundSystem::SoundSystem(SystemParams params)
|
||||
: System(params)
|
||||
, PureSystem("SoundEmitter")
|
||||
//, ImpureSystem()
|
||||
{
|
||||
ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
|
||||
m_Announcer = ResourceManager::Load<ConfigFile>("Config.ini")->Get<std::string>("Sound.Announcer", "female");
|
||||
m_World = world;
|
||||
m_EventBroker = eventbroker;
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &SoundSystem::OnPlayerSpawned);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_InputCommand, &SoundSystem::OnInputCommand);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &SoundSystem::OnDoubleJump);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EDashAbility, &SoundSystem::OnDashAbility);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EShoot, &SoundSystem::OnShoot);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &SoundSystem::OnPlayerDamage);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &SoundSystem::OnCaptured);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &SoundSystem::OnTriggerTouch);
|
||||
@@ -25,7 +21,7 @@ void SoundSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cComp
|
||||
void SoundSystem::Update(double dt)
|
||||
{
|
||||
// Temp for play test.
|
||||
if(m_DrumsIsPlaying) {
|
||||
if (m_DrumsIsPlaying) {
|
||||
m_DrumsIsPlaying = !drumTimer(dt);
|
||||
}
|
||||
}
|
||||
@@ -34,9 +30,8 @@ bool SoundSystem::OnPlayerSpawned(const Events::PlayerSpawned &e)
|
||||
{
|
||||
if (e.PlayerID == -1) { // Local player
|
||||
m_World->AttachComponent(e.Player.ID, "Listener");
|
||||
m_LocalPlayer = e.Player;
|
||||
Events::PlaySoundOnEntity go;
|
||||
go.EmitterID = m_LocalPlayer.ID;
|
||||
go.EmitterID = LocalPlayer.ID;
|
||||
go.FilePath = "Audio/announcer/" + m_Announcer + "/go.wav";
|
||||
m_EventBroker->Publish(go);
|
||||
// TEMP: starts bgm
|
||||
@@ -59,7 +54,7 @@ bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
|
||||
}
|
||||
if (e.Command == "TakeDamage" && e.Value > 0) {
|
||||
Events::PlayerDamage ev;
|
||||
ev.Player = m_LocalPlayer;
|
||||
ev.Player = LocalPlayer;
|
||||
ev.Damage = 1.0;
|
||||
m_EventBroker->Publish(ev);
|
||||
}
|
||||
@@ -69,10 +64,14 @@ bool SoundSystem::OnInputCommand(const Events::InputCommand & e)
|
||||
|
||||
void SoundSystem::playerJumps()
|
||||
{
|
||||
bool grounded = (bool)m_World->GetComponent(m_LocalPlayer.ID, "Physics")["IsOnGround"];
|
||||
if (!LocalPlayer.Valid()) {
|
||||
return;
|
||||
}
|
||||
|
||||
bool grounded = (bool)m_World->GetComponent(LocalPlayer.ID, "Physics")["IsOnGround"];
|
||||
if (grounded) {
|
||||
Events::PlaySoundOnEntity e;
|
||||
e.EmitterID = m_LocalPlayer.ID;
|
||||
e.EmitterID = LocalPlayer.ID;
|
||||
e.FilePath = "Audio/jump/jump1.wav";
|
||||
m_EventBroker->Publish(e);
|
||||
}
|
||||
@@ -89,26 +88,17 @@ bool SoundSystem::drumTimer(double dt)
|
||||
}
|
||||
}
|
||||
|
||||
bool SoundSystem::OnShoot(const Events::Shoot & e)
|
||||
{
|
||||
Events::PlaySoundOnEntity ev;
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/laser/laser1.wav";
|
||||
m_EventBroker->Publish(ev);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool SoundSystem::OnCaptured(const Events::Captured & e)
|
||||
{
|
||||
int homeTeam = (int)m_World->GetComponent(e.CapturePointID, "Team")["Team"];
|
||||
int team = (int)m_World->GetComponent(m_LocalPlayer.ID, "Team")["Team"];
|
||||
int team = (int)m_World->GetComponent(LocalPlayer.ID, "Team")["Team"];
|
||||
Events::PlaySoundOnEntity ev;
|
||||
if (team == homeTeam) {
|
||||
ev.FilePath = "Audio/announcer/" + m_Announcer + "/objective_achieved.wav";
|
||||
} else {
|
||||
ev.FilePath = "Audio/announcer/" + m_Announcer + "/objective_failed.wav"; // have not been tested
|
||||
}
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.EmitterID = LocalPlayer.ID;
|
||||
m_EventBroker->Publish(ev);
|
||||
// Temp for play test.
|
||||
m_DrumsIsPlaying = false;
|
||||
@@ -124,13 +114,13 @@ bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
|
||||
std::vector<std::string> paths;
|
||||
paths.push_back("Audio/hurt/hurt" + std::to_string(rand) + ".wav");
|
||||
|
||||
// // Breathe
|
||||
// int ammountOfbreaths = (static_cast<int>(e.Damage) / 10) + 2; // TEMP: Idk something stupid like this shit
|
||||
// for (int i = 0; i < ammountOfbreaths; i++) {
|
||||
// paths.push_back("Audio/exhausted/breath.wav");
|
||||
// }
|
||||
// // Breathe
|
||||
// int ammountOfbreaths = (static_cast<int>(e.Damage) / 10) + 2; // TEMP: Idk something stupid like this shit
|
||||
// for (int i = 0; i < ammountOfbreaths; i++) {
|
||||
// paths.push_back("Audio/exhausted/breath.wav");
|
||||
// }
|
||||
Events::PlayQueueOnEntity ev;
|
||||
ev.Emitter = m_LocalPlayer;
|
||||
ev.Emitter = LocalPlayer;
|
||||
ev.FilePaths = paths;
|
||||
m_EventBroker->Publish(ev);
|
||||
return false;
|
||||
@@ -139,8 +129,8 @@ bool SoundSystem::OnPlayerDamage(const Events::PlayerDamage & e)
|
||||
bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
|
||||
{
|
||||
Events::PlaySoundOnEntity ev;
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/die/die2.wav";
|
||||
ev.EmitterID = LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/die/die2.wav";
|
||||
m_EventBroker->Publish(ev);
|
||||
return false;
|
||||
}
|
||||
@@ -148,7 +138,7 @@ bool SoundSystem::OnPlayerDeath(const Events::PlayerDeath & e)
|
||||
bool SoundSystem::OnPlayerHealthPickup(const Events::PlayerHealthPickup & e)
|
||||
{
|
||||
Events::PlaySoundOnEntity ev;
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.EmitterID = LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/pickup/pickup2.wav";
|
||||
m_EventBroker->Publish(ev);
|
||||
return false;
|
||||
@@ -162,7 +152,7 @@ bool SoundSystem::OnTriggerTouch(const Events::TriggerTouch & e)
|
||||
}
|
||||
if (m_World->HasComponent(e.Trigger.ID, "CapturePoint")) {
|
||||
Events::PlaySoundOnEntity ev; // should be BGM
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.EmitterID = LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/bgm/drumstest.wav";
|
||||
m_EventBroker->Publish(ev);
|
||||
// Temp for play test.
|
||||
@@ -174,7 +164,7 @@ bool SoundSystem::OnTriggerTouch(const Events::TriggerTouch & e)
|
||||
bool SoundSystem::OnDoubleJump(const Events::DoubleJump & e)
|
||||
{
|
||||
Events::PlaySoundOnEntity ev;
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.EmitterID = LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/jump/jump2.wav";
|
||||
m_EventBroker->Publish(ev);
|
||||
return false;
|
||||
@@ -183,7 +173,7 @@ bool SoundSystem::OnDoubleJump(const Events::DoubleJump & e)
|
||||
bool SoundSystem::OnDashAbility(const Events::DashAbility &e)
|
||||
{
|
||||
Events::PlaySoundOnEntity ev;
|
||||
ev.EmitterID = m_LocalPlayer.ID;
|
||||
ev.EmitterID = LocalPlayer.ID;
|
||||
ev.FilePath = "Audio/jump/dash1.wav";
|
||||
m_EventBroker->Publish(ev);
|
||||
return false;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "Systems/SpawnerSystem.h"
|
||||
|
||||
SpawnerSystem::SpawnerSystem(World* world, EventBroker* eventBroker)
|
||||
: System(world, eventBroker)
|
||||
SpawnerSystem::SpawnerSystem(SystemParams params)
|
||||
: System(params)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_OnSpawnerSpawn, &SpawnerSystem::OnSpawnerSpawn);
|
||||
}
|
||||
@@ -51,7 +51,7 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
|
||||
// Set its position and orientation to that of the SpawnPoint
|
||||
spawnedEntity["Transform"]["Position"] = Transform::AbsolutePosition(spawnPoint.World, spawnPoint.ID);
|
||||
// TODO: Quaternions, bitch
|
||||
//spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint.World, spawnPoint.ID));
|
||||
spawnedEntity["Transform"]["Orientation"] = glm::eulerAngles(Transform::AbsoluteOrientation(spawnPoint));
|
||||
|
||||
return spawnedEntity;
|
||||
}
|
||||
|
||||
@@ -1,13 +1,15 @@
|
||||
#include "Systems/WeaponSystem.h"
|
||||
|
||||
WeaponSystem::WeaponSystem(World* world, EventBroker* eventBroker, IRenderer* renderer)
|
||||
: System(world, eventBroker)
|
||||
, ImpureSystem()
|
||||
WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
|
||||
: System(params)
|
||||
, PureSystem("Player")
|
||||
, m_SystemParams(params)
|
||||
, m_Renderer(renderer)
|
||||
, m_CollisionOctree(collisionOctree)
|
||||
{
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponSystem::OnInputCommand);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EShoot, &WeaponSystem::OnShoot);
|
||||
EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &WeaponSystem::OnPlayerSpawned);
|
||||
}
|
||||
|
||||
void WeaponSystem::Update(double dt)
|
||||
@@ -15,90 +17,84 @@ void WeaponSystem::Update(double dt)
|
||||
|
||||
}
|
||||
|
||||
bool WeaponSystem::OnPlayerSpawned(const Events::PlayerSpawned& e)
|
||||
void WeaponSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt)
|
||||
{
|
||||
// Update potential weapon behaviour for player
|
||||
auto it = m_ActiveWeapons.find(entity);
|
||||
if (it == m_ActiveWeapons.end()) {
|
||||
selectWeapon(entity, 1);
|
||||
}
|
||||
|
||||
m_ActiveWeapons.at(entity)->Update(dt);
|
||||
}
|
||||
|
||||
bool WeaponSystem::OnInputCommand(Events::InputCommand& e)
|
||||
{
|
||||
EntityWrapper player = e.Player;
|
||||
if (e.PlayerID == -1) {
|
||||
m_LocalPlayer = e.Player;
|
||||
player = LocalPlayer;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WeaponSystem::OnInputCommand(const Events::InputCommand& e)
|
||||
{
|
||||
// Only shoot client-side!
|
||||
if (e.PlayerID != -1) {
|
||||
// Make sure player is alive
|
||||
if (!player.Valid()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Only shoot if the player is alive
|
||||
if (!m_LocalPlayer.Valid()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (e.Command == "PrimaryFire" && e.Value > 0) {
|
||||
Events::Shoot eShoot;
|
||||
if (e.PlayerID == -1) {
|
||||
eShoot.Player = m_LocalPlayer;
|
||||
} else {
|
||||
eShoot.Player = e.Player;
|
||||
// Weapon selection
|
||||
if (e.Command == "SelectWeapon") {
|
||||
if (e.Value != 0) {
|
||||
//selectWeapon(player, static_cast<ComponentInfo::EnumType>(e.Value));
|
||||
}
|
||||
}
|
||||
|
||||
// Fire
|
||||
if (e.Command == "PrimaryFire") {
|
||||
if (m_ActiveWeapons.find(player) != m_ActiveWeapons.end()) {
|
||||
auto weapon = m_ActiveWeapons.at(player);
|
||||
if (e.Value > 0) {
|
||||
weapon->Fire();
|
||||
} else {
|
||||
weapon->CeaseFire();
|
||||
}
|
||||
}
|
||||
m_EventBroker->Publish(eShoot);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WeaponSystem::OnShoot(Events::Shoot& eShoot)
|
||||
void WeaponSystem::selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot)
|
||||
{
|
||||
// Primary
|
||||
if (slot == 1) {
|
||||
// TODO: if class...
|
||||
if (m_ActiveWeapons.count(player) == 0) {
|
||||
m_ActiveWeapons.insert(std::make_pair(player, std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_CollisionOctree, player)));
|
||||
} else {
|
||||
//m_ActiveWeapons.erase(player);
|
||||
}
|
||||
}
|
||||
|
||||
// Secondary
|
||||
if (slot == 2) {
|
||||
//m_ActiveWeapons[player] = std::make_shared<PistolWeaponBehaviour>();
|
||||
}
|
||||
}
|
||||
|
||||
bool WeaponSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
|
||||
{
|
||||
// Select primary weapon on player spawn
|
||||
// TODO: Select the active one specified by player component
|
||||
return true;
|
||||
}
|
||||
|
||||
bool WeaponSystem::OnShoot(Events::Shoot& eShoot)
|
||||
{
|
||||
if (!eShoot.Player.Valid()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// TODO: Weapon firing effects here
|
||||
|
||||
auto rayRed = ResourceManager::Load<EntityFile>("Schema/Entities/RayRed.xml");
|
||||
auto rayBlue = ResourceManager::Load<EntityFile>("Schema/Entities/RayBlue.xml");
|
||||
|
||||
EntityWrapper weapon = eShoot.Player.FirstChildByName("WeaponMuzzle");
|
||||
if (weapon.Valid()) {
|
||||
EntityWrapper ray;
|
||||
if ((ComponentInfo::EnumType)eShoot.Player["Team"]["Team"] == eShoot.Player["Team"]["Team"].Enum("Red")) {
|
||||
EntityFileParser parser(rayRed);
|
||||
EntityID rayID = parser.MergeEntities(m_World);
|
||||
ray = EntityWrapper(m_World, rayID);
|
||||
} else {
|
||||
EntityFileParser parser(rayBlue);
|
||||
EntityID rayID = parser.MergeEntities(m_World);
|
||||
ray = EntityWrapper(m_World, rayID);
|
||||
}
|
||||
|
||||
glm::mat4 transformation = Transform::AbsoluteTransformation(weapon);
|
||||
glm::vec3 scale;
|
||||
glm::vec3 translation;
|
||||
glm::quat orientation;
|
||||
glm::vec3 skew;
|
||||
glm::vec4 perspective;
|
||||
glm::decompose(transformation, scale, orientation, translation, skew, perspective);
|
||||
|
||||
// Matrix to euler angles
|
||||
glm::vec3 euler;
|
||||
euler.y = glm::asin(-transformation[0][2]);
|
||||
if (cos(euler.y) != 0) {
|
||||
euler.x = atan2(transformation[1][2], transformation[2][2]);
|
||||
euler.z = atan2(transformation[0][1], transformation[0][0]);
|
||||
} else {
|
||||
euler.x = atan2(-transformation[2][0], transformation[1][1]);
|
||||
euler.z = 0;
|
||||
}
|
||||
|
||||
//LOG_DEBUG("rotation: %f %f %f", euler.x, euler.y, euler.z);
|
||||
(glm::vec3&)ray["Transform"]["Position"] = translation;
|
||||
(glm::vec3&)ray["Transform"]["Orientation"] = euler;
|
||||
//(glm::vec3&)ray["Transform"]["Orientation"] = Transform::AbsoluteOrientationEuler(weapon);
|
||||
}
|
||||
|
||||
// Only run further picking code client-side!
|
||||
if (eShoot.Player != m_LocalPlayer) {
|
||||
// Only run further picking code for the local player!
|
||||
if (eShoot.Player != LocalPlayer) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -138,4 +134,4 @@ bool WeaponSystem::OnShoot(Events::Shoot& eShoot)
|
||||
m_EventBroker->Publish(ePlayerDamage);
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user