Ticket #405: los.patch

simulation/EntityManager.cpp

@@ -37 +37 @@
 #include "PathfindEngine.h"
 #include "ps/GameSetup/Config.h"
 
+#include <cstdlib>
+
 int AURA_CIRCLE_POINTS;
 int SELECTION_CIRCLE_POINTS;
 int SELECTION_BOX_POINTS;
@@ -336 +338 @@
             results.push_back( m_entities[i].m_entity );
 }
 
+// This is a function designed to be used for the next method.
+int EntityMoveCompare(const void* a, const void* b) {
+    return ((CEntity*) a)->GetLastMoveTime() - ((CEntity*) b)->GetLastMoveTime();
+}
+
+void CEntityManager::GetMovedExtant( std::vector<CEntity*>& results, size_t maxEntities )
+{
+    results.clear();
+    CEntity* heap[MAX_HANDLES];
+    size_t heap_pointer = 0;
+    for( size_t i = 0; i < MAX_HANDLES; i++ )
+        if( IsEntityRefd(i) &&  m_entities[i].m_entity->HasMoved() ) 
+            heap[heap_pointer++] = m_entities[i].m_entity;
+    qsort( heap, sizeof(CEntity*), heap_pointer, EntityMoveCompare );
+    // If this is the first update then its ok simply to return all the entities. 
+    // This only happens in the load screen, and thats not a time sensitive area. 
+    if ( heap_pointer > 0 && heap[0]->GetLastMoveTime() == -100 )
+        for ( size_t i = 0; i < heap_pointer; ++i )
+            results.push_back( heap[i] );
+    else
+        for (size_t i = 0; i < maxEntities && i < heap_pointer; ++i )
+            results.push_back( heap[i] );
+}
+
 void CEntityManager::GetInRange( float x, float z, float radius, std::vector<CEntity*>& results )
 {
     results.clear();

simulation/Entity.cpp

@@ -99 +99 @@
     m_graphics_position = m_position;
     m_graphics_orientation = m_orientation;
     m_actor_transform_valid = false;
+    m_actor_has_moved = true;
     entf_clear(ENTF_HAS_RALLY_POINT);
 
     entf_clear(ENTF_DESTROYED);
@@ -113 +114 @@
     m_frameCheck = 0;
     m_lastCombatTime = -100;
     m_lastRunTime = -100;
+    m_lastMoveTime = -100;
     m_currentNotification = 0;
     m_currentRequest = 0;
     entf_set(ENTF_DESTROY_NOTIFIERS);
@@ -1073 +1075 @@
         )
     {                                                           
         m_actor_transform_valid = false;
+        if( !m_actor_has_moved ) {
+            m_actor_has_moved = true;
+            m_lastMoveTime = g_Game->GetSimulation()->GetTime();
+        }
     }
     // Update the actor transform data when necessary.
     if( !m_actor_transform_valid )
@@ -1088 +1094 @@
     m_actor_transform_valid = false;
 }
 
