512 lines
17 KiB
C++
512 lines
17 KiB
C++
#include "game/Mobs.h"
|
|
#include "game/Player.h"
|
|
#include "game/World.h"
|
|
|
|
#include <map>
|
|
#include <algorithm>
|
|
|
|
namespace td {
|
|
namespace game {
|
|
|
|
bool Mob::IsImmuneTo(TowerType type) {
|
|
return std::find(GetTowerImmunities().begin(), GetTowerImmunities().end(), type) != GetTowerImmunities().end();
|
|
}
|
|
|
|
bool Mob::IsImmuneTo(EffectType type) {
|
|
return std::find(GetEffectImmunities().begin(), GetEffectImmunities().end(), type) != GetEffectImmunities().end();
|
|
}
|
|
|
|
EffectDuration& Mob::GetEffect(EffectType effectType) {
|
|
return *std::find_if(m_Effects.begin(), m_Effects.end(), [&effectType](EffectDuration effect) { return effect.type == effectType;});
|
|
}
|
|
|
|
void Mob::AddEffect(EffectType effectType, float durationSec, Tower* tower) {
|
|
if (IsImmuneTo(effectType))
|
|
return;
|
|
if (HasEffect(effectType)) {
|
|
EffectDuration& effect = GetEffect(effectType);
|
|
if (effect.duration < durationSec)
|
|
effect.duration = durationSec; // Setting new duration if it's greater then the actual
|
|
} else {
|
|
m_Effects.push_back({ effectType, durationSec, tower });
|
|
}
|
|
}
|
|
|
|
void Mob::AttackCastle(std::uint64_t delta, World* world) {
|
|
if (!HasReachedEnemyCastle()) return;
|
|
|
|
if (m_AttackTimer.Update(delta)) {
|
|
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobCastleDamage, this, m_CastleTarget, GetStats()->GetDamage());
|
|
m_AttackTimer.ApplyCooldown();
|
|
}
|
|
}
|
|
|
|
void Mob::Walk(std::uint64_t delta, World* world) {
|
|
float mobWalkSpeed = GetStats()->GetMovementSpeed();
|
|
|
|
float walkAmount = mobWalkSpeed * (static_cast<float>(delta) / 1000.0f);
|
|
|
|
if (HasEffect(EffectType::Slowness))
|
|
walkAmount *= 0.70; // walk 30% slower
|
|
|
|
switch (GetDirection()) {
|
|
case Direction::NegativeX: {
|
|
SetCenterX(GetCenterX() - walkAmount);
|
|
break;
|
|
}
|
|
case Direction::PositiveX: {
|
|
SetCenterX(GetCenterX() + walkAmount);
|
|
break;
|
|
}
|
|
case Direction::NegativeY: {
|
|
SetCenterY(GetCenterY() - walkAmount);
|
|
break;
|
|
}
|
|
case Direction::PositiveY: {
|
|
SetCenterY(GetCenterY() + walkAmount);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Mob::Move(std::uint64_t delta, World* world) {
|
|
TilePtr tile = world->GetTile(GetCenter().GetX(), GetCenter().GetY());
|
|
|
|
if (tile != nullptr && tile->GetType() == TileType::Walk) {
|
|
WalkableTilePtr walkTile = std::static_pointer_cast<WalkableTile>(tile);
|
|
ChangeDirection(*walkTile, world);
|
|
}
|
|
|
|
if (HasReachedEnemyCastle()) return;
|
|
|
|
Walk(delta, world);
|
|
|
|
TeamColor mobTeam = world->GetPlayerById(GetSender())->GetTeamColor();
|
|
|
|
TeamCastle* enemyCastle = nullptr;
|
|
|
|
if (mobTeam == TeamColor::Red) {
|
|
enemyCastle = &world->GetBlueTeam().GetCastle();
|
|
} else if (mobTeam == TeamColor::Blue) {
|
|
enemyCastle = &world->GetRedTeam().GetCastle();
|
|
}
|
|
|
|
if (IsTouchingCastle(*enemyCastle)) {
|
|
MoveBack(*enemyCastle, world);
|
|
SetMobReachedCastle(enemyCastle);
|
|
|
|
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobTouchCastle, this, enemyCastle);
|
|
}
|
|
}
|
|
|
|
void Mob::MoveBack(const TeamCastle& enemyCastle, World* world) {
|
|
switch (GetDirection()) {
|
|
case Direction::NegativeX: {
|
|
SetCenterX(enemyCastle.GetBottomRight().GetX() + GetWidth() / 2.0f);
|
|
break;
|
|
}
|
|
case Direction::PositiveX: {
|
|
SetCenterX(enemyCastle.GetTopLeft().GetX() - GetWidth() / 2.0f);
|
|
break;
|
|
}
|
|
case Direction::NegativeY: {
|
|
SetCenterY(enemyCastle.GetBottomRight().GetY() + GetHeight() / 2.0f);
|
|
break;
|
|
}
|
|
case Direction::PositiveY: {
|
|
SetCenterY(enemyCastle.GetTopLeft().GetY() - GetHeight() / 2.0f);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Mob::ChangeDirection(const WalkableTile& tile, World* world) {
|
|
if (GetDirection() == tile.direction) return;
|
|
|
|
float tileX = static_cast<float>(static_cast<std::int32_t>(GetCenterX()));
|
|
float tileY = static_cast<float>(static_cast<std::int32_t>(GetCenterY()));
|
|
|
|
switch (GetDirection()) {
|
|
|
|
case Direction::PositiveY: {
|
|
if (tile.direction == Direction::NegativeX) {
|
|
if (GetTileY() > GetTileX()) {
|
|
SetCenterY(tileY + GetTileX());
|
|
SetDirection(tile.direction);
|
|
}
|
|
} else { // tile->direction = Direction::PositiveX
|
|
if (GetTileY() > 1 - GetTileX()) {
|
|
SetCenterY(tileY + (1 - GetTileX()));
|
|
SetDirection(tile.direction);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
case Direction::NegativeY: {
|
|
if (tile.direction == Direction::PositiveX) {
|
|
if (GetTileY() < GetTileX()) {
|
|
SetCenterY(tileY + GetTileX());
|
|
SetDirection(tile.direction);
|
|
}
|
|
} else { // tile.direction = Direction::NegativeX
|
|
if (GetTileY() < 1 - GetTileX()) {
|
|
SetCenterY(tileY + (1 - GetTileX()));
|
|
SetDirection(tile.direction);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
case Direction::PositiveX: {
|
|
if (tile.direction == Direction::NegativeY) {
|
|
if (GetTileX() > GetTileY()) {
|
|
SetCenterX(tileX + GetTileY());
|
|
SetDirection(tile.direction);
|
|
}
|
|
} else { // tile.direction = Direction::PositiveY
|
|
if (GetTileX() > 1 - GetTileY()) {
|
|
SetCenterX(tileX + (1 - GetTileY()));
|
|
SetDirection(tile.direction);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
case Direction::NegativeX: {
|
|
if (tile.direction == Direction::PositiveY) {
|
|
if (GetTileX() < GetTileY()) {
|
|
SetCenterX(tileX + GetTileY());
|
|
SetDirection(tile.direction);
|
|
}
|
|
} else { // tile.direction = Direction::NegativeY
|
|
if (GetTileX() < 1 - GetTileY()) {
|
|
SetCenterX(tileX + (1 - GetTileY()));
|
|
SetDirection(tile.direction);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
bool Mob::IsTouchingCastle(const TeamCastle& enemyCastle) const {
|
|
return enemyCastle.CollidesWith(*this);
|
|
}
|
|
|
|
void Mob::Tick(std::uint64_t delta, World* world) {
|
|
m_HitCooldown = std::max(0.0f, m_HitCooldown - static_cast<float>(delta / 1000.0f));
|
|
UpdateEffects(delta, world);
|
|
Move(delta, world);
|
|
AttackCastle(delta, world);
|
|
}
|
|
|
|
void Mob::UpdateEffects(std::uint64_t delta, World* world) {
|
|
float deltaSec = static_cast<float>(delta / 1000.0f);
|
|
for (std::size_t i = 0; i < m_Effects.size(); i++) {
|
|
EffectDuration& effect = m_Effects[i];
|
|
effect.duration -= deltaSec;
|
|
if (effect.duration < 0) { // effect has gone
|
|
m_Effects.erase(m_Effects.begin() + static_cast<int>(i));
|
|
switch (effect.type) {
|
|
case EffectType::Fire: {
|
|
m_EffectFireTimer.Reset();
|
|
break;
|
|
}
|
|
|
|
case EffectType::Poison: {
|
|
m_EffectPoisonTimer.Reset();
|
|
break;
|
|
}
|
|
|
|
case EffectType::Heal: {
|
|
m_EffectHealTimer.Reset();
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (HasEffect(EffectType::Fire)) {
|
|
if (m_EffectFireTimer.Update(delta)) {
|
|
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, this, 3.0f, GetEffect(EffectType::Fire).tower);
|
|
}
|
|
}
|
|
if (HasEffect(EffectType::Poison)) {
|
|
if (m_EffectPoisonTimer.Update(delta)) {
|
|
world->GetMobNotifier().NotifyListeners(&MobListener::OnMobDamage, this, 1.0f, GetEffect(EffectType::Poison).tower);
|
|
}
|
|
}
|
|
if (HasEffect(EffectType::Heal)) {
|
|
if (m_EffectFireTimer.Update(delta)) {
|
|
Heal(10);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Mob::HasEffect(EffectType type) {
|
|
return std::find_if(m_Effects.begin(), m_Effects.end(), [&type](EffectDuration effect) { return effect.type == type;}) != m_Effects.end();
|
|
}
|
|
|
|
|
|
|
|
|
|
typedef std::pair<MobType, std::uint8_t> MobKey;
|
|
|
|
static const std::map<MobKey, MobStats> MobConstants = {
|
|
// damage speed size money_cost exp_cost exp_reward max_health
|
|
{{MobType::Zombie, 1},{MobStats{1, 1.6, {1, 1}, 15, 0, 7, 40}}},
|
|
{{MobType::Zombie, 2},{MobStats{1, 1.6, {1, 1}, 18, 88, 9, 56}}},
|
|
{{MobType::Zombie, 3},{MobStats{1, 1.6, {1, 1}, 22, 153, 10, 78}}},
|
|
{{MobType::Zombie, 4},{MobStats{1.5, 1.6, {1, 1}, 26, 268, 13, 110}}},
|
|
{{MobType::Zombie, 5},{MobStats{2, 1.6, {1, 1}, 31, 469, 15, 154}}},
|
|
|
|
{{MobType::Spider, 1},{MobStats{1, 1.6, {1, 1}, 25, 100, 15, 80}}},
|
|
{{MobType::Spider, 2},{MobStats{1, 2, {1, 1}, 30, 175, 16, 112}}},
|
|
{{MobType::Spider, 3},{MobStats{1.5, 2, {1, 1}, 36, 306, 18, 157}}},
|
|
{{MobType::Spider, 4},{MobStats{2.5, 2, {1, 1}, 43, 536, 19, 222}}},
|
|
{{MobType::Spider, 5},{MobStats{1.5, 2.5, {1, 1}, 52, 938, 22, 307}}},
|
|
|
|
{{MobType::Skeleton, 1},{MobStats{1, 1.6, {1, 1}, 120, 200, 30, 350}}},
|
|
{{MobType::Skeleton, 2},{MobStats{1, 1.6, {1, 1}, 144, 350, 33, 490}}},
|
|
{{MobType::Skeleton, 3},{MobStats{1, 1.6, {1, 1}, 173, 613, 36, 686}}},
|
|
{{MobType::Skeleton, 4},{MobStats{1.5, 1.6, {1, 1}, 225, 1072, 40, 960}}},
|
|
{{MobType::Skeleton, 5},{MobStats{2, 1.6, {1, 1}, 255, 1876, 43, 1345}}},
|
|
|
|
{{MobType::Pigman, 1},{MobStats{1, 2, {1, 1}, 100, 150, 22, 150}}},
|
|
{{MobType::Pigman, 2},{MobStats{1, 2, {1, 1}, 120, 263, 24, 210}}},
|
|
{{MobType::Pigman, 3},{MobStats{1, 2, {1, 1}, 144, 459, 25, 297}}},
|
|
{{MobType::Pigman, 4},{MobStats{1, 2, {1, 1}, 173, 804, 25, 412}}},
|
|
{{MobType::Pigman, 5},{MobStats{1.5, 2, {1, 1}, 207, 1407, 27, 576}}},
|
|
|
|
{{MobType::Creeper, 1},{MobStats{1, 2, {1, 1}, 250, 325, 46, 350}}},
|
|
{{MobType::Creeper, 2},{MobStats{1, 2, {1, 1}, 290, 550, 49, 460}}},
|
|
{{MobType::Creeper, 3},{MobStats{2, 2, {1, 1}, 350, 800, 55, 630}}},
|
|
{{MobType::Creeper, 4},{MobStats{3, 2, {1, 1}, 420, 1300, 61, 900}}},
|
|
{{MobType::Creeper, 5},{MobStats{4, 2, {1, 1}, 510, 1850, 67, 1250}}},
|
|
|
|
{{MobType::Silverfish, 1},{MobStats{1, 1.6, {1, 1}, 38, 125, 18, 120}}},
|
|
{{MobType::Silverfish, 2},{MobStats{1, 1.6, {1, 1}, 50, 230, 19, 170}}},
|
|
{{MobType::Silverfish, 3},{MobStats{1, 1.6, {1, 1}, 75, 340, 25, 225}}},
|
|
{{MobType::Silverfish, 4},{MobStats{1.5, 1.6, {1, 1}, 170, 700, 33, 310}}},
|
|
{{MobType::Silverfish, 5},{MobStats{1.5, 1.6, {1, 1}, 200, 1800, 36, 390}}},
|
|
|
|
{{MobType::Blaze, 1},{MobStats{1, 1.6, {1, 1}, 500, 500, 105, 410}}},
|
|
{{MobType::Blaze, 2},{MobStats{1, 1.6, {1, 1}, 600, 875, 111, 574}}},
|
|
{{MobType::Blaze, 3},{MobStats{1, 1.6, {1, 1}, 720, 1531, 115, 804}}},
|
|
{{MobType::Blaze, 4},{MobStats{1.5, 1.6, {1, 1}, 864, 2680, 121, 1125}}},
|
|
{{MobType::Blaze, 5},{MobStats{2, 1.6, {1, 1}, 1037, 4689, 127, 1575}}},
|
|
|
|
{{MobType::Witch, 1},{MobStats{1, 1.6, {1, 1}, 150, 300, 37, 300}}},
|
|
{{MobType::Witch, 2},{MobStats{1, 1.6, {1, 1}, 165, 525, 39, 405}}},
|
|
{{MobType::Witch, 3},{MobStats{1, 1.6, {1, 1}, 182, 918, 42, 547}}},
|
|
{{MobType::Witch, 4},{MobStats{1.5, 1.6, {1, 1}, 200, 1606, 43, 738}}},
|
|
{{MobType::Witch, 5},{MobStats{2, 1.6, {1, 1}, 220, 2810, 45, 996}}},
|
|
|
|
{{MobType::Slime, 1},{MobStats{1, 0.8, {1, 1}, 1500, 1000, 300, 800}}},
|
|
{{MobType::Slime, 2},{MobStats{1.5, 0.8, {1, 1}, 1800, 1750, 314, 880}}},
|
|
{{MobType::Slime, 3},{MobStats{2, 0.8, {1, 1}, 2160, 3063, 330, 968}}},
|
|
{{MobType::Slime, 4},{MobStats{2.5, 0.8, {1, 1}, 2592, 5359, 348, 1065}}},
|
|
{{MobType::Slime, 5},{MobStats{3, 0.8, {1, 1}, 3110, 9379, 366, 1171}}},
|
|
|
|
{{MobType::Giant, 1},{MobStats{10, 0.8, {1, 1}, 4000, 2250, 600, 6250}}},
|
|
{{MobType::Giant, 2},{MobStats{20, 0.8, {1, 1}, 4500, 4000, 612, 9375}}},
|
|
{{MobType::Giant, 3},{MobStats{30, 0.8, {1, 1}, 5062, 7250, 624, 14062}}},
|
|
{{MobType::Giant, 4},{MobStats{40, 0.8, {1, 1}, 5695, 12500, 636, 21093}}},
|
|
{{MobType::Giant, 5},{MobStats{50, 0.8, {1, 1}, 6407, 22000, 648, 31640}}},
|
|
};
|
|
|
|
const MobStats* GetMobStats(MobType type, std::uint8_t level) {
|
|
return &MobConstants.at(MobKey{ type, level });
|
|
}
|
|
|
|
static const std::map<MobKey, TowerImmunities> MobsTowerImmunities = {
|
|
{{MobType::Zombie, 1},{}},
|
|
{{MobType::Zombie, 2},{}},
|
|
{{MobType::Zombie, 3},{}},
|
|
{{MobType::Zombie, 4},{}},
|
|
{{MobType::Zombie, 5},{}},
|
|
|
|
{{MobType::Spider, 1},{}},
|
|
{{MobType::Spider, 2},{}},
|
|
{{MobType::Spider, 3},{}},
|
|
{{MobType::Spider, 4},{TowerType::Archer, TowerType::Artillery, TowerType::Leach, TowerType::Necromancer, TowerType::Poison, TowerType::Quake, TowerType::Sorcerer, TowerType::Turret, TowerType::Zeus}},
|
|
{{MobType::Spider, 5},{TowerType::Archer, TowerType::Artillery, TowerType::Leach, TowerType::Necromancer, TowerType::Poison, TowerType::Quake, TowerType::Sorcerer, TowerType::Turret, TowerType::Zeus}},
|
|
|
|
{{MobType::Skeleton, 1},{}},
|
|
{{MobType::Skeleton, 2},{}},
|
|
{{MobType::Skeleton, 3},{}},
|
|
{{MobType::Skeleton, 4},{}},
|
|
{{MobType::Skeleton, 5},{}},
|
|
|
|
{{MobType::Pigman, 1},{TowerType::Zeus}},
|
|
{{MobType::Pigman, 2},{TowerType::Zeus}},
|
|
{{MobType::Pigman, 3},{TowerType::Zeus}},
|
|
{{MobType::Pigman, 4},{TowerType::Zeus}},
|
|
{{MobType::Pigman, 5},{TowerType::Zeus}},
|
|
|
|
{{MobType::Creeper, 1},{}},
|
|
{{MobType::Creeper, 2},{}},
|
|
{{MobType::Creeper, 3},{}},
|
|
{{MobType::Creeper, 4},{}},
|
|
{{MobType::Creeper, 5},{}},
|
|
|
|
{{MobType::Silverfish, 1},{}},
|
|
{{MobType::Silverfish, 2},{}},
|
|
{{MobType::Silverfish, 3},{}},
|
|
{{MobType::Silverfish, 4},{}},
|
|
{{MobType::Silverfish, 5},{}},
|
|
|
|
{{MobType::Blaze, 1},{}},
|
|
{{MobType::Blaze, 2},{}},
|
|
{{MobType::Blaze, 3},{}},
|
|
{{MobType::Blaze, 4},{}},
|
|
{{MobType::Blaze, 5},{}},
|
|
|
|
{{MobType::Witch, 1},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
|
|
{{MobType::Witch, 2},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
|
|
{{MobType::Witch, 3},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
|
|
{{MobType::Witch, 4},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
|
|
{{MobType::Witch, 5},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
|
|
|
|
{{MobType::Slime, 1},{}},
|
|
{{MobType::Slime, 2},{}},
|
|
{{MobType::Slime, 3},{}},
|
|
{{MobType::Slime, 4},{}},
|
|
{{MobType::Slime, 5},{}},
|
|
|
|
{{MobType::Giant, 1},{}},
|
|
{{MobType::Giant, 2},{}},
|
|
{{MobType::Giant, 3},{}},
|
|
{{MobType::Giant, 4},{}},
|
|
{{MobType::Giant, 5},{}},
|
|
};
|
|
|
|
const TowerImmunities& GetMobTowerImmunities(MobType type, std::uint8_t level) {
|
|
return MobsTowerImmunities.at({ type, level });
|
|
}
|
|
|
|
static const std::map<MobKey, EffectImmunities> MobsEffectImmunities = {
|
|
{{MobType::Zombie, 1},{}},
|
|
{{MobType::Zombie, 2},{}},
|
|
{{MobType::Zombie, 3},{}},
|
|
{{MobType::Zombie, 4},{}},
|
|
{{MobType::Zombie, 5},{}},
|
|
|
|
{{MobType::Spider, 1},{}},
|
|
{{MobType::Spider, 2},{}},
|
|
{{MobType::Spider, 3},{}},
|
|
{{MobType::Spider, 4},{}},
|
|
{{MobType::Spider, 5},{}},
|
|
|
|
{{MobType::Skeleton, 1},{}},
|
|
{{MobType::Skeleton, 2},{}},
|
|
{{MobType::Skeleton, 3},{}},
|
|
{{MobType::Skeleton, 4},{EffectType::Fire}},
|
|
{{MobType::Skeleton, 5},{EffectType::Fire}},
|
|
|
|
{{MobType::Pigman, 1},{EffectType::Fire}},
|
|
{{MobType::Pigman, 2},{EffectType::Fire}},
|
|
{{MobType::Pigman, 3},{EffectType::Fire}},
|
|
{{MobType::Pigman, 4},{EffectType::Fire}},
|
|
{{MobType::Pigman, 5},{EffectType::Fire}},
|
|
|
|
{{MobType::Creeper, 1},{}},
|
|
{{MobType::Creeper, 2},{}},
|
|
{{MobType::Creeper, 3},{}},
|
|
{{MobType::Creeper, 4},{}},
|
|
{{MobType::Creeper, 5},{}},
|
|
|
|
{{MobType::Silverfish, 1},{}},
|
|
{{MobType::Silverfish, 2},{}},
|
|
{{MobType::Silverfish, 3},{}},
|
|
{{MobType::Silverfish, 4},{EffectType::Fire}},
|
|
{{MobType::Silverfish, 5},{EffectType::Fire}},
|
|
|
|
{{MobType::Blaze, 1},{EffectType::Fire}},
|
|
{{MobType::Blaze, 2},{EffectType::Fire}},
|
|
{{MobType::Blaze, 3},{EffectType::Fire}},
|
|
{{MobType::Blaze, 4},{EffectType::Fire}},
|
|
{{MobType::Blaze, 5},{EffectType::Fire}},
|
|
|
|
{{MobType::Witch, 1},{}},
|
|
{{MobType::Witch, 2},{}},
|
|
{{MobType::Witch, 3},{}},
|
|
{{MobType::Witch, 4},{}},
|
|
{{MobType::Witch, 5},{}},
|
|
|
|
{{MobType::Slime, 1},{}},
|
|
{{MobType::Slime, 2},{}},
|
|
{{MobType::Slime, 3},{}},
|
|
{{MobType::Slime, 4},{EffectType::Fire}},
|
|
{{MobType::Slime, 5},{EffectType::Fire}},
|
|
|
|
{{MobType::Giant, 1},{EffectType::Stun}},
|
|
{{MobType::Giant, 2},{EffectType::Stun}},
|
|
{{MobType::Giant, 3},{EffectType::Stun}},
|
|
{{MobType::Giant, 4},{EffectType::Stun}},
|
|
{{MobType::Giant, 5},{EffectType::Stun}},
|
|
};
|
|
|
|
const EffectImmunities& GetMobEffectImmunities(MobType type, std::uint8_t level) {
|
|
return MobsEffectImmunities.at({ type, level });
|
|
}
|
|
|
|
MobPtr MobFactory::CreateMob(MobID mobId, MobType mobType, std::uint8_t mobLevel, PlayerID mobSender) {
|
|
using MobCreator = std::function<std::shared_ptr<Mob>(MobID, std::uint8_t, PlayerID)>;
|
|
|
|
static const std::map<MobType, MobCreator> mobFactory = {
|
|
{MobType::Zombie, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Zombie>(id, level, sender);} },
|
|
{MobType::Spider, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Spider>(id, level, sender);} },
|
|
{MobType::Skeleton, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Skeleton>(id, level, sender);} },
|
|
{MobType::Pigman, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<PigMan>(id, level, sender);} },
|
|
{MobType::Creeper, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Creeper>(id, level, sender);} },
|
|
{MobType::Silverfish, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Silverfish>(id, level, sender);} },
|
|
{MobType::Blaze, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Blaze>(id, level, sender);} },
|
|
{MobType::Witch, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Witch>(id, level, sender);} },
|
|
{MobType::Slime, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Slime>(id, level, sender);} },
|
|
{MobType::Giant, [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Giant>(id, level, sender);} },
|
|
};
|
|
|
|
return mobFactory.at(mobType)(mobId, mobLevel, mobSender);
|
|
}
|
|
|
|
std::string MobFactory::GetMobName(MobType type) {
|
|
switch (type) {
|
|
case MobType::Zombie:
|
|
return "Zombie";
|
|
case MobType::Spider:
|
|
return "Spider";
|
|
case MobType::Skeleton:
|
|
return "Skeleton";
|
|
case MobType::Pigman:
|
|
return "Pigman";
|
|
case MobType::Creeper:
|
|
return "Creeper";
|
|
case MobType::Silverfish:
|
|
return "Silverfish";
|
|
case MobType::Blaze:
|
|
return "Blaze";
|
|
case MobType::Witch:
|
|
return "Witch";
|
|
case MobType::Slime:
|
|
return "Slime";
|
|
case MobType::Giant:
|
|
return "Giant";
|
|
default:
|
|
return "Unknow";
|
|
}
|
|
}
|
|
|
|
} // namespace game
|
|
} // namespace td
|