Error while compiling MiniTrails: The type or namespace name 'MiniCopter' could not be found (are you missing a using directive or an assembly reference?) | Line: 109, Pos: 35

Try replacing the plugin with this one. Unfortunately I can't test it because I have too many mods and it causes errors.

I have reworked all the code and it has nothing to do with the original plugin except for the functions.
----------------

using Oxide.Core;
using Oxide.Core.Plugins;
using System.Collections.Generic;
using Oxide.Game.Rust.Cui;
using System;
using UnityEngine;

namespace Oxide.Plugins
{
[Info("Mini Trails", "Salsa", "2.1.3")]
[Description("Draws trails behind minicopters")]
class MiniTrails : RustPlugin
{
private static Data data;
private Dictionary<ulong, MiniT> MountedMinis = new Dictionary<ulong, MiniT>();

private const string FlameEnt = "assets/prefabs/weapons/flamethrower/flamethrower.entity.prefab";
private const string AnchorEnt = "assets/prefabs/visualization/sphere.prefab"; // Looking for invisible alternative
private const string WooshSound = "assets/prefabs/npc/patrol helicopter/effects/rocket_fire.prefab";
private const string SupplyEnt = "assets/prefabs/tools/supply signal/grenade.supplysignal.deployed.prefab";
private const string FireworkEnt = "assets/prefabs/deployable/fireworks/volcanofirework-red.prefab";

private const string PermUse = "minitrails.use";

private class Preferences
{
public bool active = false;
public int count = 1;
public trailType type = trailType.fire;

public Preferences() { }
}

private enum trailType
{
fire,
pink,
firework
}

private class Data
{
public Dictionary<ulong, Preferences> preferences = new Dictionary<ulong, Preferences>();

public Data() { }
}

private class MiniT // A mini with a trail
{
public BaseVehicle mini;
public BasePlayer driver;
public List<BaseEntity> anchors = new List<BaseEntity>();
public List<BaseEntity> trails = new List<BaseEntity>();

private void spawnFlame(string prefab, Vector3 localPos, Quaternion localRotation)
{
BaseEntity trail = GameManager.server.CreateEntity(prefab, mini.transform.position, new Quaternion());
if (trail == null) return;

BaseEntity anchor = GameManager.server.CreateEntity(AnchorEnt, mini.transform.position, new Quaternion(0, 0, 0, 0), true);
if (anchor == null) return;

anchor.SetParent(mini);
anchor.Spawn();
anchor.transform.localPosition = localPos;
anchor.transform.localRotation = localRotation;

trail.SetParent(anchor);
trail.Spawn();

trail.SendNetworkUpdateImmediate(true);

anchors.Add(anchor);
}

private void spawnSupplySignal(string prefab, Vector3 localPos, Quaternion localRotation)
{
BaseEntity trail = GameManager.server.CreateEntity(prefab, mini.transform.position);
if (trail == null) return;

trail.SetParent(mini);
trail.transform.localPosition = localPos;
trail.transform.localRotation = localRotation;
trail.GetComponent<Rigidbody>().useGravity = false;
trail.GetComponent<Rigidbody>().isKinematic = true;

trail.Spawn();

SupplySignal ss = trail as SupplySignal;

ss.CancelInvoke(ss.Explode);
ss.Invoke(() =>
{
ss.SetFlag(BaseEntity.Flags.On, true);
ss.SendNetworkUpdateImmediate();
}, 0);

trails.Add(trail);
}

private void spawnFirework(string prefab, Vector3 localPos, Quaternion localRotation)
{
BaseFirework fw = GameManager.server.CreateEntity(prefab) as BaseFirework;
if (fw == null) return;

fw.SetParent(mini);
fw.transform.localPosition = localPos;
fw.transform.localRotation = localRotation;

fw.fuseLength = 0;
fw.activityLength = 5000;
fw.Ignite(fw.transform.position);

fw.Spawn();
trails.Add(fw);
}

public void spawnTrail()
{
switch (data.preferences[driver.userID].type)
{
case trailType.fire:
switch (data.preferences[driver.userID].count)
{
case 1:
spawnFlame(FlameEnt, new Vector3(0.0f, 0.8f, -1.0f), Quaternion.Euler(0, -75, 0));
break;
case 2:
spawnFlame(FlameEnt, new Vector3(0.0f, 0.8f, -1.0f), Quaternion.Euler(0, -105, 0));
spawnFlame(FlameEnt, new Vector3(0.0f, 0.8f, -1.0f), Quaternion.Euler(0, -45, 0));
break;
case 3:
spawnFlame(FlameEnt, new Vector3(0.0f, 0.8f, -1.0f), Quaternion.Euler(0, -105, 0));
spawnFlame(FlameEnt, new Vector3(0.0f, 0.8f, -1.0f), Quaternion.Euler(0, -75, 0));
spawnFlame(FireworkEnt, new Vector3(0.0f, 0.8f, -1.0f), Quaternion.Euler(0, -45, 0));
break;
default:
break;
}
break;

case trailType.pink:
spawnSupplySignal(SupplyEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, 0, 0));
break;

case trailType.firework:
switch (data.preferences[driver.userID].count)
{
case 1:
spawnFirework(FireworkEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, 0, 0));
break;
case 2:
spawnFirework(FireworkEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, -30, 0));
spawnFirework(FireworkEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, 30, 0));
break;
case 3:
spawnFirework(FireworkEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, -30, 0));
spawnFirework(FireworkEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, 0, 0));
spawnFirework(FireworkEnt, new Vector3(0, 0.8f, -2), Quaternion.Euler(-90, 30, 0));
break;
default:
break;
}
break;
}

