introduce cell events for rendering of attackes

Author: chrxh

source/Base/Resources.h

@@ -2,7 +2,7 @@
 
 namespace Const
 {
-    std::string const ProgramVersion = "4.9.1";
+    std::string const ProgramVersion = "4.10.0";
     std::string const DiscordURL = "https://discord.gg/7bjyZdXXQ2";
 
     std::string const BasePath = "resources/";

source/EngineGpuKernels/AttackerProcessor.cuh

@@ -147,7 +147,9 @@ __device__ __inline__ void AttackerProcessor::processCell(SimulationData& data,
             if (energyToTransfer > NEAR_ZERO) {
 
                 //notify attacked cell
-                atomicExch(&otherCell->activity.channels[7], AttackNotificationActivity);
+                atomicAdd(&otherCell->activity.channels[7], 1.0f);
+                otherCell->event = CellEvent_Hit;
+                otherCell->eventCounter = 6;
 
                 auto origEnergy = atomicAdd(&otherCell->energy, -energyToTransfer);
                 if (origEnergy > baseValue + energyToTransfer) {
@@ -180,6 +182,8 @@ __device__ __inline__ void AttackerProcessor::processCell(SimulationData& data,
         activity.channels[0] = energyDelta / 10;
 
         if (energyDelta > NEAR_ZERO) {
+            cell->event = CellEvent_Attacking;
+            cell->eventCounter = 6;
             statistics.incNumAttacks(cell->color);
         }
     }

source/EngineGpuKernels/CellFunctionProcessor.cuh

@@ -10,6 +10,7 @@ class CellFunctionProcessor
 {
 public:
     __inline__ __device__ static void collectCellFunctionOperations(SimulationData& data);
+    __inline__ __device__ static void updateRenderingData(SimulationData& data);
     __inline__ __device__ static void resetFetchedActivities(SimulationData& data);
 
     __inline__ __device__ static Activity calcInputActivity(Cell* cell);
@@ -47,6 +48,19 @@ __inline__ __device__ void CellFunctionProcessor::collectCellFunctionOperations(
     }
 }
 
+__inline__ __device__ void CellFunctionProcessor::updateRenderingData(SimulationData& data)
+{
+    auto& cells = data.objects.cellPointers;
+    auto partition = calcAllThreadsPartition(cells.getNumEntries());
+
+    for (int index = partition.startIndex; index <= partition.endIndex; ++index) {
+        auto& cell = cells.at(index);
+        if (cell->eventCounter > 0) {
+            --cell->eventCounter;
+        }
+    }
+}
+
 __inline__ __device__ void CellFunctionProcessor::resetFetchedActivities(SimulationData& data)
 {
     auto& cells = data.objects.cellPointers;

source/EngineGpuKernels/Object.cuh

@@ -225,6 +225,10 @@ struct Cell
     //annotations
     CellMetadataDescription metadata;
 
+    //additional rendering data
+    CellEvent event;
+    uint8_t eventCounter;
+
     //editing data
     uint8_t selected;  //0 = no, 1 = selected, 2 = cluster selected
     uint8_t detached;  //0 = no, 1 = yes

source/EngineGpuKernels/ObjectFactory.cuh

@@ -74,6 +74,8 @@ __inline__ __device__ Cell* ObjectFactory::createCellFromTO(DataTO const& dataTO
     cell->selected = 0;
     cell->scheduledOperationIndex = -1;
     cell->numConnections = cellTO.numConnections;
+    cell->event = CellEvent_No;
+    cell->eventCounter = 0;
     for (int i = 0; i < cell->numConnections; ++i) {
         auto& connectingCell = cell->connections[i];
         connectingCell.cell = cellTargetArray + cellTO.connections[i].cellIndex;
@@ -278,6 +280,8 @@ __inline__ __device__ Cell* ObjectFactory::createRandomCell(float energy, float2
     cell->creatureId = 0;
     cell->mutationId = 0;
     cell->detectedByCreatureId = 0;
+    cell->event = CellEvent_No;
+    cell->eventCounter = 0;
 
     if (cudaSimulationParameters.particleTransformationRandomCellFunction) {
         cell->cellFunction = _data->numberGen1.random(CellFunction_Count - 1);
@@ -392,5 +396,7 @@ __inline__ __device__ Cell* ObjectFactory::createCell(uint64_t& cellPointerIndex
     }
     cell->density = 1.0f;
     cell->detectedByCreatureId = 0;
+    cell->event = CellEvent_No;
+    cell->eventCounter = 0;
     return cell;
 }

source/EngineGpuKernels/RenderingKernels.cu

@@ -261,11 +261,15 @@ namespace
         if (radius2 > 2.5 - NEAR_ZERO) {
             auto radiusSquared1 = radius1 * radius1;
             auto radiusSquared2 = radius2 * radius2;
+            auto middleRadiusSquared = (radiusSquared1 + radiusSquared2) / 2;
+
             for (float x = -radius2; x <= radius2; x += 1.0f) {
                 for (float y = -radius2; y <= radius2; y += 1.0f) {
                     auto rSquared = x * x + y * y;
                     if (rSquared <= radiusSquared2 && rSquared >= radiusSquared1) {
-                        drawDot(imageData, imageSize, pos + float2{x, y}, color);
+                        auto weight = rSquared < middleRadiusSquared ? (rSquared - radiusSquared1) / (middleRadiusSquared - radiusSquared1)
+                                                                     : (radiusSquared2 - rSquared) / (radiusSquared2 - middleRadiusSquared);
+                        drawDot(imageData, imageSize, pos + float2{x, y}, color * weight * 0.6f);
                     }
                 }
             }
@@ -402,12 +406,14 @@ __global__ void cudaDrawCells(uint64_t timestep, int2 worldSize, float2 rectUppe
                 drawCircle(imageData, imageSize, cellImagePos, float3{0.3f, 0.3f, 0.3f}, radius, shadedCells);
             }
 
-            //draw attacks
-            if (cell->cellFunction == CellFunction_Attacker && abs(cell->activity.channels[0]) > NEAR_ZERO) {
-                drawDisc(imageData, imageSize, cellImagePos, {0.0f, 1.0f, 0.0f}, radius * 1.4f, radius * 2.0f);
-            }
-            if (abs(cell->activity.channels[7] - AttackNotificationActivity) < NEAR_ZERO) {
-                drawDisc(imageData, imageSize, cellImagePos, {1.0f, 0.0f, 0.0f}, radius * 1.4f, radius * 2.0f);
+            //draw events
+            if (cell->eventCounter > 0) {
+                if (cell->event == CellEvent_Attacking) {
+                    drawDisc(imageData, imageSize, cellImagePos, {0.0f, 1.0f, 0.0f}, radius * 1.4f, radius * 2.0f);
+                }
+                if (cell->event == CellEvent_Hit) {
+                    drawDisc(imageData, imageSize, cellImagePos, {1.0f, 0.0f, 0.0f}, radius * 1.4f, radius * 2.0f);
+                }
             }
 
             //draw detonation

source/EngineGpuKernels/SimulationKernels.cu

@@ -84,6 +84,7 @@ __global__ void cudaNextTimestep_cellFunction_prepare_substep2(SimulationData da
 {
     CellProcessor::livingStateTransition(data);
     CellFunctionProcessor::collectCellFunctionOperations(data);
+    CellFunctionProcessor::updateRenderingData(data);
 }
 
 __global__ void cudaNextTimestep_cellFunction_nerve(SimulationData data, SimulationStatistics statistics)

source/EngineInterface/CellFunctionConstants.h

@@ -126,4 +126,10 @@ enum DetonatorState_
     DetonatorState_Exploded
 };
 
-auto constexpr AttackNotificationActivity = 0.95f;
+using CellEvent = int;
+enum CellEvent_
+{
+    CellEvent_No,
+    CellEvent_Hit,
+    CellEvent_Attacking
+};

vcpkg.json

@@ -1,6 +1,6 @@
 {
   "name": "alien",
-  "version": "4.9.1",
+  "version": "4.10.0",
   "dependencies": [
     {
       "name": "glew",