Progress #1407 -- Moving pieces of code to where they should be (#1439)

For `GameObject`s, the `LateUpdate`, `Sync`, `OnAfterSync` and `OnReconnect` functions have been introduced.
The next step is to move the some of the function calls from `PacketNotifier` to `OnEnter/LeaveVision`, `OnSync` and `OnSpawn`.

GameServerCore/Domain/GameObjects/IGameObject.cs

@@ -44,6 +44,16 @@ public interface IGameObject : IUpdate
         /// Radius of the circle which is used for vision; detecting if objects are visible given terrain, and if so, networked to the player (or team) that owns this game object.
         /// </summary>
         float VisionRadius { get; }
+        /// <summary>
+        /// Whether the object should be hidden by the fog of war.
+        /// </summary>
+        bool IsAffectedByFoW { get; }
+        /// <summary>
+        /// If an object is to be hidden by the fog of war,
+        /// should the object's spawn notification be sent only when the object comes into view,
+        /// not as soon as possible.
+        /// </summary>
+        bool SpawnShouldBeHidden { get; }
 
         /// <summary>
         /// Called by ObjectManager after AddObject (usually right after instatiation of GameObject).
@@ -104,6 +114,24 @@ public interface IGameObject : IUpdate
         /// </summary>
         void OnCollision(IGameObject collider, bool isTerrain = false);
 
+        /// <summary>
+        /// Called by ObjectManager after the Update function has been called on all objects.
+        /// Designed to be used by AI to determine the target. 
+        /// </summary>
+        void LateUpdate(float diff);
+        /// <summary>
+        /// Called by the ObjectManager after vision has been computed for this object and a particular player.
+        /// </summary>
+        void Sync(int userId, TeamId team, bool visible, bool forceSpawn = false);
+        /// <summary>
+        /// Called by ObjectManager after the Sync function has been called on all objects.
+        /// </summary>
+        void OnAfterSync();
+        /// <summary>
+        /// Called by HandleSpawn class after the player has reconnected.
+        /// </summary>
+        void OnReconnect(int userId, TeamId team);
+
         /// <summary>
         /// Sets the object's team.
         /// </summary>
@@ -128,7 +156,7 @@ public interface IGameObject : IUpdate
         /// <param name="team">A team which could have vision of this object.</param>
         /// <param name="visible">New value.</param>
         void SetVisibleByTeam(TeamId team, bool visible = true);
-
+                
         /// <summary>
         /// Whether or not the object is visible for the specified player.
         /// <summary>

GameServerLib/GameObjects/AttackableUnits/AI/BaseTurret.cs

@@ -39,6 +39,8 @@ public class BaseTurret : ObjAiBase, IBaseTurret
         /// </summary>
         public IRegion BubbleRegion { get; private set; }
 
+        public override bool IsAffectedByFoW => false;
+
         public BaseTurret(
             Game game,
             string name,

GameServerLib/GameObjects/AttackableUnits/AI/LaneMinion.cs

@@ -19,6 +19,8 @@ public class LaneMinion : Minion, ILaneMinion
         public string BarracksName { get; }
         public MinionSpawnType MinionSpawnType { get; }
 
+        public override bool SpawnShouldBeHidden => false;
+
         public LaneMinion(
             Game game,
             MinionSpawnType spawnType,

GameServerLib/GameObjects/AttackableUnits/AI/LaneTurret.cs

@@ -97,5 +97,17 @@ public override void AutoAttackHit(IAttackableUnit target)
                 base.AutoAttackHit(target);
             }
         }
+
+        protected override void OnSpawn(int userId, TeamId team, bool doVision)
+        {
+            base.OnSpawn(userId, team, doVision);
+            foreach (var item in Inventory)
+            {
+                if (item != null)
+                {
+                    _game.PacketNotifier.NotifyBuyItem(userId, this, item as IItem);
+                }
+            }
+        }
     }
 }

GameServerLib/GameObjects/AttackableUnits/AI/ObjAIBase.cs

