BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into AndersTest

Browse Source 
# Conflicts:
#	include/Engine/Core/MemoryPool.h
#	include/Engine/Network/Packet.h
#	include/Game/Systems/AmmoPickupSystem.h
#	include/Game/Systems/PickupSpawnSystem.h
#	resources/Schema/Entities/NewMap2version2.xml
#	src/Game/Game.cpp
#	src/Game/Systems/AmmoPickupSystem.cpp
#	src/Game/Systems/PickupSpawnSystem.cpp
This commit is contained in:
verysecrethero
2016-03-14 10:31:03 +01:00
parent 63e8fb4bc8 18ea938b56
commit 01e0e41122
501 changed files with 165536 additions and 7412 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Game/Events/EDashAbility.h
+5 -1
View File
@@ -2,11 +2,15 @@
#define Events_DashAbility_h__
#include "Core/Event.h"
#include "Core/EntityWrapper.h"
namespace Events
{
struct DashAbility : public Event { };
struct DashAbility : public Event
{
EntityID Player;
};
}
include/Game/Events/EReset.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef Events_Reset_h__
#define Events_Reset_h__
#include "Core/EventBroker.h"
#include "Core/EntityWrapper.h"
namespace Events
{
struct Reset : Event
{
};
}
#endif
include/Game/Game.h
+3 -3
View File
@@ -13,13 +13,13 @@
#include "Input/KeyboardInputHandler.h"
#include "Input/MouseInputHandler.h"
#include "Core/EKeyDown.h"
#include "Core/EntityFilePreprocessor.h"
#include "Core/EntityXMLFilePreprocessor.h"
#include "Core/SystemPipeline.h"
#include "Systems/ExplosionEffectSystem.h"
#include "Editor/EditorSystem.h"
#include "Core/EntityFile.h"
#include "Core/EntityXMLFile.h"
#include "Rendering/RenderSystem.h"
#include "Core/EntityFileParser.h"
#include "Core/EntityXMLFileParser.h"
#include "Core/Octree.h"
#include "Rendering/Font.h"
#include "Systems/InterpolationSystem.h"
include/Game/Systems/AbilityCooldownHUDSystem.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef AbilityCooldownHUDSystem_h__
#define AbilityCooldownHUDSystem_h__
#include "../../Engine/Core/System.h"
#include "../../Engine/GLM.h"
class AbilityCooldownHUDSystem : public ImpureSystem
{
public:
AbilityCooldownHUDSystem(SystemParams params)
: System(params)
{ }
virtual void Update(double dt) override;
private:
};
#endif
include/Game/Systems/AmmoPickupSystem.h
+18 -7
View File
@@ -2,9 +2,9 @@
#define AmmoPickupSystem_h__
#include "Core/System.h"
#include "Core/Transform.h"
#include "Core/TransformSystem.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFileParser.h"
#include "Core/EntityFile.h"
#include "Core/EPickupSpawned.h"
#include "Core/EAmmoPickup.h"
#include "Engine/Collision/ETrigger.h"
@@ -23,6 +23,9 @@ private:
EventRelay<AmmoPickupSystem, Events::TriggerLeave> m_ETriggerLeave;
bool OnTriggerLeave(Events::TriggerLeave& e);
EventRelay<AmmoPickupSystem, Events::AmmoPickup> m_EAmmoPickup;
bool OnAmmoPickup(Events::AmmoPickup& e);
struct NewAmmoPickup {
glm::vec3 Pos;
double AmmoGain;
@@ -31,15 +34,23 @@ private:
EntityID parentID;
};
std::vector<NewAmmoPickup> m_ETriggerTouchVector;
struct EntityAtMaxValuePickupStruct {
EntityWrapper player;
EntityWrapper pickup;
EntityWrapper trigger;
};
std::vector<EntityAtMaxValuePickupStruct> m_PickupAtMaximum;
void DoPickup(EntityWrapper &player, EntityWrapper &trigger);
//class
enum class PlayerClass {
Assault,
Defender,
Sniper,
None
};
//helper methods
bool DoesPlayerHaveMaxAmmo(EntityWrapper &player);
PlayerClass DetermineClass(EntityWrapper &player);
void SetPlayerAmmo(EntityWrapper &player, int ammoGain);
int GetPlayerMaxAmmo(EntityWrapper &player);
};
#endif
include/Game/Systems/AmmunitionHUDSystem.h
-17
View File
@@ -1,17 +0,0 @@
#ifndef AmmunitionHUDSystem_h__
#define AmmunitionHUDSystem_h__
#include "../../Engine/Core/System.h"
#include "../../Engine/GLM.h"
class AmmunitionHUDSystem : public ImpureSystem
{
public:
AmmunitionHUDSystem(SystemParams params)
: System(params)
{ }
virtual void Update(double dt) override;
};
#endif
include/Game/Systems/BoostIconsHUDSystem.h
+19
View File
@@ -0,0 +1,19 @@
#ifndef BoostIconsHUDSystem_h__
#define BoostIconsHUDSystem_h__
#include "../../Engine/Core/System.h"
#include "../../Engine/GLM.h"
class BoostIconsHUDSystem : public PureSystem
{
public:
BoostIconsHUDSystem(SystemParams params)
: System(params)
, PureSystem("BoostIconsHUD")
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
};
#endif
include/Game/Systems/BoostSystem.h
+24
View File
@@ -0,0 +1,24 @@
#ifndef BoostSystem_h__
#define BoostSystem_h__
#include "Core/System.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFile.h"
#include "Core/EPlayerDamage.h"
#include "Common.h"
#include "SpawnerSystem.h"
class BoostSystem : public System
{
public:
BoostSystem(SystemParams params);
private:
EventRelay<BoostSystem, Events::PlayerDamage> m_EPlayerDamage;
bool OnPlayerDamage(Events::PlayerDamage& e);
std::string DetermineClass(EntityWrapper player);
void giveAmmo(EntityWrapper giver, EntityWrapper receiver);
};
#endif
include/Game/Systems/CapturePointArrowHUDSystem.h
+30
View File
@@ -0,0 +1,30 @@
#ifndef CapturePointArrowHUDSystem_h__
#define CapturePointArrowHUDSystem_h__
#include <GLFW/glfw3.h>
#include <glm/common.hpp>
#include <glm/gtx/vector_angle.hpp>
#include "Common.h"
#include "Core/System.h"
#include "Core/TransformSystem.h"
#include "Core/ECaptured.h"
class CapturePointArrowHUDSystem : public ImpureSystem
{
public:
CapturePointArrowHUDSystem(SystemParams params);
virtual void Update(double dt) override;
private:
EventRelay<CapturePointArrowHUDSystem, Events::Captured> m_ECapturedEvent;
bool OnCapturePointCaptured(Events::Captured& e);
bool m_InitialtargetsSet = false;
glm::vec3 m_RedTeamCurrentTarget;
glm::vec3 m_BlueTeamCurrentTarget;
};
#endif
include/Game/Systems/CapturePointHUDSystem.h
+1 -1
View File
@@ -7,7 +7,7 @@
#include "Common.h"
#include "Core/System.h"
#include "Engine/Collision/ETrigger.h"
#include "Collision/ETrigger.h"
class CapturePointHUDSystem : public ImpureSystem
{
include/Game/Systems/CapturePointSystem.h
+7 -2
View File
@@ -9,6 +9,7 @@
#include "Engine/Collision/ETrigger.h"
#include "Core/ECaptured.h"
#include "Core/EWin.h"
#include "Game/Events/EReset.h"
#include <tuple>
#include <vector>
@@ -23,6 +24,7 @@ public:
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
private:
void Init();
//methods which will take care of specific events
EventRelay<CapturePointSystem, Events::TriggerTouch> m_ETriggerTouch;
bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e);
@@ -30,6 +32,9 @@ private:
bool CapturePointSystem::OnTriggerLeave(const Events::TriggerLeave& e);
EventRelay<CapturePointSystem, Events::Captured> m_ECaptured;
bool CapturePointSystem::OnCaptured(const Events::Captured& e);
EventRelay<CapturePointSystem, Events::Reset> m_EReset;
bool CapturePointSystem::OnReset(const Events::Reset& e);
void ChangeCapturePointModelsVisibility(EntityWrapper &capturePointModels, bool isOwner);
bool m_WinnerWasFound = false;
//need to track these variables for the captureSystem to work as per design!
@@ -42,9 +47,9 @@ private:
int m_NumberOfCapturePoints = 0;
std::map<int, EntityWrapper> m_CapturePointNumberToEntityMap;
//std::vector<ComponentWrapper>
bool m_ResetTimers = false;
bool m_RecentlyCapturedNeedNextCapturePointNow = false;
Events::Captured m_CapturedEvent;
//vectors which will keep track of enter/leave changes
std::vector<std::tuple<EntityWrapper, EntityWrapper>> m_ETriggerTouchVector;
include/Game/Systems/DamageIndicatorSystem.h
+5 -2
View File
@@ -2,9 +2,9 @@
#define DamageIndicatorSystem_h__
#include "Core/System.h"
#include "Core/Transform.h"
#include "Core/TransformSystem.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFileParser.h"
#include "Core/EntityFile.h"
#include "Core/EPlayerDamage.h"
#include "Common.h"
#include <tuple>
@@ -15,6 +15,7 @@
#include "Rendering/Util/CommonFunctions.h"
//#define INDICATOR_TEST
#include "Core/ConfigFile.h"
class DamageIndicatorSystem : public ImpureSystem
{
@@ -40,6 +41,8 @@ private:
std::vector<DamageIndicatorStruct> updateDamageIndicatorVector;
float CalculateAngle(EntityWrapper player, glm::vec3 enemyPos);
bool m_NetworkEnabled;
//for tests
#ifdef INDICATOR_TEST
glm::vec3 DamageIndicatorTest(EntityWrapper player);
include/Game/Systems/EndScreenSystem.h
+21
View File
@@ -0,0 +1,21 @@
#ifndef EndScreenSystem_h__
#define EndScreenSystem_h__
#include "Core/System.h"
#include "Input/EInputCommand.h"
#include "Rendering/ESetCamera.h"
#include "Core/EWin.h"
class EndScreenSystem : public ImpureSystem
{
public:
EndScreenSystem(SystemParams params);
virtual void Update(double dt) override;
private:
EventRelay<EndScreenSystem, Events::Win> m_EWin;
bool OnWin(const Events::Win& e);
};
#endif
include/Game/Systems/ExplosionEffectSystem.h
+1
View File
@@ -3,6 +3,7 @@
#include "Common.h"
#include "Core/System.h"
#include "Engine/GLM.h"
class ExplosionEffectSystem : public PureSystem
{
include/Game/Systems/FadeSystem.h
+22
View File
@@ -0,0 +1,22 @@
#ifndef FadeSystem_h__
#define FadeSystem_h__
#include "Core/System.h"
#include "GLM.h"
class FadeSystem : public PureSystem
{
public:
FadeSystem(SystemParams params)
: System(params)
, PureSystem("Fade")
{
}
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cFadeOut, double dt) override;
private:
};
#endif
include/Game/Systems/FloatingEffectSystem.h
+19
View File
@@ -0,0 +1,19 @@
#include "Common.h"
#include "Core/System.h"
class FloatingEffectSystem : public PureSystem
{
public:
FloatingEffectSystem(SystemParams params)
: System(params)
, PureSystem("FloatingEffect")
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
{
ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
(Field<double>)component["Time"] += dt;
(Field<glm::vec3>)transform["Position"] = (float)(double)component["Amplitude"] * glm::sin((glm::two_pi<float>() / (float)(double)component["Period"]) * (float)(double)component["Time"]) * (glm::vec3)component["Axis"];
}
};
include/Game/Systems/KillFeedSystem.h
+20 -7
View File
@@ -3,7 +3,7 @@
#include "../../Engine/Core/System.h"
#include "../../Engine/GLM.h"
#include "Core/EPlayerDeath.h"
#include "Network/EKillDeath.h"
class KillFeedSystem : public ImpureSystem
{
@@ -11,8 +11,7 @@ public:
KillFeedSystem(SystemParams params)
: System(params)
{
EVENT_SUBSCRIBE_MEMBER(m_EPlayerDeath, &KillFeedSystem::OnPlayerDeath);
EVENT_SUBSCRIBE_MEMBER(m_EKillDeath, &KillFeedSystem::OnPlayerKillDeath)
}
virtual void Update(double dt) override;
@@ -22,16 +21,30 @@ private:
EventRelay<KillFeedSystem, Events::PlayerDeath> m_EPlayerDeath;
bool KillFeedSystem::OnPlayerDeath(Events::PlayerDeath& e);
EventRelay<KillFeedSystem, Events::KillDeath> m_EKillDeath;
bool KillFeedSystem::OnPlayerKillDeath(Events::KillDeath& e);
struct KillFeedInfo
{
std::string Content;
glm::vec4 Color;
std::string KillerName = "";
int KillerClass = 0;
int KillerID = -1;
int KillerTeam = 0;
std::string KillerColor = "";
std::string VictimName = "";
int VictimClass = 0;
int VictimID = -1;
int VictimTeam = 0;
std::string VictimColor = "";
bool redused;
float TimeToLive = 5.f;
};
std::string m_RedColor = "\\C08366D";
std::string m_BlueColor = "\\C6A1208";
std::list<KillFeedInfo> m_DeathQueue;
};
include/Game/Systems/LifetimeSystem.h
+1 -1
View File
@@ -10,7 +10,7 @@ public:
: System(params)
, PureSystem("Lifetime")
{
LOG_INFO("ASDASDASSA");
}
virtual void Update(double dt) override;
include/Game/Systems/MainMenuSystem.h
+45
View File
@@ -0,0 +1,45 @@
#ifndef MainMenuSystem_h__
#define MainMenuSystem_h__
#include "Core/System.h"
#include "Rendering/IRenderer.h"
#include "Core/ResourceManager.h"
#include "Core/Event.h"
#include "Systems/SpawnerSystem.h"
#include "GUI/EButtonClicked.h"
#include "GUI/EButtonPressed.h"
#include "GUI/EButtonReleased.h"
#include "Input/EInputCommand.h"
#include "Network/ESearchForServers.h"
#include "Network/EConnectRequest.h"
#include <stdlib.h>
class MainMenuSystem : public ImpureSystem
{
public:
MainMenuSystem(SystemParams params, IRenderer* renderer);
virtual void Update(double dt) override;
private:
IRenderer* m_Renderer;
void OpenSubMenu(const Events::InputCommand& e);
void OpenDropDown(const Events::InputCommand& e);
EventRelay<MainMenuSystem, Events::ButtonClicked> m_EClicked;
bool OnButtonClick(const Events::ButtonClicked& e);
EventRelay<MainMenuSystem, Events::ButtonReleased> m_EReleased;
bool OnButtonRelease(const Events::ButtonReleased& e);
EventRelay<MainMenuSystem, Events::ButtonPressed> m_EPressed;
bool OnButtonPress(const Events::ButtonPressed& e);
EventRelay<MainMenuSystem, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(const Events::InputCommand& e);
std::string m_CurrentCommand = "";
EntityWrapper m_OpenSubMenu = EntityWrapper::Invalid;
EntityWrapper m_DropDown = EntityWrapper::Invalid;
};
#endif
include/Game/Systems/PickupSpawnSystem.h
+41
View File
@@ -0,0 +1,41 @@
#ifndef PickupSpawnSystem_h__
#define PickupSpawnSystem_h__
#include "Core/System.h"
#include "Core/TransformSystem.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFile.h"
#include "Core/EPickupSpawned.h"
#include "Core/EPlayerHealthPickup.h"
#include "Engine/Collision/ETrigger.h"
#include "Common.h"
class PickupSpawnSystem : public ImpureSystem
{
public:
PickupSpawnSystem(SystemParams params);
virtual void Update(double dt) override;
private:
EventRelay<PickupSpawnSystem, Events::TriggerTouch> m_ETriggerTouch;
bool OnTriggerTouch(Events::TriggerTouch& e);
EventRelay<PickupSpawnSystem, Events::TriggerLeave> m_ETriggerLeave;
bool OnTriggerLeave(Events::TriggerLeave& e);
struct NewHealthPickup {
glm::vec3 Pos;
double HealthGain;
double RespawnTimer;
double DecreaseThisRespawnTimer;
EntityID parentID;
};
std::vector<NewHealthPickup> m_ETriggerTouchVector;
struct EntityAtMaxValuePickupStruct {
EntityWrapper player;
EntityWrapper trigger;
};
std::vector<EntityAtMaxValuePickupStruct> m_PickupAtMaximum;
void DoPickup(EntityWrapper &player, EntityWrapper &trigger);
};
#endif
include/Game/Systems/PlayerDeathSystem.h
+8 -3
View File
@@ -6,11 +6,9 @@
#include "GLM.h"
#include "Rendering/ESetCamera.h"
#include "Core/ConfigFile.h"
#include "Core/EntityFile.h"
#include "Core/EntityFileParser.h"
#include "Core/EPlayerDeath.h"
#include "Core/EEntityDeleted.h"
class PlayerDeathSystem : public ImpureSystem
{
@@ -20,9 +18,16 @@ public:
virtual void Update(double dt) override;
private:
EntityWrapper m_LocalPlayerDeathEffect;
EventRelay<PlayerDeathSystem, Events::PlayerDeath> m_OnPlayerDeath;
bool OnPlayerDeath(Events::PlayerDeath& e);
EventRelay<PlayerDeathSystem, Events::EntityDeleted> m_EEntityDeleted;
bool OnEntityDeleted(Events::EntityDeleted& e);
EventRelay<PlayerDeathSystem, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(Events::InputCommand& e);
void setSpectatorCamera();
void createDeathEffect(EntityWrapper player);
};
include/Game/Systems/PlayerMovementSystem.h
+9 -3
View File
@@ -6,9 +6,7 @@
#include <imgui/imgui.h>
#include "Events/EDoubleJump.h"
#include "../Engine/Sound/EPlaySoundOnEntity.h"
#include "Core/EntityFile.h"
#include "Core/EntityFileParser.h"
class PlayerMovementSystem : public ImpureSystem
{
@@ -32,8 +30,12 @@ private:
bool m_LeftFoot = false;
// To get a difference when calculating the walking state.
glm::vec3 m_LastPosition = glm::vec3();
// Used to track afterimages for sprint effect.
float m_SprintEffectTimer;
// Used to track afterimages for dash effect.
float m_DashEffectTimer;
// The logic for making the sound play when player is moving
void playerStep(double dt);
void playerStep(double dt, EntityWrapper player);
// Spawn a hexagon at origin of an Entity
void spawnHexagon(EntityWrapper target);
@@ -41,7 +43,11 @@ private:
bool OnPlayerSpawned(Events::PlayerSpawned& e);
EventRelay<PlayerMovementSystem, Events::DoubleJump> m_EDoubleJump;
bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e);
EventRelay<PlayerMovementSystem, Events::DashAbility> m_EDashAbility;
bool PlayerMovementSystem::OnDashAbility(Events::DashAbility & e);
void updateMovementControllers(double dt);
void updateVelocity(EntityWrapper player, double dt);
void setAim(EntityWrapper root, std::string weaponNodeName, double time);
};
include/Game/Systems/PlayerSpawnSystem.h
+11 -4
View File
@@ -13,14 +13,21 @@ public:
PlayerSpawnSystem(SystemParams params);
virtual void Update(double dt) override;
static void SetRespawnTime(float respawnTime) { m_RespawnTime = respawnTime; };
private:
// This enum must correspond to the command values for PickTeam buttons.
enum class PlayerClass
{
None = 0,
Assault = 1,
Defender = 2,
Sniper = 2
};
struct SpawnRequest
{
int PlayerID;
ComponentInfo::EnumType Team;
PlayerClass Class;
};
bool m_NetworkEnabled = false;
@@ -31,8 +38,8 @@ private:
//EntityWrapper ID -> Player ID.
std::map<EntityID, int> m_PlayerIDs;
static float m_RespawnTime;
float m_Timer;
float m_ForcedRespawnTime;
bool m_DbgConfigForceRespawn;
EventRelay<PlayerSpawnSystem, Events::InputCommand> m_OnInputCommand;
bool OnInputCommand(Events::InputCommand& e);
include/Game/Systems/RaptorCopterSystem.h
+24 -3
View File
@@ -1,6 +1,25 @@
#include "Common.h"
#include "Core/System.h"
//struct FSubscriptProxy
// {
// friend struct ComponentWrapper;
// FSubscriptProxy(ComponentWrapper* component, std::string fieldName)
// : m_Component(component)
// , m_FieldName(fieldName)
// { }
// ComponentWrapper* m_Component;
// std::string m_FieldName;
// public:
// template <typename T>
// operator Field<T>() { return Field<T>(m_Component->Field<T>(m_FieldName)); }
// };
class RaptorCopterSystem : public PureSystem
{
public:
@@ -9,9 +28,11 @@ public:
, PureSystem("RaptorCopter")
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cRaptorCopter, double dt) override
{
ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
(glm::vec3&)transform["Orientation"] += (float)(double)component["Speed"] * (float)dt * (glm::vec3)component["Axis"];
ComponentWrapper& cTransform = entity["Transform"];
//FSubscriptProxy subOri(&cTransform, "Orientation");
//Field<glm::vec3> orientation = subOri;
(Field<glm::vec3>)cTransform["Orientation"] += (float)(const double&)cRaptorCopter["Speed"] * (float)dt * (glm::vec3)cRaptorCopter["Axis"];
}
};
include/Game/Systems/ScoreScreenSystem.h
+50
View File
@@ -0,0 +1,50 @@
#ifndef ScoreScreenSystem_h__
#define ScoreScreenSystem_h__
#include "Core/System.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFile.h"
#include "Network/EKillDeath.h"
#include "Core/EPlayerSpawned.h"
#include "Network/EPlayerConnected.h"
#include "Network/EPlayerDisconnected.h"
#include "Game/Events/EReset.h"
#include "Engine/Input/EInputCommand.h"
#include "GLM.h"
class ScoreScreenSystem : public PureSystem
{
public:
ScoreScreenSystem(SystemParams params);
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& scoreScreen, double dt) override;
EventRelay<ScoreScreenSystem, Events::KillDeath> m_EPlayerDeath;
bool OnPlayerDeath(const Events::KillDeath& e);
EventRelay<ScoreScreenSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawn(const Events::PlayerSpawned& e);
EventRelay<ScoreScreenSystem, Events::PlayerConnected> m_EPlayerConnected;
bool OnPlayerConnected(const Events::PlayerConnected& e);
EventRelay<ScoreScreenSystem, Events::PlayerDisconnected> m_EPlayerDisconnected;
bool OnPlayerDisconnected(const Events::PlayerDisconnected& e);
EventRelay<ScoreScreenSystem, Events::Reset> m_EReset;
bool OnReset(const Events::Reset& e);
EventRelay<ScoreScreenSystem, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(const Events::InputCommand& e);
private:
struct PlayerData {
int ID = -1;
std::string Name = "";
int Team = 1;
int Kills = 0;
int Deaths = 0;
EntityWrapper Player = EntityWrapper::Invalid;
};
std::vector<int> m_DisconnectedIdentities;
int m_PlayerCounter = 0;
std::unordered_map<int, PlayerData> m_PlayerIdentities;
};
#endif
include/Game/Systems/ServerListSystem.h
+29
View File
@@ -0,0 +1,29 @@
#ifndef ServerListSystem_h__
#define ServerListSystem_h__
#include "Core/System.h"
#include "Rendering/IRenderer.h"
#include "Core/ResourceManager.h"
#include "Core/Event.h"
#include "Systems/SpawnerSystem.h"
#include "Core/EventBroker.h"
#include "Network/ESearchForServers.h"
#include "Network/EDisplayServerlist.h"
class ServerListSystem : public PureSystem
{
public:
ServerListSystem(SystemParams params, IRenderer* renderer);
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cServerList, double dt) override;
void RefreshList();
private:
IRenderer* m_Renderer;
EventRelay<ServerListSystem, Events::DisplayServerlist> m_EServerListRecieved;
bool OnServerListRecieved(const Events::DisplayServerlist& e);
};
#endif
include/Game/Systems/SoundSystem.h
+6 -12
View File
@@ -2,6 +2,7 @@
#define Systems_SoundSystem_h__
#include <random>
#include <chrono>
#include "../Engine/Core/System.h"
#include "../Engine/Core/ResourceManager.h"
@@ -20,9 +21,10 @@
#include "../Engine/Collision/ETrigger.h"
#include "../Engine/Sound/EPlaySoundOnEntity.h"
#include "../Engine/Sound/EPlayBackgroundMusic.h"
#include "../Engine/Sound/EPlayAnnouncerVoice.h"
#include "../Game/Events/EDoubleJump.h"
#include "../Game/Events/EDashAbility.h"
#include "../Engine/Sound/EChangeBGM.h"
class SoundSystem : public PureSystem, ImpureSystem
{
@@ -33,14 +35,10 @@ public:
private:
std::string m_Announcer = "";
// Logic for playing a sound when a player jumps
void playerJumps();
// Temporary solution for play test.
bool m_DrumsIsPlaying = false;
double m_DrumTimer = 0.0;
bool drumTimer(double dt);
void playerJumps(EntityWrapper player);
std::default_random_engine generator;
std::default_random_engine m_RandomGenerator;
std::uniform_int_distribution<int> m_RandIntDistribution;
EventRelay<SoundSystem, Events::PlayerSpawned> m_EPlayerSpawned;
bool OnPlayerSpawned(const Events::PlayerSpawned &e);
@@ -48,10 +46,6 @@ private:
bool OnInputCommand(const Events::InputCommand &e);
EventRelay<SoundSystem, Events::DoubleJump> m_EDoubleJump;
bool OnDoubleJump(const Events::DoubleJump &e);
EventRelay<SoundSystem, Events::DashAbility> m_EDashAbility;
bool OnDashAbility(const Events::DashAbility &e);
EventRelay<SoundSystem, Events::TriggerTouch> m_ETriggerTouch;
bool OnTriggerTouch(const Events::TriggerTouch &e);
EventRelay<SoundSystem, Events::Captured> m_ECaptured;
bool OnCaptured(const Events::Captured &e);
EventRelay<SoundSystem, Events::PlayerDamage> m_EPlayerDamage;
include/Game/Systems/SpawnerSystem.h
+4 -3
View File
@@ -6,9 +6,9 @@
#include "GLM.h"
#include "Core/System.h"
#include "Events/ESpawnerSpawn.h"
#include "Core/Transform.h"
#include "Core/ResourceManager.h"
#include "Core/EntityFileParser.h"
#include "Core/TransformSystem.h"
#include "Core/EntityFile.h"
#include "Rendering/Model.h"
class SpawnerSystem : public System
{
@@ -19,6 +19,7 @@ public:
// will try to pick a spawn location so that the spawned entity doesn't
// collide with anything that has that component and is collidable.
static EntityWrapper Spawn(EntityWrapper spawner, EntityWrapper parent = EntityWrapper::Invalid, const std::string& dontCollideComponent = "");
static EntityWrapper SpawnEntityFile(const std::string& entityFilePath, EntityWrapper spawner, EntityWrapper parent = EntityWrapper::Invalid, const std::string& dontCollideComponent = "");
private:
EventRelay<SpawnerSystem, Events::SpawnerSpawn> m_OnSpawnerSpawn;
include/Game/Systems/SpectatorCameraSystem.h
+29
View File
@@ -0,0 +1,29 @@
#ifndef SpectatorCameraSystem_h__
#define SpectatorCameraSystem_h__
#include "Core/System.h"
#include "Input/EInputCommand.h"
#include "Network/EPlayerDisconnected.h"
#include "Game/Events/EReset.h"
class SpectatorCameraSystem : public ImpureSystem
{
public:
SpectatorCameraSystem(SystemParams params);
virtual void Update(double dt) override;
private:
int m_PickedTeam;
bool m_CamSetToTeamPick;
void reset();
EventRelay<SpectatorCameraSystem, Events::InputCommand> m_EInputCommand;
bool OnInputCommand(const Events::InputCommand& e);
EventRelay<SpectatorCameraSystem, Events::PlayerDisconnected> m_EDisconnect;
bool OnDisconnect(const Events::PlayerDisconnected& e);
EventRelay<SpectatorCameraSystem, Events::Reset> m_EReset;
bool OnReset(const Events::Reset& e);
};
#endif
include/Game/Systems/StartSystem.h
+23
View File
@@ -0,0 +1,23 @@
#ifndef StartSystem_h__
#define StartSystem_h__
#include "Core/System.h"
#include "Core/ResourceManager.h"
#include "Core/Event.h"
#include "Core/EventBroker.h"
#include "Rendering/ESetCamera.h"
class StartSystem : public ImpureSystem
{
public:
StartSystem(SystemParams params);
virtual void Update(double dt) override;
private:
EntityWrapper m_ActiveCamera = EntityWrapper::Invalid;
EventRelay<StartSystem, Events::SetCamera> m_ECameraActivated;
bool OnCameraActivated(const Events::SetCamera& e);
};
#endif
include/Game/Systems/TextFieldReader.h
+21
View File
@@ -0,0 +1,21 @@
#ifndef AmmunitionHUDSystem_h__
#define AmmunitionHUDSystem_h__
#include <boost/lexical_cast.hpp>
#include <sstream>
#include <iomanip>
#include "../../Engine/Core/System.h"
#include "../../Engine/GLM.h"
class TextFieldReader : public PureSystem
{
public:
TextFieldReader(SystemParams params)
: System(params)
, PureSystem("TextFieldReader")
{ }
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cTextFieldReader, double dt) override;
};
#endif
include/Game/Systems/Weapon/AssaultWeaponBehaviour.h
+26 -29
View File
@@ -1,47 +1,44 @@
#ifndef AssaultWeaponBehaviour_h__
#define AssaultWeaponBehaviour_h__
#include "Sound/EPlaySoundOnEntity.h"
#include "Collision/Collision.h"
#include "Core/ConfigFile.h"
#include "WeaponBehaviour.h"
#include "../SpawnerSystem.h"
#include "Collision/Collision.h"
#include "Core/EPlayerDamage.h"
#include "Core/EShoot.h"
#include "Sound/EPlaySoundOnEntity.h"
#include "Rendering/EAutoAnimationBlend.h"
class AssaultWeaponBehaviour : public WeaponBehaviour<AssaultWeaponBehaviour>
{
public:
AssaultWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
: WeaponBehaviour(systemParams, "AssaultWeapon", renderer, collisionOctree)
: System(systemParams)
, WeaponBehaviour(systemParams, "AssaultWeapon", renderer, collisionOctree)
, m_RandomEngine(m_RandomDevice())
{ }
protected:
virtual void OnPrimaryFire(WeaponInfo& wi) override;
virtual void OnCeasePrimaryFire(WeaponInfo& wi) override;
virtual void OnReload(WeaponInfo& wi) override;
void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) override;
//bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) override;
private:
// State
bool m_Firing = false;
bool m_Reloading = false;
double m_ReloadTimer = 0.0;
double m_TimeSinceLastFire = 0.0;
EntityWrapper m_FirstPersonReloadImpostor;
std::random_device m_RandomDevice;
std::mt19937 m_RandomEngine;
// Weapon functions
void fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi);
bool canFire(ComponentWrapper cWeapon, WeaponInfo& wi);
bool dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi);
// Utility
//Camera cameraFromEntity(EntityWrapper camera);
void CheckBoost(ComponentWrapper cWeapon, WeaponInfo& wi);
bool hasAmmo();
void fireRound();
void spawnTracer();
float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
void playFireSound();
void playEmptySound();
void viewPunch();
void finishReload();
void playShootAnimation();
void playIdleAnimation();
void playReloadAnimation();
bool shoot(double damage);
void showHitMarker();
};
#endif
include/Game/Systems/Weapon/DefenderWeaponBehaviour.h
+24 -15
View File
@@ -1,7 +1,12 @@
#ifndef DefenderWeaponBehaviour_h__
#define DefenderWeaponBehaviour_h__
#include "WeaponBehaviour.h"
#include "Collision/Collision.h"
#include "Core/EPlayerDamage.h"
#include "Rendering/ESetCamera.h"
#include "Sound/EPlaySoundOnEntity.h"
#include "Sound/EPlaySoundOnEntity.h"
#include <glm/gtx/vector_angle.hpp>
class DefenderWeaponBehaviour : public WeaponBehaviour<DefenderWeaponBehaviour>
{
@@ -10,29 +15,33 @@ public:
: System(systemParams)
, WeaponBehaviour(systemParams, "DefenderWeapon", renderer, collisionOctree)
, m_RandomEngine(m_RandomDevice())
{
EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &DefenderWeaponBehaviour::OnSetCamera);
}
{ }
void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
void UpdateWeapon(WeaponInfo& wi, double dt) override;
void OnPrimaryFire(WeaponInfo& wi) override;
void OnCeasePrimaryFire(WeaponInfo& wi) override;
bool OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e) override;
void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) override;
bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) override;
void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) override;
private:
std::random_device m_RandomDevice;
std::mt19937 m_RandomEngine;
EntityWrapper m_CurrentCamera;
EventRelay<DefenderWeaponBehaviour, Events::SetCamera> m_ESetCamera;
bool OnSetCamera(const Events::SetCamera& e);
// Weapon functions
void fireShell(WeaponInfo& wi);
void dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage);
void fireShell(ComponentWrapper cWeapon, WeaponInfo& wi);
void dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi, const std::vector<glm::vec2>& pattern);
void spawnTracers(ComponentWrapper cWeapon, WeaponInfo& wi, std::vector<glm::vec2> pattern);
bool canFire(ComponentWrapper cWeapon, WeaponInfo& wi);
// Utility
float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
Camera cameraFromEntity(EntityWrapper camera);
};
void CheckBoost(ComponentWrapper cWeapon, WeaponInfo& wi);
};
#endif
include/Game/Systems/Weapon/SidearmWeaponBehaviour.h
+51
View File
@@ -0,0 +1,51 @@
#ifndef SidearmWeaponBehaviour_h__
#define SidearmWeaponBehaviour_h__
#include "WeaponBehaviour.h"
#include "Collision/Collision.h"
#include "Core/EPlayerDamage.h"
#include "Sound/EPlaySoundOnEntity.h"
#include "Rendering/EAutoAnimationBlend.h"
class SidearmWeaponBehaviour : public WeaponBehaviour<SidearmWeaponBehaviour>
{
public:
SidearmWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
: System(systemParams)
, WeaponBehaviour(systemParams, "SidearmWeapon", renderer, collisionOctree)
, m_RandomEngine(m_RandomDevice())
{ }
void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) override;
void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) override;
private:
std::random_device m_RandomDevice;
std::mt19937 m_RandomEngine;
// Weapon functions
void fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi);
//void dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage);
// Utility
bool canFire(ComponentWrapper cWeapon);
bool playerInFirstPerson(EntityWrapper player);
bool dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi);
// void giveAmmo(ComponentWrapper cWeapon, WeaponInfo& wi, EntityWrapper receiver);
void spawnTracer(ComponentWrapper cWeapon, WeaponInfo& wi);
void CheckAmmo(ComponentWrapper cWeapon, WeaponInfo& wi);
void RemoveFrindlyAmmoHUD(WeaponInfo& wi);
//float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
};
#endif
include/Game/Systems/Weapon/WeaponBehaviour.h
+192 -35
View File
@@ -7,6 +7,9 @@
#include "Collision/EntityAABB.h"
#include "Input/EInputCommand.h"
#include "Systems/SpawnerSystem.h"
#include "Rendering/ESetCamera.h"
#include "Core/ConfigFile.h"
#include "Rendering/EAutoAnimationBlend.h"
template <typename ETYPE>
class WeaponBehaviour : public PureSystem
@@ -20,42 +23,159 @@ public:
, m_Renderer(renderer)
, m_CollisionOctree(collisionOctree)
{
EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponBehaviour::_OnInputCommand)
EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponBehaviour::_OnInputCommand);
EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &WeaponBehaviour::_OnSetCamera);
auto config = ResourceManager::Load<ConfigFile>("Config.ini");
m_ConfigAutoReload = config->Get<bool>("Gameplay.AutoReload", true);
}
virtual ~WeaponBehaviour() = default;
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override
{
/* EntityWrapper firstPersonWeapon = entity.FirstChildByName("Hands").FirstChildByName("AssaultWeapon");
EntityWrapper thirdPersonWeapon = entity.FirstChildByName("PlayerModel").FirstChildByName("AssaultWeapon");
if (IsClient && (firstPersonWeapon.Valid() || thirdPersonWeapon.Valid())) {
if (m_ActiveWeapons.count(entity) == 0) {
WeaponInfo& wi = m_ActiveWeapons[entity];
wi.Player = entity;
wi.WeaponEntity = entity;
wi.FirstPersonEntity = firstPersonWeapon;
wi.ThirdPersonEntity = thirdPersonWeapon;
OnEquip(cWeapon, wi);
}
}*/
auto weapon = getActiveWeapon(entity);
if (!weapon) {
return;
} else {
UpdateWeapon(*weapon, dt);
UpdateWeapon(cWeapon, *weapon, dt);
}
}
protected:
struct WeaponInfo
{
std::string WeaponComponent;
EntityWrapper Player;
EntityWrapper WeaponEntity;
EntityWrapper FirstPersonEntity;
EntityWrapper FirstPersonPlayerModel;
EntityWrapper ThirdPersonEntity;
ComponentWrapper GetComponent() { return WeaponEntity[WeaponComponent]; }
EntityWrapper ThirdPersonPlayerModel;
};
IRenderer* m_Renderer;
EntityWrapper m_CurrentCamera;
Octree<EntityAABB>* m_CollisionOctree;
std::unordered_map<EntityWrapper, WeaponInfo> m_ActiveWeapons;
bool m_ConfigAutoReload;
virtual void UpdateWeapon(WeaponInfo& wi, double dt) { }
virtual void OnPrimaryFire(WeaponInfo& wi) { }
virtual void OnCeasePrimaryFire(WeaponInfo& wi) { }
virtual void OnReload(WeaponInfo& wi) { }
virtual bool OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e) { return false; }
virtual void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) { }
virtual void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) { }
virtual void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) { }
virtual void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) { }
virtual void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) { }
virtual void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) { }
virtual bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) { return false; }
bool isPlayerInFirstPerson(EntityWrapper player)
{
if (!m_CurrentCamera.Valid()) {
return false;
} else {
return m_CurrentCamera == player || m_CurrentCamera.IsChildOf(player);
}
}
// Returns wi.FirstPersonEntity or wi.ThirdPersonEntity depending on
// if the player is in first person mode or not.
EntityWrapper getRelevantWeaponEntity(WeaponInfo& wi)
{
if (isPlayerInFirstPerson(wi.Player)) {
return wi.FirstPersonEntity;
} else {
return wi.ThirdPersonEntity;
}
}
float traceRayDistance(glm::vec3 origin, glm::vec3 direction)
{
float distance;
glm::vec3 pos;
auto entity = Collision::EntityFirstHitByRay(Ray(origin, direction), m_CollisionOctree, distance, pos);
if (entity) {
return distance;
} else {
return 100.f;
}
}
void playAnimation(EntityWrapper weaponModelEntity, const std::string& subTreeName, const std::string& animationNodeName)
{
EntityWrapper root = weaponModelEntity.FirstParentWithComponent("Model");
if (!root.Valid()) {
return;
}
EntityWrapper subTree = root.FirstChildByName(subTreeName);
if (!subTree.Valid()) {
return;
}
EntityWrapper animationNode = subTree.FirstChildByName(animationNodeName);
if (!animationNode.Valid()) {
return;
}
Events::AutoAnimationBlend eFireBlend;
eFireBlend.RootNode = root;
eFireBlend.NodeName = animationNodeName;
eFireBlend.Restart = true;
eFireBlend.Start = true;
m_EventBroker->Publish(eFireBlend);
}
void playAnimationAndReturn(EntityWrapper weaponModelEntity, const std::string& subTreeName, const std::string& animationNodeName)
{
EntityWrapper root = weaponModelEntity;
if (!root.Valid()) {
return;
}
EntityWrapper subTree = root.FirstChildByName(subTreeName);
if (!subTree.Valid()) {
return;
}
EntityWrapper animationNode = subTree.FirstChildByName(animationNodeName);
if (!animationNode.Valid()) {
return;
}
Events::AutoAnimationBlend eFireBlend;
eFireBlend.RootNode = root;
eFireBlend.NodeName = animationNodeName;
eFireBlend.Restart = true;
eFireBlend.Start = true;
m_EventBroker->Publish(eFireBlend);
Events::AutoAnimationBlend eIdleBlend;
eIdleBlend.RootNode = root;
eIdleBlend.NodeName = "Idle";
eIdleBlend.AnimationEntity = animationNode;
eIdleBlend.Delay = -0.2;
eIdleBlend.Duration = 0.2;
m_EventBroker->Publish(eIdleBlend);
}
private:
EventRelay<ETYPE, Events::SetCamera> m_ESetCamera;
bool _OnSetCamera(const Events::SetCamera& e)
{
m_CurrentCamera = e.CameraEntity;
return true;
}
EventRelay<ETYPE, Events::InputCommand> m_EInputCommand;
bool _OnInputCommand(const Events::InputCommand& e)
{
@@ -70,15 +190,19 @@ private:
}
// Make sure the player has this weapon
auto weapon = getWeaponComponent(player);
if (!weapon) {
auto cWeapon = getWeaponComponent(player);
if (!cWeapon) {
return false;
}
// Weapon selection
if (e.Command == "SelectWeapon") {
if (static_cast<ComponentInfo::EnumType>(e.Value) == static_cast<ComponentInfo::EnumType>((*weapon)["Slot"])) {
selectWeapon(player);
if (e.Value > 0) {
if (static_cast<ComponentInfo::EnumType>(e.Value) == static_cast<ComponentInfo::EnumType>((*cWeapon)["Slot"])) {
selectWeapon(*cWeapon, player);
} else {
holsterWeapon(*cWeapon, player);
}
}
}
@@ -91,18 +215,18 @@ private:
// Fire
if (e.Command == "PrimaryFire") {
if (e.Value > 0) {
OnPrimaryFire(*activeWeapon);
OnPrimaryFire(*cWeapon, *activeWeapon);
} else {
OnCeasePrimaryFire(*activeWeapon);
OnCeasePrimaryFire(*cWeapon, *activeWeapon);
}
}
// Reload
if (e.Command == "Reload" && e.Value != 0) {
OnReload(*activeWeapon);
OnReload(*cWeapon, *activeWeapon);
}
return OnInputCommand(*activeWeapon, e);
return OnInputCommand(*cWeapon, *activeWeapon, e);
}
boost::optional<ComponentWrapper> getWeaponComponent(EntityWrapper player)
@@ -129,15 +253,25 @@ private:
return activeWeapon;
}
void selectWeapon(EntityWrapper player)
void selectWeapon(ComponentWrapper cWeapon, EntityWrapper player)
{
//if (!IsServer) {
// return;
//}
// Don't reselect weapon if it's already active
if (getActiveWeapon(player)) {
return;
}
// Find the weapon attachments matching the weapon type
std::vector<EntityWrapper> weaponAttachments = player.ChildrenWithComponent("WeaponAttachment");
EntityWrapper firstPersonAttachment;
EntityWrapper thirdPersonAttachment;
for (auto& attachment : weaponAttachments) {
ComponentWrapper cWeaponAttachment = attachment["WeaponAttachment"];
if ((std::string&)cWeaponAttachment["Weapon"] == m_ComponentType) {
Field<std::string> weaponType = cWeaponAttachment["Weapon"];
if (*weaponType == m_ComponentType) {
ComponentWrapper::SubscriptProxy person = cWeaponAttachment["Person"];
if ((ComponentInfo::EnumType)person == person.Enum("FirstPerson")) {
firstPersonAttachment = attachment;
@@ -152,29 +286,52 @@ private:
return;
}
// Purge other weapon entities
for (auto& attachment : weaponAttachments) {
//if (attachment == firstPersonAttachment || attachment == thirdPersonAttachment) {
// continue;
//}
attachment.DeleteChildren();
}
// Spawn the weapon(s)
EntityWrapper firstPersonWeapon;
EntityWrapper thirdPersonWeapon;
if (firstPersonAttachment.Valid()) {
firstPersonWeapon = SpawnerSystem::Spawn(firstPersonAttachment, firstPersonAttachment);
if (IsClient) {
if (firstPersonAttachment.Valid()) {
firstPersonWeapon = SpawnerSystem::Spawn(firstPersonAttachment, firstPersonAttachment);
}
}
if (thirdPersonAttachment.Valid()) {
thirdPersonWeapon = SpawnerSystem::Spawn(thirdPersonAttachment, thirdPersonAttachment);
}
m_ActiveWeapons[player].WeaponComponent = m_ComponentType;
m_ActiveWeapons[player].Player = player;
m_ActiveWeapons[player].WeaponEntity = player;
m_ActiveWeapons[player].FirstPersonEntity = firstPersonWeapon;
m_ActiveWeapons[player].ThirdPersonEntity = thirdPersonWeapon;
WeaponInfo& wi = m_ActiveWeapons[player];
wi.Player = player;
wi.WeaponEntity = player;
wi.FirstPersonEntity = firstPersonWeapon;
wi.FirstPersonPlayerModel = firstPersonWeapon;
wi.ThirdPersonEntity = thirdPersonWeapon;
wi.ThirdPersonPlayerModel = thirdPersonWeapon.FirstParentWithComponent("Model");
player["Player"]["CurrentWeapon"] = cWeapon.Info.Name;
OnEquip(cWeapon, wi);
}
void holsterWeapon(ComponentWrapper cWeapon, EntityWrapper player)
{
auto activeWeapon = getActiveWeapon(player);
if (!activeWeapon) {
return;
}
WeaponInfo& wi = *activeWeapon;
// Send holster event
OnHolster(cWeapon, wi);
// Delete weapon entities
if (wi.FirstPersonEntity.Valid()) {
m_World->DeleteEntity(wi.FirstPersonEntity.ID);
}
if (wi.ThirdPersonEntity.Valid()) {
m_World->DeleteEntity(wi.ThirdPersonEntity.ID);
}
// Make weapon inactive
m_ActiveWeapons.erase(player);
}
};
include/Game/Systems/Weapon/WeaponSystem.h
+2 -2
View File
@@ -9,8 +9,8 @@
#include "Core/EShoot.h"
#include "Core/EPlayerSpawned.h"
#include "Input/EInputCommand.h"
#include "Core/EntityFile.h"
#include "Core/EntityFileParser.h"
#include "Core/EntityXMLFile.h"
#include "Core/EntityXMLFileParser.h"
#include "Core/Octree.h"
#include "Collision/EntityAABB.h"
#include "Systems/SpawnerSystem.h"