What about support for flashbangs, molotovs, satchels and beancan grenades? Also good to add support for flares.

are you wanting to have someone to custom program those in?

Merged post

cuz ive rewritten it to work with flare, flashbang, f1, beancan, c4, satch, airdrop, anything throwable left clickable, and working on right clickable.

Well, I wait it from the plugin author. But If U already have edited plugin - You can share it with the community. If You want of couse.

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

namespace Oxide.Plugins
{
[Info("Weapon Trajectory", "MrWolfRanger", "1.0.5")] //Original author Jake_Rich, Reauthor Diana, Current author MrWolfRanger
[Description("Draws the trajectory of rockets and explosives.")]

public class WeaponTrajectory : RustPlugin
{
public static WeaponTrajectory _plugin;
public JSONFile<ConfigData> _settingsFile;
public ConfigData Settings { get { return _settingsFile.Instance; } }
public PlayerDataController<GrenadePlayerData> PlayerData;
public const float UpdateRate = 0.1f;
public const string Permission_Path = "weapontrajectory.show";

void Init()
{
_plugin = this;
}

void Loaded()
{
//Dont create empty config files
if (typeof(ConfigData).GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic).Length > 0)
{
_settingsFile = new JSONFile<ConfigData>($"{Name}", ConfigLocation.Config, extension: ".cfg");
}
PlayerData = new PlayerDataController<GrenadePlayerData>();

//Don't create empty lang files
if (lang_en.Count > 0)
{
lang.RegisterMessages(lang_en, this);
}

permission.RegisterPermission(Permission_Path, this);

timer.Every(UpdateRate, DoPlayerUpdate);
}

void Unload()
{
PlayerData.Unload();
}

public class ConfigData
{
public float GrenadeVelocityScale = 1.25f;
public float RocketVelocityScale = 1f;
public float HVRocketVelocityScale = 1f;
public float FireRocketVelocityScale = 1f;
public bool UsePermissions = true;
}

public class GrenadePlayerData : BasePlayerData
{

}

void DoPlayerUpdate()
{
foreach(var player in BasePlayer.activePlayerList)
{
try
{
CheckPlayerInput(player);
}
catch
{

}
}
}

void CheckPlayerInput(BasePlayer player)
{
if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
//f1 grenade
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "grenade.f1")
{
DrawGrenadePath(player);
}
}
if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
// molotov
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "grenade.molotov")
{
DrawGrenadePath(player);
}
}
if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
//flashbang
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "grenade.flashbang")
{
DrawGrenadePath(player);
}
}
if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
//flare
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "flare")
{
DrawGrenadePath(player);
}
}

if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
//grenade.smoke
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "grenade.smoke")
{
DrawGrenadePath(player);
}
}
if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
//supply.signal
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "supply.signal")
{
DrawGrenadePath(player);
}
}
if (player.serverInput.IsDown(BUTTON.FIRE_PRIMARY))
//grenade.beancan
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "grenade.beancan")
{
DrawGrenadePath(player);
}
}

else if (player.serverInput.IsDown(BUTTON.FIRE_SECONDARY))
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "rocket.launcher")
{
DrawRocketPath(player, heldItem.GetHeldEntity() as BaseLauncher);
}
else if(heldItem.info.shortname == "explosive.timed")
{
DrawGrenadePath(player);
}
}
{
var heldItem = player.GetActiveItem();
if (heldItem.info.shortname == "rocket.launcher")
{
DrawRocketPath(player, heldItem.GetHeldEntity() as BaseLauncher);
}
else if(heldItem.info.shortname == "explosive.satchel")
{
DrawGrenadePath(player);
}
}
}

void DrawGrenadePath(BasePlayer player)
{
if (Settings.UsePermissions)
{
if (!permission.UserHasPermission(player.UserIDString, Permission_Path) && !player.IsAdmin)
{
return;
}
}
//Puts($"{comp.maxThrowVelocity}");
//DrawArrow(player, UpdateRate, Color.green, player.eyes.position, player.eyes.position + player.eyes.BodyForward());
List<Vector3> list = Pool.GetList<Vector3>();
DoMovement(list, player.eyes.position, (player.eyes.BodyForward() * 13 + player.estimatedVelocity * 0.5f) * Settings.GrenadeVelocityScale);
for (int i = 0; i < list.Count - 1; i++)
{
DrawArrow(player, UpdateRate, Color.green, list[i], list[i+1]);
}
Pool.FreeList(ref list);
}

void DrawRocketPath(BasePlayer player,BaseLauncher launcher)
{
if (Settings.UsePermissions)
{
if (!permission.UserHasPermission(player.UserIDString, Permission_Path) && !player.IsAdmin)
{
return;
}
}
if (launcher.primaryMagazine.contents == 0)
{
return;
}

var ammoType = launcher.primaryMagazine.ammoType.GetComponent<ItemModProjectile>().projectileObject.Get().GetComponent<ServerProjectile>();

float velocityScale = Settings.RocketVelocityScale;
if (launcher.primaryMagazine.ammoType.shortname == "ammo.rocket.hv")
{
velocityScale = Settings.HVRocketVelocityScale;
}
else if (launcher.primaryMagazine.ammoType.shortname == "ammo.rocket.fire")
{
velocityScale = Settings.FireRocketVelocityScale;
}

List<Vector3> list = Pool.GetList<Vector3>();
float step = 0.3f;
DoMovement(list, player.eyes.position + (player.eyes.BodyForward() * ammoType.speed) * velocityScale * step, (player.eyes.BodyForward() * ammoType.speed) * velocityScale, step, 30, ammoType.gravityModifier);
for (int i = 0; i < list.Count - 1; i++)
{
DrawArrow(player, UpdateRate, Color.green, list[i], list[i + 1]);
}
Pool.FreeList(ref list);
}