@@ -1064,6 +1064,9 @@ public void SetPet(IPet pet)
         public override void Update(float diff)
         {
             base.Update(diff);
+
+            UpdateBuffs(diff);
+
             CharScript.OnUpdate(diff);
             if (!_aiPaused)
             {
@@ -1093,7 +1096,33 @@ public override void Update(float diff)
                 SetPet(null);
             }
         }
-
+        void UpdateBuffs(float diff)
+        {
+            var tempBuffs = new List<IBuff>(GetBuffs());
+            for (int i = tempBuffs.Count - 1; i >= 0; i--)
+            {
+                if (tempBuffs[i].Elapsed())
+                {
+                    RemoveBuff(tempBuffs[i]);
+                }
+                else
+                {
+                    tempBuffs[i].Update(diff);
+                }
+            }
+        }
+        public override void LateUpdate(float diff)
+        {            
+            // Stop targeting an untargetable unit.
+            if (TargetUnit != null && !TargetUnit.Status.HasFlag(StatusFlags.Targetable))
+            {
+                if(TargetUnit is IObjAiBase aiTar && aiTar.CharData.IsUseable)
+                {
+                    return;
+                }
+                Untarget(TargetUnit);
+            }
+        }
         public override void TakeDamage(IAttackableUnit attacker, float damage, DamageType type, DamageSource source, DamageResultType damageText)
         {
             base.TakeDamage(attacker, damage, type, source, damageText);

GameServerLib/GameObjects/AttackableUnits/AttackableUnit.cs

@@ -92,6 +92,9 @@ public class AttackableUnit : GameObject, IAttackableUnit
         /// </summary>
         public IForceMovementParameters MovementParameters { get; protected set; }
 
+        public override bool IsAffectedByFoW => true;
+        public override bool SpawnShouldBeHidden => true;
+
         public AttackableUnit(
             Game game,
             string model,
@@ -273,6 +276,24 @@ public override void OnCollision(IGameObject collider, bool isTerrain = false)
             }
         }
 
+        protected override void OnSync(int userId, TeamId team)
+        {
+            if (Replication.Changed)
+            {
+                _game.PacketNotifier.HoldReplicationDataUntilOnReplicationNotification(this, userId, true);
+            }
+            if (IsMovementUpdated())
+            {
+                _game.PacketNotifier.HoldMovementDataUntilWaypointGroupNotification(this, userId, false);
+            }
+        }
+
+        public override void OnAfterSync()
+        {
+            Replication.MarkAsUnchanged();
+            ClearMovementUpdated();
+        }
+
         /// <summary>
         /// Returns whether or not this unit is targetable to the specified team.
         /// </summary>

GameServerLib/GameObjects/AttackableUnits/Buildings/ObjBuilding.cs

@@ -6,6 +6,8 @@ namespace LeagueSandbox.GameServer.GameObjects.AttackableUnits.Buildings
 {
     public class ObjBuilding : AttackableUnit, IObjBuilding
     {
+        public override bool IsAffectedByFoW => false;
+
         public ObjBuilding(Game game, string model, IStats stats, int collisionRadius = 40,
             Vector2 position = new Vector2(), int visionRadius = 0, uint netId = 0, TeamId team = TeamId.TEAM_BLUE) :
             base(game, model, stats, collisionRadius, position, visionRadius, netId, team)

GameServerLib/GameObjects/GameObject.cs

@@ -81,6 +81,9 @@ public IEnumerable<int> VisibleForPlayers
         /// </summary>
         public float VisionRadius { get; protected set; }
 
+        public virtual bool IsAffectedByFoW => false;
+        public virtual bool SpawnShouldBeHidden => false;
+
         /// <summary>
         /// Instantiation of an object which represents the base class for all objects in League of Legends.
         /// </summary>
@@ -132,6 +135,10 @@ public virtual void Update(float diff)
         {
         }
 
+        public virtual void LateUpdate(float diff)
+        {
+        }
+
         /// <summary>
         /// Whether or not the object should be removed from the game (usually both server and client-side). Refer to ObjectManager.
         /// </summary>
@@ -242,6 +249,68 @@ public virtual void OnCollision(IGameObject collider, bool isTerrain = false)
             }
         }
 