Effect.server.Run(WooshSound, mini.transform.position + new Vector3(0.0f, 0.9f, -2.0f));
}

public void clearTrail()
{
switch (data.preferences[driver.userID].type)
{
case trailType.fire:
foreach (BaseEntity s in anchors)
if (s != null) s.Kill();
anchors.Clear();
break;

case trailType.firework:
foreach (BaseEntity t in trails)
if (t != null) t.Kill();
trails.Clear();
break;

case trailType.pink:
trails[0].Kill();
trails.Clear();
break;
}
}

public MiniT(BaseVehicle _mini, BasePlayer _player)
{
mini = _mini;
driver = _player;
if (data.preferences.ContainsKey(_player.userID))
if (data.preferences[_player.userID].active)
spawnTrail();
}
}

private void OnEntityMounted(BaseVehicle mini, BasePlayer player)
{
if (mini == null || !mini.ShortPrefabName.Contains("minicopter") || !permission.UserHasPermission(player.UserIDString, PermUse)) return;
mini.OwnerID = player.userID;
if (MountedMinis.ContainsKey(player.userID))
MountedMinis.Remove(player.userID);
MountedMinis.Add(player.userID, new MiniT(mini, player));
}

private void OnEntityDismounted(BaseVehicle mini, BasePlayer player)
{
if (!MountedMinis.ContainsKey(player.userID)) return;
try
{
MountedMinis[player.userID].clearTrail();
MountedMinis.Remove(player.userID);
}
catch { }
}

private void OnEntityKill(BaseNetworkable entity)
{
if (!(entity is BaseVehicle mini) || !MountedMinis.ContainsKey(mini.OwnerID) || !data.preferences.ContainsKey(mini.OwnerID)) return;
if (!data.preferences[mini.OwnerID].active) return;
MountedMinis[mini.OwnerID].clearTrail();
MountedMinis.Remove(mini.OwnerID);
}

private void OnServerSave() => Interface.Oxide.DataFileSystem.WriteObject(Name, data);

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

private void Init()
{
data = Interface.Oxide.DataFileSystem.ReadObject<Data>(Name);
if (data == null)
{
data = new Data();
Interface.Oxide.DataFileSystem.WriteObject(Name, data);
}

permission.RegisterPermission(PermUse, this);
}