+bool CEntity::HasMoved()
+{
+    return m_actor_has_moved;
+}
+
+void CEntity::ResetHasMoved()
+{
+    m_actor_has_moved = false;
+}
+
+double CEntity::GetLastMoveTime()
+{
+    return m_lastMoveTime;
+}
+
+CVector3D CEntity::GetLastPosition()
+{
+    // if the entity has never moved then its probably safter to get the current position.
+    if ( m_lastMoveTime == -100) {
+        m_last_position = m_position;
+        return m_last_position;
+    } else {
+        CVector3D temp = m_last_position;
+        m_last_position = m_position;
+        return temp;
+    }
+}
+
+ssize_t CEntity::GetLastLOS()
+{
+    // if the entity has never moved then its probably safter to get the current los.
+    if ( m_lastMoveTime == -100) {
+        m_last_los = m_los;
+        return m_last_los;
+    } else {
+        ssize_t temp = m_last_los;
+        m_last_los = m_los;
+        return temp;
+    }
+}
+
 float CEntity::GetAnchorLevel( float x, float z )
 {
     CTerrain *pTerrain = g_Game->GetWorld()->GetTerrain();

simulation/LOSManager.cpp

@@ -31 +31 @@
 #include "lib/allocators/allocators.h"  // matrix_alloc
 #include "lib/timer.h"
 
+// rather than using a single constant representing the max_players, to save memory we should
+// only allocate as much memory as there are players. this works for now however. 
+#define MAX_PLAYERS 32
 
 CLOSManager::CLOSManager() : m_LOSSetting(LOS_SETTING_NORMAL), m_FogOfWar(true)
 {
-#ifdef _2_los
     m_Explored = 0;
     m_Visible  = 0;
-#else
-    m_VisibilityMatrix = 0;
-#endif
 }
 
 CLOSManager::~CLOSManager() 
 {
-#ifdef _2_los
     matrix_free((void**)m_Explored);
     m_Explored = 0;
-    matrix_free((void**)m_Visible);
+
+    for ( int i = 0; i < MAX_PLAYERS; ++i )
+        matrix_free((void**)m_Visible[i]);
+    free( m_Visible );
     m_Visible = 0;
-#else
-    matrix_free((void**)m_VisibilityMatrix);
-    m_VisibilityMatrix = 0;
-#endif
 }
 
 void CLOSManager::Initialize(ELOSSetting losSetting, bool fogOfWar) 
@@ -64 +61 @@
     CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
     m_TilesPerSide = terrain->GetVerticesPerSide() - 1;
     m_TilesPerSide_1 = m_TilesPerSide-1;
+    // REMOVE!
+    std::cout << "Total Tiles: " << m_TilesPerSide * m_TilesPerSide << std::endl;
 
-
     // Create the LOS data arrays
-#ifdef _2_los
     m_Explored = (int**)matrix_alloc(m_TilesPerSide, m_TilesPerSide, sizeof(int));
-    m_Visible  = (int**)matrix_alloc(m_TilesPerSide, m_TilesPerSide, sizeof(int));
-#else
-    m_VisibilityMatrix = (u16**)matrix_alloc(m_TilesPerSide, m_TilesPerSide, sizeof(u16));
-#endif
+    m_Visible  = (int16_t***)malloc( sizeof(int16_t**) * MAX_PLAYERS ); 
+    for ( int i = 0; i < MAX_PLAYERS; ++i ) 
+        m_Visible[i] = (int16_t**)matrix_alloc(m_TilesPerSide, m_TilesPerSide, sizeof(int16_t));
 
     // TODO: This memory should be freed somewhere when the engine supports 
     // multiple sessions without restarting the program.
     // JW: currently free it in the dtor
 
     // Set initial values
-#ifdef _2_los
     int explored_value = (m_LOSSetting == LOS_SETTING_EXPLORED || m_LOSSetting == LOS_SETTING_ALL_VISIBLE)? 0xFF : 0;
-    int vis_value      = (m_LOSSetting == LOS_SETTING_ALL_VISIBLE)? 0xFF : 0;
-#else
-    u16 vis_value = 0;
-    if(m_LOSSetting == LOS_SETTING_EXPLORED || m_LOSSetting == LOS_SETTING_ALL_VISIBLE)
-        for(int i = 0; i < 8; i++) vis_value |= LOS_EXPLORED << (i*2);
-    if(m_LOSSetting == LOS_SETTING_ALL_VISIBLE || (m_LOSSetting == LOS_SETTING_EXPLORED && !m_FogOfWar) )
-        for(int i = 0; i < 8; i++) vis_value |= LOS_VISIBLE << (i*2);
-#endif
+    int vis_value      = (m_LOSSetting == LOS_SETTING_ALL_VISIBLE)? 1 : 0;
     for(size_t x=0; x<m_TilesPerSide; x++)
     {
-#ifdef _2_los
         memset(m_Explored[x], explored_value, m_TilesPerSide*sizeof(int));
-        memset(m_Visible [x], vis_value     , m_TilesPerSide*sizeof(int));
-#else
-        for(size_t y=0; y<m_TilesPerSide; y++)
-        for(size_t x=0; x<m_TilesPerSide; x++)
-            m_VisibilityMatrix[y][x] = vis_value;
-#endif
+        for (size_t p = 0; p < MAX_PLAYERS; ++p)
+            memset(m_Visible[p][x], vis_value, m_TilesPerSide*sizeof(int16_t));
     }
 
     // Just Update() to set the visible array and also mark currently visible tiles as explored.
     // NOTE: this will have to be changed if we decide to use incremental LOS
-    Update();
+    InitialUpdate();
 }
 
