Add team-based color and logic to player and enemy

Introduces EnemyTeam to PlayerEntity and PlayerController, passing team as a constructor argument. EnemySpawner now takes a team and applies team-based coloring to its materials. PlayerController sets material colors based on team. Enemy AI now checks team before targeting players. Map spawner logic assigns teams to spawners. Also fixes texture cleanup and cached texture removal in GfxTexture2d destructor.

Author: UntitledOutput

src/brl/gfx/texture.cpp

@@ -136,7 +136,21 @@ brl::GfxTexture2d* brl::GfxTexture2d::getWhiteTexture()
 brl::GfxTexture2d::~GfxTexture2d()
 {
     GfxTexture::~GfxTexture();
-    delete[] pixels;
+    if (pixels)
+    {
+
+        delete[] pixels;
+        pixels = nullptr;
+    }
+    for (const auto& cached_texture : cachedTextures)
+    {
+        if (cached_texture.second == this)
+        {
+            cachedTextures.erase(std::find(cachedTextures.begin(), cachedTextures.end(), cached_texture));
+            break;
+        }
+    }
+
 }
 
 brl::GfxTexture2dArray::GfxTexture2dArray(Color32* pixels, int width, int height, int layerCount)

test/include/enemy.h

@@ -52,7 +52,7 @@ struct EnemyController : ActorBehaviour
 
 struct EnemySpawner : ActorBehaviour
 {
-    EnemySpawner();
+    EnemySpawner(EnemyTeam team);
     void start() override;
     void update() override;
 

test/include/player.h

@@ -7,26 +7,31 @@
 #include "borealis/gfx/sprite.hpp"
 #include "borealis/util/input.hpp"
 
+enum EnemyTeam : int;
+
 struct PlayerEntity : ActorBehaviour
 {
     PlayerEntity();
 
     void handleAttack(glm::vec3 dir, float power) override;
 
     bool isGuarding = false;
+    EnemyTeam Team;
+
 
     static std::vector<PlayerEntity*> cachedEntities;
 };
 
 struct PlayerController : PlayerEntity
 {
 
-    PlayerController();
+    PlayerController(EnemyTeam team);
     void update() override;
     void handleAttack(glm::vec3 dir, float power) override;
 
     brl::GfxImage* healthBarImage;
 
+
 private:
     brl::GfxMaterial* material = nullptr;
     brl::GfxMeshRenderer* renderer;

test/src/enemy.cpp

@@ -123,7 +123,7 @@ void EnemyController::update()
 
         float distance = glm::distance(pos, position());
 
-        if (distance < 7.5f)
+        if (distance < 7.5f && cachedEntity->Team != Team)
         {
             playerEntity = cachedEntity;
             entityPosition = pos;
@@ -281,7 +281,7 @@ brl::UtilCoroutine EnemyController::DeathCoroutine()
 
 }
 
-EnemySpawner::EnemySpawner()
+EnemySpawner::EnemySpawner(EnemyTeam t)
 {
     auto tower = brl::GfxModel::loadModel("models/tower/tower.glb");
 
@@ -291,33 +291,44 @@ EnemySpawner::EnemySpawner()
     shaderBins[1] = new brl::GfxShader(GL_FRAGMENT_SHADER, brl::readFileString("shaders/map_object/frg.glsl"));
     auto shader = new brl::GfxShaderProgram(shaderBins, 2, true);
 
-    team = (EnemyTeam)brl::random(0, 3);
+    team = t;
+
+    auto color = glm::vec3{0};
+    switch (team)
+    {
+
+        case Red:
+            color = glm::vec3(212, 28, 64);
+            break;
+        case Blue:
+            color = glm::vec3(66, 93, 245);
+            break;
+        case Yellow:
+            color = glm::vec3(245, 188, 66);
+            break;
+        case Black:
+            color = glm::vec3(28, 36, 48);
+            break;
+    }
 
     for (auto material : tower->materials)
     {
         material->reloadShader(shader);
-        auto color = glm::vec3{0};
-        switch (team)
-        {
-
-            case Red:
-                color = glm::vec3(212, 28, 64);
-                break;
-            case Blue:
-                color = glm::vec3(66, 93, 245);
-                break;
-            case Yellow:
-                color = glm::vec3(245, 188, 66);
-                break;
-            case Black:
-                color = glm::vec3(28, 36, 48);
-                break;
-        }
         material->setVec3("_color", color);
     }
 
     const auto& towerEntity = tower->createEntity();
 
+    auto renderer = towerEntity->getEntityInChildren<brl::GfxMeshRenderer>();
+    for (int i = 0; i < renderer->materials.size(); ++i)
+    {
+        auto material = new brl::GfxMaterial(*renderer->materials[i]);
+        material->reloadShader(shader);
+        material->setVec3("_color", color);
+
+        renderer->materials[i] = material;
+    }
+
     towerEntity->setEulerAngles({0, 180, 0});
     towerEntity->localScale = glm::vec3(1.0f);
 

test/src/main.cpp

@@ -63,10 +63,10 @@ int main(int argc, const char* argv[])
 
     map->loadMap();
 
-    auto player = new PlayerController();
+    auto player = new PlayerController(Red);
     player->healthBarImage = healthBar;
 
-    auto enemy = new EnemySpawner();
+    auto enemy = new EnemySpawner(Red);
     enemy->localPosition = {0, 0, -20};
 
 

test/src/map.cpp

@@ -2,6 +2,7 @@
 #include "FastNoiseLite.h"
 #include "enemy.h"
 #include "borealis/util/random.hpp"
+#include "glm/gtx/integer.hpp"
 
 MapObject::MapObject(brl::GfxMeshRenderer* renderer)
 {
@@ -353,15 +354,15 @@ void MapController::loadMap()
 
     // place spawners
 
-    int spawnersMax = 5;
+    int spawnersMax = 6;
     int spawnerCount = 0;
     for (int x = 0; x < chunkCountX*MAP_CHUNK_SIZE; ++x)
     {
         for (int y = 0; y < chunkCountY * MAP_CHUNK_SIZE; ++y)
         {
             if (brl::random(0, 1000) >= 999)
             {
-                auto enemySpawner = new EnemySpawner();
+                auto enemySpawner = new EnemySpawner((EnemyTeam)glm::mod(spawnerCount,4));
 
                 auto blockX = (x * MAP_BLOCK_SPACING) - ((chunkCountX*MAP_CHUNK_SIZE) / 2);
                 ;

test/src/player.cpp

@@ -14,32 +14,55 @@ void PlayerEntity::handleAttack(glm::vec3 dir, float power)
 {
 }
 
-PlayerController::PlayerController()
+PlayerController::PlayerController(EnemyTeam team)
 {
+    Team = team;
+    std::string unitFolder = "textures/Units/NonColor Units/";
 
-    auto texture = brl::GfxTexture2d::loadTexture("textures/Units/Yellow Units/Warrior/Warrior_Idle.png");
-    auto walkTexture = brl::GfxTexture2d::loadTexture("textures/Units/Yellow Units/Warrior/Warrior_Run.png");
-    auto attackTexture = brl::GfxTexture2d::loadTexture("textures/Units/Yellow Units/Warrior/Warrior_Attack1.png");
-    auto guardTexture = brl::GfxTexture2d::loadTexture("textures/Units/Yellow Units/Warrior/Warrior_Guard.png");
+    auto texture = brl::GfxTexture2d::loadTexture(unitFolder + "Warrior/Warrior_Idle.png");
+    auto walkTexture = brl::GfxTexture2d::loadTexture(unitFolder + "Warrior/Warrior_Run.png");
+    auto attackTexture = brl::GfxTexture2d::loadTexture(unitFolder + "Warrior/Warrior_Attack1.png");
+    auto guardTexture = brl::GfxTexture2d::loadTexture(unitFolder + "Warrior/Warrior_Guard.png");
     idleSprites = brl::GfxSprite::extractSpritesToArray(texture, 192, 192, true);
     walkSprites = brl::GfxSprite::extractSpritesToArray(walkTexture, 192, 192, true);
     attackSprites = brl::GfxSprite::extractSpritesToArray(attackTexture, 192, 192, true);
     guardSprites = brl::GfxSprite::extractSpritesToArray(guardTexture, 192, 192, true);
 
+
     auto shaderBins = new brl::GfxShader*[2];
 
-    shaderBins[0] = new brl::GfxShader(GL_VERTEX_SHADER, brl::readFileString("shaders/test/vtx.glsl"));
-    shaderBins[1] = new brl::GfxShader(GL_FRAGMENT_SHADER, brl::readFileString("shaders/test/frg.glsl"));
+    shaderBins[0] = new brl::GfxShader(GL_VERTEX_SHADER, brl::readFileString("shaders/enemy/enemy.vert"));
+    shaderBins[1] = new brl::GfxShader(GL_FRAGMENT_SHADER, brl::readFileString("shaders/enemy/enemy.frag"));
     auto shader = new brl::GfxShaderProgram(shaderBins, 2, true);
 
-
     material = new brl::GfxMaterial(shader);
     // material->setVec3("color", brl::vector3{1,0,0});
     material->setTexture("idleSprite", idleSprites);
     material->setTexture("walkSprite", walkSprites);
     material->setTexture("attackSprite", attackSprites);
     material->setTexture("guardSprite", guardSprites);
 
+    glm::vec3 v;
+    switch (Team)
+    {
+
+        case Red:
+            v = glm::vec3(212, 28, 64);
+            break;
+        case Blue:
+            v = glm::vec3(66, 93, 245);
+            break;
+        case Yellow:
+            v = glm::vec3(245, 188, 66);
+            break;
+        case Black:
+            v = glm::vec3(28, 36, 48);
+            break;
+    }
+    material->setVec3("_color", v);
+    material->setVec3("_armorColor", glm::vec3(239, 225, 171));
+    material->setVec3("_weaponColor", glm::vec3(212, 237, 194));
+
     renderer = new brl::GfxMeshRenderer();
     renderer->mesh = brl::GfxMesh::GetPrimitive(brl::QUAD);
     renderer->setMaterial(material);