void OnExplosiveThrown(BasePlayer player, BaseEntity entity)
{
if (entity.ShortPrefabName == "grenade.f1.deployed" || entity.ShortPrefabName == "explosive.timed.deployed")
{
entity.SetVelocity(entity.GetComponent<Rigidbody>().velocity * Settings.GrenadeVelocityScale);
}

//if(entity.ShortPrefabName == "explosive.timed.deployed")
//{
// entity.SetVelocity(entity.GetComponent<Rigidbody>().velocity * Settings.GrenadeVelocityScale);
//}
}

void OnRocketLaunched(BasePlayer player, BaseEntity entity)
{
var rocket = entity as TimedExplosive;
if (rocket == null)
{
return;
}
var projectile = rocket.GetComponent<ServerProjectile>();
float velocityScale = Settings.RocketVelocityScale;
if (entity.ShortPrefabName == "rocket_hv")
{
velocityScale = Settings.HVRocketVelocityScale;
}
else if (entity.ShortPrefabName == "rocket_fire")
{
velocityScale = Settings.FireRocketVelocityScale;
}
projectile.CurrentVelocity *= velocityScale;
Puts(entity.ShortPrefabName);
//rocket.explosionEffect.
//assets/prefabs/npc/patrol helicopter/effects/rocket_explosion.prefab
}

private void DoMovement(List<Vector3> output, Vector3 currentPos, Vector3 currentVelocity, float step = 0.1f, int maxSteps = 20, float gravityModifier = 1f)
{
for(int i = 0; i < maxSteps; i++)
{
output.Add(currentPos);
//DoMovement

currentVelocity += Physics.gravity * gravityModifier * step;
currentPos = currentPos + currentVelocity * step;

//Update velocity

//currentVelocity -= currentVelocity.normalized * (currentVelocity.magnitude * this.drag * step);
}
output.Add(currentPos);
}

private class VelocityUpdate
{
public Vector3 Position;
public Vector3 Velocity;
}

void OnFrame()
{
SendDDrawCommands();
}

#region DDraw

private static Dictionary<BasePlayer, List<string>> DDrawCommandQueue = new Dictionary<BasePlayer, List<string>>();

private static void QueueDDrawCommand(BasePlayer player, string command, params object[] args)
{
List<string> list;
if (!DDrawCommandQueue.TryGetValue(player, out list))
{
list = new List<string>();
DDrawCommandQueue.Add(player, list);
}
list.Add(ConsoleSystem.BuildCommand(command, args));
}

public static void DrawCube(BasePlayer player, float duration, UnityEngine.Color color, Vector3 position, float size = 1)
{
QueueDDrawCommand(player, "ddraw.box", duration, color, position, size);
}