[ChatCommand("trail")]
private void cmdTrail(BasePlayer player, string command, string[] args)
{
if (!permission.UserHasPermission(player.UserIDString, PermUse))
{
SendChatMessage(player, lang.GetMessage("NoPerm", this, player.UserIDString));
return;
}

if (!data.preferences.ContainsKey(player.userID))
data.preferences.Add(player.userID, new Preferences());

if (args.Length == 0)
{
if (data.preferences[player.userID].active)
{
data.preferences[player.userID].active = false;
if (MountedMinis.ContainsKey(player.userID))
MountedMinis[player.userID].clearTrail();

SendChatMessage(player, lang.GetMessage("TrailOff", this, player.UserIDString));
}
else
{
data.preferences[player.userID].active = true;
if (MountedMinis.ContainsKey(player.userID))
MountedMinis[player.userID].spawnTrail();

SendChatMessage(player, lang.GetMessage("TrailOn", this, player.UserIDString));
}

return;
}
else if (args.Length == 1)
{
int newCount;
try
{
newCount = int.Parse(args[0]);
if (newCount > 0 && newCount < 4)
{
if (MountedMinis.ContainsKey(player.userID) && data.preferences[player.userID].active)
MountedMinis[player.userID].clearTrail();
data.preferences[player.userID].count = newCount;
if (MountedMinis.ContainsKey(player.userID) && data.preferences[player.userID].active)
MountedMinis[player.userID].spawnTrail();
SendChatMessage(player, lang.GetMessage("SetCount", this, player.UserIDString) + $" {args[0]}");
}
else
{
SendChatMessage(player, lang.GetMessage("InvalidTrailCount", this, player.UserIDString));
return;
}
}
catch (FormatException)
{
trailType newType = data.preferences[player.userID].type;
switch (args[0].ToLower())
{
case "fire":
newType = trailType.fire;
SendChatMessage(player, lang.GetMessage("SetFire", this, player.UserIDString));
break;
case "pink":
newType = trailType.pink;
SendChatMessage(player, lang.GetMessage("SetPink", this, player.UserIDString));
break;
case "firework":
newType = trailType.firework;
SendChatMessage(player, lang.GetMessage("SetFirework", this, player.UserIDString));
break;
default:
SendChatMessage(player, lang.GetMessage("UnknownArg", this, player.UserIDString) + $" \"{args[0]}\"");
return;
}
if (MountedMinis.ContainsKey(player.userID) && data.preferences[player.userID].active)
MountedMinis[player.userID].clearTrail();
data.preferences[player.userID].type = newType;
if (MountedMinis.ContainsKey(player.userID) && data.preferences[player.userID].active)
MountedMinis[player.userID].spawnTrail();
}
}
else SendChatMessage(player, lang.GetMessage("Syntax", this, player.UserIDString));
}

protected override void LoadDefaultMessages()
{
lang.RegisterMessages(new Dictionary<string, string>
{
["Prefix"] = "Mini Trails",
["Syntax"] =
"Invalid arguments\n" +
"<color=#00FF00>Usage:</color>\n" +
"/trail\t\t\t\t\t| toggle trail\n" +
"/trail [1-3]\t\t\t\t| set number of trails\n" +
"/trail [fire | pink]\t| set trail type",
["SetFire"] = "Trail set to fire",
["SetPink"] = "Trail set to pink smoke",
["SetFirework"] = "Trail set to firework",
["UnknownArg"] = "Unknown argument",
["InvalidTrailCount"] = "Invalid number of trails. Must be between 1 and 3",
["SetCount"] = "Trail count set to",
["TrailOn"] = "Trail toggled on!",
["TrailOff"] = "Trail toggled off",
["NoPerm"] = "You do not have permission to use this command",
["MessageHeader"] = "<color=#c21111>Rustic Rejects</color>: "
}, this);
}

void SendChatMessage(BasePlayer player, string msg) =>
SendReply(player, lang.GetMessage("MessageHeader", this, player.UserIDString) + msg);
}
}