-// NOTE: this will have to be changed if we decide to use incremental LOS
-void CLOSManager::Update() 
+// This is only called in the constructor to set the visibility matrix.
+void CLOSManager::InitialUpdate() 
 {
     if(m_LOSSetting == LOS_SETTING_ALL_VISIBLE)
         return;
 
-    // Clear the visible array
-#ifdef _2_los
-    if( m_FogOfWar )
+    // Set visibility for each entity
+    std::vector<CEntity*> extant;
+    g_EntityManager.GetMovedExtant(extant);
+    for(size_t i=0; i<extant.size(); i++) 
     {
-        for(int x=0; x<m_TilesPerSide; x++)
-        {
-            memset(m_Visible[x], 0, m_TilesPerSide*sizeof(int));
+        CEntity* e = extant[i];
+
+        ssize_t los = e->GetLastLOS();
+        size_t player_id = e->GetPlayer()->GetPlayerID();
+        int mask = (1 << player_id);
+        if(los == 0)
+            continue;
+
+        ssize_t cx, cz;
+        CTerrain::CalcFromPosition(e->GetLastPosition().X, e->GetLastPosition().Z, cx, cz);
+
+        ssize_t minX = std::max(cx-los, ssize_t(0));
+        ssize_t minZ = std::max(cz-los, ssize_t(0));
+        ssize_t maxX = std::min(cx+los, ssize_t(m_TilesPerSide_1));
+        ssize_t maxZ = std::min(cz+los, ssize_t(m_TilesPerSide_1));
+
+        //Set the visibility for the current entities.
+        for(ssize_t x=minX; x<=maxX; x++) {
+            for(ssize_t z=minZ; z<=maxZ; z++) {
+                if((x-cx)*(x-cx) + (z-cz)*(z-cz) <= los*los) {
+                    ++m_Visible[player_id][x][z];
+                    m_Explored[x][z] |= mask;
+                }
+            }
         }
+        e->ResetHasMoved();
     }
-#else
-    if( m_FogOfWar )
-    {
-        u16 not_all_vis = 0xFFFF;
-        for(int i = 0; i < 8; i++)
-            not_all_vis &= ~(LOS_VISIBLE << (i*2));
-        for(size_t y=0; y<m_TilesPerSide; y++)
-        for(size_t x=0; x<m_TilesPerSide; x++)
-            m_VisibilityMatrix[y][x] &= not_all_vis;
-    }
-#endif
+}
 
+// NOTE: this will have to be changed if we decide to use incremental LOS
+void CLOSManager::Update() 
+{
+    if(m_LOSSetting == LOS_SETTING_ALL_VISIBLE)
+        return;
+
     // Set visibility for each entity
     std::vector<CEntity*> extant;
-    g_EntityManager.GetExtant(extant);
+    g_EntityManager.GetMovedExtant(extant);
     for(size_t i=0; i<extant.size(); i++) 
     {
         CEntity* e = extant[i];
 
         ssize_t los = e->m_los;
+        ssize_t llos = e->GetLastLOS();
+        size_t player_id = e->GetPlayer()->GetPlayerID();
+        int mask = (1 << player_id);
         if(los == 0)
             continue;
 
-#ifdef _2_los
-        size_t mask = (size_t(1) << e->GetPlayer()->GetPlayerID());
-#else
-        size_t shift = e->GetPlayer()->GetPlayerID()*2;
-#endif
-
-        ssize_t cx, cz;
+        ssize_t cx, cz;
         CTerrain::CalcFromPosition(e->m_position.X, e->m_position.Z, cx, cz);
 
         ssize_t minX = std::max(cx-los, ssize_t(0));
@@ -158 +157 @@
         ssize_t maxX = std::min(cx+los, ssize_t(m_TilesPerSide_1));
         ssize_t maxZ = std::min(cz+los, ssize_t(m_TilesPerSide_1));
 
-        for(ssize_t x=minX; x<=maxX; x++) 
-        {
-            for(ssize_t z=minZ; z<=maxZ; z++) 
-            {
-                if((x-cx)*(x-cx) + (z-cz)*(z-cz) <= los*los) 
-                {
-#ifdef _2_los
-                    m_Visible[x][z] |= mask;
+        // First the reference count is increased for each new visible square.
+        for(ssize_t x=minX; x<=maxX; x++) {
+            for(ssize_t z=minZ; z<=maxZ; z++) {
+                if((x-cx)*(x-cx) + (z-cz)*(z-cz) <= los*los) {
+                    ++m_Visible[player_id][x][z];
                     m_Explored[x][z] |= mask;
-#else
-                    m_VisibilityMatrix[x][z] |= (LOS_EXPLORED|LOS_VISIBLE) << shift;
-#endif
                 }
             }
         }
+
+        ssize_t lcx, lcz;
+        CTerrain::CalcFromPosition(e->GetLastPosition().X, e->GetLastPosition().Z, lcx, lcz);
+
+        minX = std::max(lcx-los, ssize_t(0));
+        minZ = std::max(lcz-los, ssize_t(0));
+        maxX = std::min(lcx+los, ssize_t(m_TilesPerSide_1));
+        maxZ = std::min(lcz+los, ssize_t(m_TilesPerSide_1));
+
+        // Now the reference count is decremented for every square left.
+        for(ssize_t x=minX; x<=maxX; x++)
+            for(ssize_t z=minZ; z<=maxZ; z++)
+                if((x-lcx)*(x-lcx) + (z-lcz)*(z-lcz) <= llos*llos)
+                    --m_Visible[player_id][x][z];
+        e->ResetHasMoved();
     }
 }
 
-
+// As far as I know this function along with CPlayer::GetLOSToken are useless and should be removed.
 size_t LOS_GetTokenFor(size_t player_id)
 {
-#ifdef _2_los
     return size_t(1) << player_id;
-#else
-    return player_id*2;
-#endif
 }
 
 //TIMER_ADD_CLIENT(tc_getstatus);
@@ -199 +203 @@
 
     // TODO: Make the mask depend on the player's diplomacy (just OR all his allies' masks)
 
-#ifdef _2_los
-
-    const int mask = player->GetLOSToken();
-    if((m_Visible[tx][tz] & mask) || m_LOSSetting == LOS_SETTING_ALL_VISIBLE) 
-    {
+    const int id = player->GetPlayerID();
+    if(m_Visible[id][tx][tz] || m_LOSSetting == LOS_SETTING_ALL_VISIBLE)
         return LOS_VISIBLE;
-    }
-    else if((m_Explored[tx][tz] & mask) || m_LOSSetting == LOS_SETTING_EXPLORED)
-    {
+    else if((m_Explored[tx][tz] & (1 << id)) || m_LOSSetting == LOS_SETTING_EXPLORED)
         return LOS_EXPLORED;
-    }
-    else
-    {
+    else 
         return LOS_UNEXPLORED;
-    }
-#else
-    const size_t shift = player->GetLOSToken();
-    return (ELOSStatus)((m_VisibilityMatrix[tx][tz] >> shift) & 3);
-#endif
 }
 
 

simulation/EntityManager.h

@@ -53 +53 @@
 // collision patch size, in graphics units, not tiles (1 tile = 4 units)
 #define COLLISION_PATCH_SIZE 8
 
+// The max number of entities to be recieved by GetQueuedExtant
+#define MAX_QUEUED_EXTANT 50
+
 #define g_EntityManager g_Game->GetWorld()->GetEntityManager()
 
 class CEntityManager
@@ -140 +143 @@
     void GetMatchingAsHandles( std::vector<HEntity>& matchlist, EntityPredicate predicate, void* userdata = 0 );
     void GetExtantAsHandles( std::vector<HEntity>& results );
     void GetExtant( std::vector<CEntity*>& results );
+
+    // returns entities who have been moved since the last update. 
+    void GetMovedExtant( std::vector<CEntity*>& results, size_t maxEntities = MAX_QUEUED_EXTANT );
     static inline bool IsExtant()   // True if the singleton is actively maintaining handles. When false, system is shutting down, handles are quietly dumped.
     {
         return( m_extant );

simulation/Entity.h

@@ -160 +160 @@
 
     double m_lastCombatTime;
     double m_lastRunTime;
+    // This represents the last time the field m_actor_has_moved was set to true;
+    double m_lastMoveTime;
 
     // Building to convert to if this is a foundation, or "" otherwise
     CStrW m_building;
@@ -181 +183 @@
     // LOS distance/range
     ssize_t m_los;
 
+
     // If the object is a territory centre, this points to its territory
     CTerritory* m_associatedTerritory;
 
@@ -214 +217 @@
     // moved since it was last calculated, and the terrain hasn't been changed).
     bool m_actor_transform_valid;
 
+    // True if the actor has moved. This value can only be reset to false via ResetHasMoved
+    bool m_actor_has_moved;
+    
+    // Values saved since the last time ResetHasMoved was called.
+    CVector3D m_last_position;
+    ssize_t m_last_los;
+
     // Our current collision patch in CEntityManager
     std::vector<CEntity*>* m_collisionPatch;
 
@@ -290 +300 @@
     // (Necessary when terrain might move underneath the actor.)
     void InvalidateActor();
 
+    // Checks if the player has moved since the last call to ResetHasMoved.
+    bool HasMoved();
+    // Resets the move state.
+    void ResetHasMoved();
+    // Gets the time of movement during last movement since the call to ResetHasMoved.
+    double GetLastMoveTime();
+    // Gets the position since the last call to GetLastPosition.
+    CVector3D GetLastPosition();
+    // Gets the los since the last call to GetLastLOS.
+    ssize_t GetLastLOS();
+
     // Updates auras
     void UpdateAuras( int timestep_millis );
 

simulation/LOSManager.h

@@ -31 +31 @@
 #ifndef INCLUDED_LOSMANAGER
 #define INCLUDED_LOSMANAGER
 
+#include <cstdlib>
+
 class CUnit;
 class CEntity;
 class CPlayer;
@@ -63 +65 @@
 
 class CLOSManager
 {
-#ifdef _2_los
+ protected:
+
     int** m_Explored;       // (m_Explored[x][z] & (1<<p) says whether player p has explored tile (x,z),
                             // i.e. has removed Shroud of Darkness from it.
-    int** m_Visible;        // (m_Visible[x][z] & (1<<p)) says whether player p currently sees tile (x,z).
+    int16_t*** m_Visible;       // (m_Visible[p][x][z]) says whether player p currently sees tile (x,z).
     // NOTE: This will have to be changed to a 3D array where each element stores the number of units
     // of a certain player that can see a certain tile if we want to use incremental LOS.
-#else
-    u16** m_VisibilityMatrix;
-#endif
 
     size_t m_TilesPerSide;
     size_t m_TilesPerSide_1;    // as above, -1
+    // used internally to initially set the visibility matrix.
+    void InitialUpdate();
 
-public:
+ public:
 
 
     ELOSSetting m_LOSSetting;