public static void DrawBox(BasePlayer player, float duration, UnityEngine.Color color, Vector3 min, Vector3 max)
{
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, min.y, min.z), new Vector3(min.x, min.y, max.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, min.y, min.z), new Vector3(min.x, max.y, min.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, min.y, min.z), new Vector3(max.x, min.y, min.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(max.x, max.y, max.z), new Vector3(max.x, max.y, min.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(max.x, max.y, max.z), new Vector3(max.x, min.y, max.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(max.x, max.y, max.z), new Vector3(min.x, max.y, max.z));

QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, max.y, min.z), new Vector3(min.x, max.y, max.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, max.y, min.z), new Vector3(max.x, max.y, min.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(max.x, min.y, min.z), new Vector3(max.x, max.y, min.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(max.x, min.y, min.z), new Vector3(max.x, min.y, max.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, min.y, max.z), new Vector3(max.x, min.y, max.z));
QueueDDrawCommand(player, "ddraw.line", duration, color, new Vector3(min.x, min.y, max.z), new Vector3(min.x, max.y, max.z));
}

public static void DrawText(BasePlayer player, string text, float duration, UnityEngine.Color color, Vector3 position, int size = 12)
{
QueueDDrawCommand(player, "ddraw.text", duration, color, position, size == 12 ? text : $"<size={size}>{text.Replace("\n", "\\n")}</size>");
}

public static void DrawSphere(BasePlayer player, float duration, UnityEngine.Color color, Vector3 position, float size)
{
QueueDDrawCommand(player, "ddraw.sphere", duration, color, position, size);
}

public static void DrawArrow(BasePlayer player, float duration, Color color, Vector3 start, Vector3 end)
{
QueueDDrawCommand(player, "ddraw.arrow", duration, color, start, end, 0.1);
}

public void SendDDrawCommands()
{
if (DDrawCommandQueue.Count == 0)
{
return;
}
foreach (var request in DDrawCommandQueue)
{
if (request.Key == null)
{
continue;
}
bool fakeAdmin = request.Key.IsAdmin == false;
if (fakeAdmin)
{
request.Key.SetPlayerFlag(BasePlayer.PlayerFlags.IsAdmin, true);
request.Key.SendNetworkUpdateImmediate();
}
foreach (var cmd in request.Value)
{
request.Key.SendConsoleCommand(cmd);
}
if (fakeAdmin)
{
request.Key.SetPlayerFlag(BasePlayer.PlayerFlags.IsAdmin, false);
request.Key.SendNetworkUpdateImmediate();
}
}
DDrawCommandQueue.Clear();
}

#endregion

#region Lang API

public Dictionary<string, string> lang_en = new Dictionary<string, string>()
{

};

public static string GetLangMessage(string key, BasePlayer player)
{
return _plugin.lang.GetMessage(key, _plugin, player.UserIDString);
}

public static string GetLangMessage(string key, ulong player)
{
return _plugin.lang.GetMessage(key, _plugin, player.ToString());
}

public static string GetLangMessage(string key, string player)
{
return _plugin.lang.GetMessage(key, _plugin, player);
}

#endregion

#region PlayerData

public class BasePlayerData
{
[JsonIgnore]
public BasePlayer Player { get; set; }

public string userID { get; set; } = "";

public BasePlayerData()
{

}
public BasePlayerData(BasePlayer player) : base()
{
userID = player.UserIDString;
Player = player;
}
}

public class PlayerDataController<T> where T : BasePlayerData
{
[JsonPropertyAttribute(Required = Required.Always)]
private Dictionary<string, T> playerData { get; set; } = new Dictionary<string, T>();
private JSONFile<Dictionary<string, T>> _file;
private Timer _timer;
public IEnumerable<T> All { get { return playerData.Values; } }

public PlayerDataController()
{

}

public PlayerDataController(string filename = null)
{
if (filename == null)
{
return;
}
_file = new JSONFile<Dictionary<string, T>>(filename);
_timer = _plugin.timer.Every(120f, () =>
{
_file.Save();
});
}

public void Unload()
{
if (_file == null)
{
return;
}
_file.Save();
}

public T Get(string identifer)
{
T data;
if (!playerData.TryGetValue(identifer, out data))
{
data = Activator.CreateInstance<T>();
playerData[identifer] = data;
}
return data;
}

public T Get(ulong userID)
{
return Get(userID.ToString());
}

public T Get(BasePlayer player)
{
var data = Get(player.UserIDString);
data.Player = player;
return data;
}

public bool Has(ulong userID)
{
return playerData.ContainsKey(userID.ToString());
}

public void Set(string userID, T data)
{
playerData[userID] = data;
}

public bool Remove(string userID)
{
return playerData.Remove(userID);
}

public void Update(T data)
{
playerData[data.userID] = data;
}
}

#endregion

#region Configuration Files

public enum ConfigLocation
{
Data = 0,
Config = 1,
Logs = 2,
Plugins = 3,
Lang = 4,
Custom = 5,
}

public class JSONFile<Type> where Type : class
{
private DynamicConfigFile _file;
public string _name { get; set; }
public Type Instance { get; set; }
private ConfigLocation _location { get; set; }
private string _path { get; set; }

public JSONFile(string name, ConfigLocation location = ConfigLocation.Data, string path = null, string extension = ".json")
{
_name = name.Replace(".json", "");
_location = location;
switch (location)
{
case ConfigLocation.Data:
{
_path = $"{Oxide.Core.Interface.Oxide.DataDirectory}/{name}{extension}";
break;
}
case ConfigLocation.Config:
{
_path = $"{Oxide.Core.Interface.Oxide.ConfigDirectory}/{name}{extension}";
break;
}
case ConfigLocation.Logs:
{
_path = $"{Oxide.Core.Interface.Oxide.LogDirectory}/{name}{extension}";
break;
}
case ConfigLocation.Lang:
{
_path = $"{Oxide.Core.Interface.Oxide.LangDirectory}/{name}{extension}";
break;
}
case ConfigLocation.Custom:
{
_path = $"{path}/{name}{extension}";
break;
}
}
_file = new DynamicConfigFile(_path);
_file.Settings = new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore };
Init();
}

public virtual void Init()
{
Load();
Save();
Load();
}

public virtual void Load()
{

if (!_file.Exists())
{
Save();
}
Instance = _file.ReadObject<Type>();
if (Instance == null)
{
Instance = Activator.CreateInstance<Type>();
Save();
}
return;
}

public virtual void Save()
{
_file.WriteObject(Instance);
return;
}

public virtual void Reload()
{
Load();
}

private void Unload(Plugin sender, PluginManager manager)
{

}
}

#endregion

}
}

Merged post

im tired of seeing dead and dying plugins, at least i fix them, including Killstreak and Airstrike and many dead ones including canabail.

hi, could you update it for the grenade launcher and rocket.launcher.dragon? Thank you!