public void CheckRespawns()
        {
            lock (_markersLock)
            {
                if (_markers.Count == 0)
                {
                    return;
                }
            }
            List <Tuple <int, Rectangle, Rectangle> > list = new List <Tuple <int, Rectangle, Rectangle> >();

            for (int i = 0; i < 255; i++)
            {
                Player player = Main.player[i];
                if (player.active && !player.dead)
                {
                    list.Add(Tuple.Create(i, Utils.CenteredRectangle(player.Center, _playerBoxSizeInner), Utils.CenteredRectangle(player.Center, _playerBoxSizeOuter)));
                }
            }
            if (list.Count == 0)
            {
                return;
            }
            RemoveExpiredOrInvalidMarkers();
            lock (_markersLock)
            {
                List <RevengeMarker> list2 = new List <RevengeMarker>();
                for (int j = 0; j < _markers.Count; j++)
                {
                    RevengeMarker revengeMarker             = _markers[j];
                    bool          flag                      = false;
                    Tuple <int, Rectangle, Rectangle> tuple = null;
                    foreach (Tuple <int, Rectangle, Rectangle> item in list)
                    {
                        if (revengeMarker.Intersects(item.Item2, item.Item3))
                        {
                            tuple = item;
                            flag  = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        revengeMarker.SetRespawnAttemptLock(state: false);
                    }
                    else if (!revengeMarker.RespawnAttemptLocked)
                    {
                        revengeMarker.SetRespawnAttemptLock(state: true);
                        if (revengeMarker.WouldNPCBeDiscouraged(Main.player[tuple.Item1]))
                        {
                            revengeMarker.SetToExpire();
                            continue;
                        }
                        revengeMarker.SpawnEnemy();
                        list2.Add(revengeMarker);
                    }
                }
                _markers = _markers.Except(list2).ToList();
            }
        }
 private void AddMarker(RevengeMarker marker)
 {
     lock (_markersLock)
     {
         _markers.Add(marker);
     }
 }
        public void CacheEnemy(NPC npc)
        {
            if (npc.boss || npc.realLife != -1 || npc.rarity > 0 || npc.extraValue < MinimumCoinsForCaching || npc.position.X < Main.leftWorld + 640f + 16f || npc.position.X + (float)npc.width > Main.rightWorld - 640f - 32f || npc.position.Y < Main.topWorld + 640f + 16f || npc.position.Y > Main.bottomWorld - 640f - 32f - (float)npc.height)
            {
                return;
            }
            int num = npc.netID;

            if (NPCID.Sets.RespawnEnemyID.TryGetValue(num, out var value))
            {
                num = value;
            }
            if (num != 0)
            {
                RevengeMarker marker = new RevengeMarker(npc.Center, num, npc.GetLifePercent(), npc.type, npc.aiStyle, npc.extraValue, npc.value, npc.SpawnedFromStatue, _gameTime);
                AddMarker(marker);
                if (Main.netMode == 2)
                {
                    NetMessage.SendCoinLossRevengeMarker(marker);
                }
                if (DisplayCaching)
                {
                    Main.NewText("Cached " + npc.GivenOrTypeName);
                }
            }
        }
        public void AddMarkerFromReader(BinaryReader reader)
        {
            int           uniqueID          = reader.ReadInt32();
            Vector2       coords            = reader.ReadVector2();
            int           npcNetId          = reader.ReadInt32();
            float         npcHPPercent      = reader.ReadSingle();
            int           npcType           = reader.ReadInt32();
            int           npcAiStyle        = reader.ReadInt32();
            int           coinValue         = reader.ReadInt32();
            float         baseValue         = reader.ReadSingle();
            bool          spawnedFromStatue = reader.ReadBoolean();
            RevengeMarker marker            = new RevengeMarker(coords, npcNetId, npcHPPercent, npcType, npcAiStyle, coinValue, baseValue, spawnedFromStatue, _gameTime, uniqueID);

            AddMarker(marker);
        }
        public RevengeMarker DrawMapIcons(SpriteBatch spriteBatch, Vector2 mapTopLeft, Vector2 mapX2Y2AndOff, Rectangle?mapRect, float mapScale, float drawScale, string unused)
        {
            RevengeMarker result = null;

            lock (_markersLock)
            {
                foreach (RevengeMarker marker in _markers)
                {
                    if (marker.DrawMapIcon(spriteBatch, mapTopLeft, mapX2Y2AndOff, mapRect, mapScale, drawScale, _gameTime))
                    {
                        result = marker;
                    }
                }
                return(result);
            }
        }