OnEntityBuilt

using System.Linq;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Foundation Build Limit", "RustPluginGenerator", "1.0.0")]
    [Description("Limits how many foundations each player can place and counts new builds via OnEntityBuilt.")]
    public class FoundationBuildLimit : RustPlugin
    {
        private const string PermBypass = "foundationbuildlimit.bypass";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Max foundations per player")]
            public int MaxFoundations = 3;

            [JsonProperty("Bypass permission")]
            public string BypassPermission = PermBypass;
        }

        private class StoredData
        {
            public Dictionary<string, int> Counts = new Dictionary<string, int>();
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        private void Init()
        {
            permission.RegisterPermission(PermBypass, this);
        }

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

        private void Unload()
        {
            if (data != null)
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

        private object CanBuild(Planner planner, Construction construction, Construction.Target target)
        {
            var player = planner?.GetOwnerPlayer();
            if (player == null || planner.isTypeDeployable) return null;
            if (permission.UserHasPermission(player.UserIDString, config.BypassPermission)) return null;

            var prefab = construction?.fullName;
            if (prefab == null || !prefab.Contains("foundation")) return null;

            if (CountFoundations(player.userID) >= config.MaxFoundations)
            {
                ChatMessage(player, $"You have reached the {config.MaxFoundations} foundation limit.");
                return false;
            }
            return null;
        }

        private void OnEntityBuilt(Planner planner, GameObject gameObject)
        {
            if (gameObject == null) return;
            var player = planner?.GetOwnerPlayer();
            if (player == null) return;

            var entity = gameObject.ToBaseEntity();
            var block = entity as BuildingBlock;
            if (block == null) return;
            if (!block.ShortPrefabName.Contains("foundation")) return;

            if (data == null) return;
            string id = player.UserIDString;
            int current;
            data.Counts.TryGetValue(id, out current);
            data.Counts[id] = current + 1;
        }

        private int CountFoundations(ulong userId)
        {
            int count = 0;
            foreach (var net in BaseNetworkable.serverEntities)
            {
                var block = net as BuildingBlock;
                if (block == null) continue;
                if (block.OwnerID != userId) continue;
                if (!block.ShortPrefabName.Contains("foundation")) continue;
                count++;
            }
            return count;
        }

        private void ChatMessage(BasePlayer player, string text)
        {
            player.ChatMessage(text);
        }
    }
}