Persson-dev/Tower-Defense
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

feat: implement shapes for entities

Browse Source
This commit is contained in:
Simon Pribylski
2021-11-21 20:00:35 +01:00
parent a716e46c64
commit 070749e685
11 changed files with 92 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
include/game/Mobs.h
View File

@@ -2,6 +2,7 @@
#include "Towers.h" #include "Towers.h"
#include "Types.h" #include "Types.h"
#include "Team.h"
#include <vector> #include <vector>
#include <memory> #include <memory>
@@ -75,7 +76,7 @@ const MobStats* getMobStats(MobType type, std::uint8_t level);
const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level); const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level);
const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level); const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level);
class Mob { class Mob : public utils::shape::Rectangle{
protected: protected:
float m_Health; float m_Health;
private: private:
@@ -84,13 +85,12 @@ private:
MobLevel m_Level; MobLevel m_Level;
Direction m_Direction; Direction m_Direction;
std::vector<EffectDuration> m_Effects; std::vector<EffectDuration> m_Effects;
const Tower* m_LastDamage; // the tower that damaged the mob const Tower* m_LastDamage; // the last tower that damaged the mob
utils::Timer m_EffectFireTimer; utils::Timer m_EffectFireTimer;
utils::Timer m_EffectPoisonTimer; utils::Timer m_EffectPoisonTimer;
utils::Timer m_EffectHealTimer; utils::Timer m_EffectHealTimer;
float m_X = 0, m_Y = 0;
public: public:
Mob(MobID id, MobLevel level, PlayerID sender) : m_Sender(sender), m_Level(level), Mob(MobID id, MobLevel level, PlayerID sender) : m_Sender(sender), m_Level(level),
m_EffectFireTimer(1000), m_EffectPoisonTimer(1000), m_EffectHealTimer(1000) { m_EffectFireTimer(1000), m_EffectPoisonTimer(1000), m_EffectHealTimer(1000) {
@@ -101,7 +101,7 @@ public:
virtual void tick(std::uint64_t delta); virtual void tick(std::uint64_t delta);
virtual void OnDeath(World* world) {} virtual bool OnDeath(World* world) { return true; }
const TowerImmunities& getTowerImmunities() const { return getMobTowerImmunities(getType(), m_Level); } const TowerImmunities& getTowerImmunities() const { return getMobTowerImmunities(getType(), m_Level); }
const EffectImmunities& getEffectImmunities() const { return getMobEffectImmunities(getType(), m_Level); } const EffectImmunities& getEffectImmunities() const { return getMobEffectImmunities(getType(), m_Level); }
@@ -116,12 +116,6 @@ public:
void damage(float dmg, const Tower* damager) { m_Health = std::max(0.0f, m_Health - dmg); m_LastDamage = damager; } void damage(float dmg, const Tower* damager) { m_Health = std::max(0.0f, m_Health - dmg); m_LastDamage = damager; }
void heal(float heal) { m_Health = std::min(static_cast<float>(getStats()->getMaxLife()), m_Health + heal); } void heal(float heal) { m_Health = std::min(static_cast<float>(getStats()->getMaxLife()), m_Health + heal); }
float getX() const { return m_X; }
void setX(float x) { m_X = x; }
float getY() const { return m_Y; }
void setY(float y) { m_Y = y; }
bool isImmuneTo(TowerType type); bool isImmuneTo(TowerType type);
bool isImmuneTo(EffectType type); bool isImmuneTo(EffectType type);

33
include/game/Team.h
View File

@@ -2,6 +2,8 @@
#include "Types.h" #include "Types.h"
#include "misc/Shapes.h"
#include <vector> #include <vector>
#include <memory> #include <memory>
#include <cmath> #include <cmath>
@@ -17,14 +19,33 @@ enum class TeamColor : std::int8_t {
Blue Blue
}; };
struct Spawn { class Spawn : public utils::shape::Rectangle {
Direction direction; private:
std::int32_t x, y; Direction m_Direction;
public:
Spawn(){
setWidth(5);
setHeight(5);
}
Direction getDirection() const { return m_Direction; }
void setDirection(Direction direction) { m_Direction = direction; }
}; };
struct TeamCastle { struct TeamCastle : public utils::shape::Rectangle{
std::int32_t x, y; private:
std::uint16_t life = 1000; float m_Life;
public:
TeamCastle() : m_Life(1000) {
setWidth(5);
setHeight(5);
}
float getLife() const { return m_Life; }
void setLife(float life) { m_Life = life; }
void damage(float damage) { m_Life = std::max(0.0f, m_Life - damage); }
}; };
class Team { class Team {

9
include/game/Towers.h
View File

@@ -5,6 +5,8 @@
#include <memory> #include <memory>
#include "misc/Time.h" #include "misc/Time.h"
#include "misc/Shapes.h"
#include "game/Types.h" #include "game/Types.h"
namespace td { namespace td {
@@ -85,17 +87,16 @@ const TowerStats* getTowerStats(TowerType type, TowerLevel level);
typedef std::uint16_t TowerID; typedef std::uint16_t TowerID;
class Tower { class Tower : public utils::shape::Point {
private: private:
TowerID m_ID; TowerID m_ID;
TowerType m_Type; TowerType m_Type;
std::int32_t m_X, m_Y;
TowerLevel m_Level{}; TowerLevel m_Level{};
PlayerID m_Builder; PlayerID m_Builder;
protected: protected:
utils::CooldownTimer m_Timer; utils::CooldownTimer m_Timer;
public: public:
Tower(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) : m_ID(id), m_Type(type), m_X(x), m_Y(y), m_Builder(builder), Tower(TowerID id, TowerType type, std::int32_t x, std::int32_t y, PlayerID builder) : utils::shape::Point(x, y), m_ID(id), m_Type(type), m_Builder(builder),
m_Timer(getStats()->getDamageRate() * 1000) { // converting seconds to millis m_Timer(getStats()->getDamageRate() * 1000) { // converting seconds to millis
} }
@@ -112,8 +113,6 @@ public:
} }
std::uint16_t getID() const { return m_ID; } std::uint16_t getID() const { return m_ID; }
std::int32_t getX() const { return m_X; }
std::int32_t getY() const { return m_Y; }
const TowerLevel& getLevel() const { return m_Level; } const TowerLevel& getLevel() const { return m_Level; }
const TowerStats* getStats() const { return getTowerStats(m_Type, m_Level); } const TowerStats* getStats() const { return getTowerStats(m_Type, m_Level); }
PlayerID getBuilder() const { return m_Builder; } PlayerID getBuilder() const { return m_Builder; }

3
include/game/World.h
View File

@@ -134,6 +134,8 @@ protected:
public: public:
World(Game* game); World(Game* game);
static constexpr std::uint8_t CastleWidth = 5, CastleHeight = 5;
bool loadMap(const protocol::WorldBeginDataPacket* worldHeader); bool loadMap(const protocol::WorldBeginDataPacket* worldHeader);
bool loadMap(const protocol::WorldDataPacket* worldData); bool loadMap(const protocol::WorldDataPacket* worldData);
@@ -191,6 +193,7 @@ public:
virtual void OnArrowShot(MobPtr target, Tower* shooter); virtual void OnArrowShot(MobPtr target, Tower* shooter);
private: private:
void moveMobs(std::uint64_t delta); void moveMobs(std::uint64_t delta);
void moveMob(MobPtr mob, std::uint64_t delta);
void tickMobs(std::uint64_t delta); void tickMobs(std::uint64_t delta);
void cleanDeadMobs(); void cleanDeadMobs();
}; };

6
include/misc/Shapes.h
View File

@@ -33,6 +33,9 @@ public:
Rectangle() {} Rectangle() {}
const Point& getCenter() const { return m_Center; } const Point& getCenter() const { return m_Center; }
float getCenterX() const { return m_Center.getX(); }
float getCenterY() const { return m_Center.getY(); }
float getWidth() const { return m_Width; } float getWidth() const { return m_Width; }
float getHeight() const { return m_Height; } float getHeight() const { return m_Height; }
@@ -40,6 +43,9 @@ public:
Point getBottomRight() const { return { m_Center.getX() + (m_Width / 2.0f), m_Center.getY() + (m_Height / 2.0f) }; } Point getBottomRight() const { return { m_Center.getX() + (m_Width / 2.0f), m_Center.getY() + (m_Height / 2.0f) }; }
void setCenter(const Point& center) { m_Center = center; } void setCenter(const Point& center) { m_Center = center; }
void setCenterX(float x) { m_Center.setX(x); }
void setCenterY(float y) { m_Center.setY(y); }
void setWidth(float width) { m_Width = width; } void setWidth(float width) { m_Width = width; }
void setHeight(float height) { m_Height = height; } void setHeight(float height) { m_Height = height; }

2
src/game/Towers.cpp
View File

@@ -9,7 +9,7 @@ namespace game {
bool Tower::isMobInRange(MobPtr mob) { bool Tower::isMobInRange(MobPtr mob) {
if (mob->isDead()) if (mob->isDead())
return false; return false;
return (m_X - mob->getX()) * (m_X - mob->getX()) + (m_Y - mob->getY()) * (m_Y - mob->getY()) < (getStats()->getRange() * getStats()->getRange()); return mob->collidesWith(*this);
} }
const std::map<std::pair<TowerType, TowerLevel>, TowerStats> TowerConstants = { const std::map<std::pair<TowerType, TowerLevel>, TowerStats> TowerConstants = {

25
src/game/World.cpp
View File

@@ -111,8 +111,7 @@ void World::tick(std::uint64_t delta) {
void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir) { void World::spawnMobAt(MobID id, MobType type, std::uint8_t level, PlayerID sender, float x, float y, Direction dir) {
MobPtr mob = MobFactory::createMob(id, type, level, sender); MobPtr mob = MobFactory::createMob(id, type, level, sender);
mob->setX(x); mob->setCenter({x, y});
mob->setY(y);
mob->setDirection(dir); mob->setDirection(dir);
m_Mobs.push_back(mob); m_Mobs.push_back(mob);
} }
@@ -131,40 +130,44 @@ void World::tickMobs(std::uint64_t delta) {
void World::moveMobs(std::uint64_t delta) { void World::moveMobs(std::uint64_t delta) {
for (MobPtr mob : m_Mobs) { for (MobPtr mob : m_Mobs) {
TilePtr tile = getTile(mob->getX(), mob->getY()); TilePtr tile = getTile(mob->getCenter().getX(), mob->getCenter().getY());
if (tile != nullptr && tile->getType() == TileType::Walk) { if (tile != nullptr && tile->getType() == TileType::Walk) {
WalkableTile* walkTile = dynamic_cast<WalkableTile*>(tile.get()); WalkableTile* walkTile = dynamic_cast<WalkableTile*>(tile.get());
mob->setDirection(walkTile->direction); mob->setDirection(walkTile->direction);
} }
moveMob(mob, delta);
}
}
void World::moveMob(MobPtr mob, std::uint64_t delta) {
float mobWalkSpeed = mob->getStats()->getMovementSpeed(); float mobWalkSpeed = mob->getStats()->getMovementSpeed();
float walkAmount = mobWalkSpeed * ((float)delta / 1000.0f); float walkAmount = mobWalkSpeed * ((float)delta / 1000.0f);
if (mob->hasEffect(EffectType::Slowness)) if (mob->hasEffect(EffectType::Slowness))
walkAmount *= 0.70; walkAmount *= 0.70; // walk 30% slower
switch (mob->getDirection()) { switch (mob->getDirection()) {
case Direction::NegativeX: { case Direction::NegativeX: {
mob->setX(mob->getX() - walkAmount); mob->setCenterX(mob->getCenterX() - walkAmount);
break; break;
} }
case Direction::PositiveX: { case Direction::PositiveX: {
mob->setX(mob->getX() + walkAmount); mob->setCenterX(mob->getCenterX() + walkAmount);
break; break;
} }
case Direction::NegativeY: { case Direction::NegativeY: {
mob->setY(mob->getY() - walkAmount); mob->setCenterY(mob->getCenterY() - walkAmount);
break; break;
} }
case Direction::PositiveY: { case Direction::PositiveY: {
mob->setY(mob->getY() + walkAmount); mob->setCenterY(mob->getCenterY() + walkAmount);
break; break;
} }
} }
} }
}
const Color* World::getTileColor(TilePtr tile) const { const Color* World::getTileColor(TilePtr tile) const {
switch (tile->getType()) { switch (tile->getType()) {
@@ -245,8 +248,7 @@ void World::cleanDeadMobs() {
for (std::size_t i = 0; i < m_Mobs.size(); i++) { for (std::size_t i = 0; i < m_Mobs.size(); i++) {
MobPtr mob = m_Mobs[i]; MobPtr mob = m_Mobs[i];
if (mob->isDead()) { if (mob->isDead()) {
mob->OnDeath(this); if (mob->OnDeath(this)) {
//reward players //reward players
Player& sender = m_Game->getPlayerById(mob->getSender()); Player& sender = m_Game->getPlayerById(mob->getSender());
sender.addExp(mob->getStats()->getExpReward()); sender.addExp(mob->getStats()->getExpReward());
@@ -258,6 +260,7 @@ void World::cleanDeadMobs() {
} }
} }
} }
}
TowerPtr World::getTower(const glm::vec2& position) const { TowerPtr World::getTower(const glm::vec2& position) const {
for (TowerPtr tower : m_Towers) { for (TowerPtr tower : m_Towers) {

2
src/game/client/ClientGame.cpp
View File

@@ -103,7 +103,7 @@ void ClientGame::HandlePacket(const protocol::WorldDataPacket* packet) {
m_WorldRenderer.loadModels(); m_WorldRenderer.loadModels();
// set cam pos to player spawn // set cam pos to player spawn
const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn(); const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn();
m_WorldRenderer.setCamPos(spawn.x + 0.5, spawn.y + 0.5); m_WorldRenderer.setCamPos(spawn.getCenterX(), spawn.getCenterY());
} }
void ClientGame::renderWorld() { void ClientGame::renderWorld() {

8
src/game/server/ServerWorld.cpp
View File

@@ -22,8 +22,8 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player
enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn(); enemyMobSpawn = &getTeam(game::TeamColor::Red).getSpawn();
} }
std::int32_t spawnCenterX = enemyMobSpawn->x; std::int32_t spawnCenterX = enemyMobSpawn->getCenterX();
std::int32_t spawnCenterY = enemyMobSpawn->y; std::int32_t spawnCenterY = enemyMobSpawn->getCenterY();
std::int32_t minSpawnY = spawnCenterY - 2; std::int32_t minSpawnY = spawnCenterY - 2;
std::int32_t maxSpawnY = spawnCenterY + 2; std::int32_t maxSpawnY = spawnCenterY + 2;
@@ -34,9 +34,9 @@ void ServerWorld::spawnMobs(game::MobType type, std::uint8_t level, game::Player
float mobX = utils::getRandomReal<float>(minSpawnX, maxSpawnX); float mobX = utils::getRandomReal<float>(minSpawnX, maxSpawnX);
float mobY = utils::getRandomReal<float>(minSpawnY, maxSpawnY); float mobY = utils::getRandomReal<float>(minSpawnY, maxSpawnY);
spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->direction); spawnMobAt(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->getDirection());
protocol::SpawnMobPacket packet(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->direction); protocol::SpawnMobPacket packet(m_CurrentMobID, type, level, sender, mobX, mobY, enemyMobSpawn->getDirection());
m_Server->broadcastPacket(&packet); m_Server->broadcastPacket(&packet);
m_CurrentMobID++; m_CurrentMobID++;

8
src/render/WorldRenderer.cpp
View File

@@ -74,7 +74,7 @@ void WorldRenderer::renderMobs() const {
for (game::MobPtr mob : m_World->getMobList()) { for (game::MobPtr mob : m_World->getMobList()) {
Renderer::Model model; Renderer::Model model;
model.vao = m_MobVao.get(); model.vao = m_MobVao.get();
model.positon = { mob->getX(), mob->getY() }; model.positon = { mob->getCenterX(), mob->getCenterY() };
m_Renderer->renderModel(model); m_Renderer->renderModel(model);
} }
} }
@@ -235,11 +235,7 @@ void WorldRenderer::renderMobTooltip() const {
void WorldRenderer::detectMobHovering() const { void WorldRenderer::detectMobHovering() const {
glm::vec2 cursorWorldPos = getCursorWorldPos(); glm::vec2 cursorWorldPos = getCursorWorldPos();
for (game::MobPtr mob : m_World->getMobList()) { for (game::MobPtr mob : m_World->getMobList()) {
// mob size is currently 1x1 for all mobs if(mob->collidesWith({cursorWorldPos.x, cursorWorldPos.y})){
float mobCenterX = mob->getX();
float mobCenterY = mob->getY();
if (cursorWorldPos.x > mobCenterX - 0.5f && cursorWorldPos.x < mobCenterX + 0.5f
&& cursorWorldPos.y > mobCenterY - 0.5f && cursorWorldPos.y < mobCenterY + 0.5f) {
m_MobTooltip->setMob(mob.get()); m_MobTooltip->setMob(mob.get());
return; return;
} }

8
src/render/loader/WorldLoader.cpp
View File

@@ -97,8 +97,8 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
for (int spawnColor = 0; spawnColor < 2; spawnColor++) { for (int spawnColor = 0; spawnColor < 2; spawnColor++) {
const game::Spawn& spawn = world->getTeam(game::TeamColor(spawnColor)).getSpawn(); const game::Spawn& spawn = world->getTeam(game::TeamColor(spawnColor)).getSpawn();
float fromX = spawn.x - 2, toX = spawn.x + 3; float fromX = spawn.getTopLeft().getX() , toX = spawn.getBottomRight().getX();
float fromY = spawn.y - 2, toY = spawn.y + 3; float fromY = spawn.getTopLeft().getY() , toY = spawn.getBottomRight().getY();
positions.insert(positions.end(), { positions.insert(positions.end(), {
fromX, fromY, fromX, fromY,
@@ -125,8 +125,8 @@ GL::VertexArray loadWorldModel(const td::game::World* world) {
for (int castleColor = 0; castleColor < 2; castleColor++) { for (int castleColor = 0; castleColor < 2; castleColor++) {
const game::TeamCastle& castle = world->getTeam(game::TeamColor(castleColor)).getCastle(); const game::TeamCastle& castle = world->getTeam(game::TeamColor(castleColor)).getCastle();
float fromX = castle.x - 2, toX = castle.x + 3; float fromX = castle.getTopLeft().getX(), toX = castle.getBottomRight().getX();
float fromY = castle.y - 2, toY = castle.y + 3; float fromY = castle.getTopLeft().getY(), toY = castle.getBottomRight().getY();
positions.insert(positions.end(), { positions.insert(positions.end(), {
fromX, fromY, fromX, fromY,