[Concept] : [Unity] : Entity Blittable System

[h0lybyte]

Core Concept/Theory
We would need a clear and concise description of the concept. For example, It would be cool if [...]

Entity Blittable System or EBS will be the core for the UI and networking.
The structure will look like this

graph TD
    A["EntityBlit (Universal)<br/>- Ulid, Type, ActionFlags, WorldPos<br/>ALWAYS PRESENT (36 bytes)"]
    
    A -->|"Combined with ONE of these:"| B["ResourceBlit<br/>(20 bytes)"]
    A --> C["StructureBlit<br/>(18 bytes)"]
    A --> D["MonsterBlit<br/>(22 bytes)"]
    A --> E["UnitBlit<br/>(26 bytes)"]
    A --> F["NPCBlit<br/>(16 bytes)"]
    A --> G["ItemBlit<br/>(12 bytes)"]
    A --> H["PlayerBlit<br/>(20 bytes)"]
    
    style A fill:#4a90e2,stroke:#2e5c8a,stroke-width:3px,color:#fff
    style B fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff
    style C fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff
    style D fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff
    style E fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff
    style F fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff
    style G fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff
    style H fill:#50c878,stroke:#2d7a4a,stroke-width:2px,color:#fff

Loading

The goal will be to not only make it easier to FFI between C# and JS, but also make it easier to move data between the server and client.

This issue ticket will be for keeping notes on the EBS foundation!

I will try to keep some proof of concepts on here, so that we can reference them later on.

---

Alternative Ideas
Is there any other way this concept could be used?

This will be used by the UI, making it easier to hover over different entities within the ECS system.

---

Alternative Examples/Sources
Are there any other references that you can provide?

Will provide them as comments for this ticket.

---

Additional information
Add any other context or examples of this concept here.

No additional information at this time.

Application Notes
KBVE Graph

[h0lybyte]

using Unity.Collections;
using Unity.Mathematics;

namespace KBVE.MMExtensions.Orchestrator.DOTS
{
    /// <summary>
    /// Minimal universal entity data. Always present for any entity.
    /// Size: ~36 bytes
    /// </summary>
    public struct EntityBlit
    {
        // Universal fields (all entities have these)
        public FixedBytes16 Ulid;              // 16 bytes
        public EntityType Type;                // 4 bytes
        public EntityActionFlags ActionFlags;  // 4 bytes
        public float3 WorldPos;                // 12 bytes

        // Helper properties
        public bool IsResource => Type.IsResource();
        public bool IsStructure => Type.IsStructure();
        public bool IsMonster => Type.IsMonster();
        public bool IsUnit => Type.IsUnit();
        public bool IsPlayer => Type.IsPlayer();
        public bool IsItem => Type.IsItem();
    }

    /// <summary>
    /// Resource-specific data. Only present when entity is a Resource.
    /// Size: ~20 bytes
    /// </summary>
    public struct ResourceBlit
    {
        public byte ResourceType;       // 1 byte
        public byte ResourceFlags;      // 1 byte
        public int Amount;              // 4 bytes
        public int MaxAmount;           // 4 bytes
        public float HarvestYield;      // 4 bytes
        public float HarvestTime;       // 4 bytes
        // Padding: ~2 bytes for alignment
    }

    /// <summary>
    /// Structure-specific data. Only present when entity is a Structure.
    /// Size: ~18 bytes
    /// </summary>
    public struct StructureBlit
    {
        public byte StructureType;          // 1 byte
        public byte Level;                  // 1 byte
        public int Health;                  // 4 bytes
        public int MaxHealth;               // 4 bytes
        public float ProductionRate;        // 4 bytes
        public float ProductionProgress;    // 4 bytes
    }

    /// <summary>
    /// Combat entity data (Monster/Unit/Player). Only present for combatants.
    /// Size: ~22 bytes
    /// </summary>
    public struct CombatantBlit
    {
        public byte CombatantType;      // 1 byte
        public byte Level;              // 1 byte
        public int Health;              // 4 bytes
        public int MaxHealth;           // 4 bytes
        public float AttackDamage;      // 4 bytes
        public float AttackSpeed;       // 4 bytes
        public float MoveSpeed;         // 4 bytes
    }

    /// <summary>
    /// Item-specific data. Only present when entity is an Item.
    /// Size: ~12 bytes
    /// </summary>
    public struct ItemBlit
    {
        public byte ItemType;           // 1 byte
        public byte Rarity;             // 1 byte
        public int StackCount;          // 4 bytes
        public int MaxStack;            // 4 bytes
        // Padding: ~2 bytes
    }
}

That is the basics of the EntityBlits , still need to rewrite them into their own structures.

[h0lybyte]

I see, I made a grave mistake, I am suppose to have two ULIDS, one would be for the exact instance of the said object and the other would be the template instance.

[h0lybyte]

The BlittableCopy is done here

https://github.com/KBVE/kbve/blob/main/packages/unity/mmextensions/mmextensions/Editor/BlittableDOTS.cs

However there are still some optimizations that we can do with the data from the blit to UI, however we can focus on that later on after we migrate over the structures and NPCs.