+        protected virtual void OnSpawn(int userId, TeamId team, bool doVision)
+        {
+            _game.PacketNotifier.NotifySpawn(this, team, userId, _game.GameTime, doVision);
+        }
+
+        protected virtual void OnEnterVision(int userId, TeamId team)
+        {
+            _game.PacketNotifier.NotifyVisibilityChange(this, team, true, userId);
+        }
+
+        protected virtual void OnSync(int userId, TeamId team)
+        {
+        }
+
+        protected virtual void OnLeaveVision(int userId, TeamId team)
+        {
+            _game.PacketNotifier.NotifyVisibilityChange(this, team, false, userId);
+        }
+
+        public virtual void Sync(int userId, TeamId team, bool visible, bool forceSpawn = false)
+        {
+            visible = visible || !IsAffectedByFoW;
+
+            if (!forceSpawn && IsSpawnedForPlayer(userId))
+            {
+                if (IsAffectedByFoW && (IsVisibleForPlayer(userId) != visible))
+                {
+                    if(visible)
+                    {
+                        OnEnterVision(userId, team);
+                    }
+                    else
+                    {
+                        OnLeaveVision(userId, team);
+                    }
+                    SetVisibleForPlayer(userId, visible);
+                }
+                else if(visible)
+                {
+                    OnSync(userId, team);
+                }
+            }
+            else if (visible || !SpawnShouldBeHidden)
+            {
+                OnSpawn(userId, team, visible);
+                SetVisibleForPlayer(userId, visible);
+                SetSpawnedForPlayer(userId);
+            }
+        }
+
+        public virtual void OnAfterSync()
+        {
+        }
+
+        public virtual void OnReconnect(int userId, TeamId team)
+        {
+            if(IsSpawnedForPlayer(userId))
+            {
+                OnSpawn(userId, team, IsVisibleForPlayer(userId));
+            }
+        }
+
         /// <summary>
         /// Sets the object's team.
         /// </summary>
@@ -263,7 +332,7 @@ public virtual void SetTeam(TeamId team)
         /// <param name="team">A team which could have vision of this object.</param>
         public bool IsVisibleByTeam(TeamId team)
         {
-            return _visibleByTeam[team];
+            return !IsAffectedByFoW || _visibleByTeam[team];
         }
 
         /// <summary>
@@ -283,7 +352,7 @@ public void SetVisibleByTeam(TeamId team, bool visible = true)
         /// <param name="userId">The player in relation to which the value is obtained</param>
         public bool IsVisibleForPlayer(int userId)
         {
-            return _visibleForPlayers.GetValueOrDefault(userId, false);
+            return !IsAffectedByFoW || _visibleForPlayers.GetValueOrDefault(userId, false);
         }
 
         /// <summary>

GameServerLib/GameObjects/Particle.cs

@@ -73,6 +73,9 @@ public class Particle : GameObject, IParticle
         /// </summary>
         public FXFlags Flags { get; }
 
+        public override bool IsAffectedByFoW => true;
+        public override bool SpawnShouldBeHidden => true;
+
         /// <summary>
         /// Prepares the Particle, setting up the information required for networking it to clients.
         /// This particle will spawn and stay on the specified GameObject target.

GameServerLib/GameObjects/Spell/Missile/SpellMissile.cs

@@ -36,6 +36,9 @@ public class SpellMissile : GameObject, ISpellMissile
         /// </summary>
         public bool IsServerOnly { get; }
 
+        public override bool IsAffectedByFoW => true;
+        public override bool SpawnShouldBeHidden => true;
+
         public SpellMissile(
             Game game,
             int collisionRadius,