C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using Oxide.Core.Plugins;
using Oxide.Game.Rust.Cui;
using System;
using System.Collections.Generic;
using UnityEngine;
namespace Oxide.Plugins {
[Info("Heli Ride", "ColonBlow", "1.1.17")]
[Description("Allows players to fly the Patrol Helicopter")]
public class HeliRide : RustPlugin {
//Rust update fixes
#region Loadup
[PluginReference]
private Plugin Chute, Vanish;
public bool CockpitOverlay => Config.Get<bool>("Show Custom Cockpit Overlay");
public bool CrossHair => Config.Get<bool>("Show Custom Crosshair");
private static Dictionary<ulong, HeliData> HeliFlying = new Dictionary<ulong, HeliData>();
private static Dictionary<ulong, HeliDamage> DamagedHeli = new Dictionary<ulong, HeliDamage>();
private static Dictionary<ulong, HasParachute> AddParachute = new Dictionary<ulong, HasParachute>();
public class HeliData {
public BasePlayer player;
}
public class HeliDamage {
public BasePlayer player;
}
public class HasParachute {
public BasePlayer player;
}
private void Loaded() {
if (Chute == null) {
PrintWarning("Chute plugin not found.To enable player parachutes when there helicopter dies, install Chute plugin!");
}
if (Vanish == null) {
PrintWarning("Vanish plugin not found.Player will be visable and UseAutoVanish will be turned off");
UseAutoVanish = false;
}
LoadVariables();
permission.RegisterPermission("heliride.allowed", this);
}
#endregion
#region Configuration
private bool Changed;
private static bool ShowCockpitOverlay = true;
private static bool ShowCrosshair = true;
private static bool UseParachutes = true;
private static bool SpawnCrates = false;
private static bool UseAutoVanish = false;
private static double RocketDelay = 0.2;
private static float RocketMax = 36f;
private static float NapalmMax = 36f;
private static double RocketNapalmReloadTime = 20;
private static float BulletDamage = 50f;
private static string RocketPrefab = "assets/prefabs/npc/patrol helicopter/rocket_heli.prefab";
private static string NapalmPrefab = "assets/prefabs/npc/patrol helicopter/rocket_heli_napalm.prefab";
private void LoadConfigVariables() {
CheckCfg("ShowCockpitOverlay", ref ShowCockpitOverlay);
CheckCfg("ShowCrosshair", ref ShowCrosshair);
CheckCfg("UseParachutes", ref UseParachutes);
CheckCfg("SpawnCrates", ref SpawnCrates);
CheckCfg("UseAutoVanish", ref UseAutoVanish);
CheckCfg("RocketDelay", ref RocketDelay);
CheckCfg("RocketNapalmReloadTime", ref RocketNapalmReloadTime);
CheckCfgFloat("BulletDamage", ref BulletDamage);
CheckCfgFloat("Max Rockets Loaded", ref RocketMax);
CheckCfgFloat("Max Napalm Loaded", ref NapalmMax);
CheckCfg("Heli Rocket prefab : ", ref RocketPrefab);
CheckCfg("Heli Napam prefab : ", ref NapalmPrefab);
}
protected override void LoadDefaultConfig() {
Puts("Creating a new config file");
Config.Clear();
LoadVariables();
}
private void LoadVariables() {
LoadConfigVariables();
SaveConfig();
}
private void CheckCfg<T>(string Key, ref T var) {
if (Config[Key] is T) var = (T)Config[Key];
else Config[Key] = var;
}
private void CheckCfgFloat(string Key, ref float var) {
if (Config[Key] != null) var = Convert.ToSingle(Config[Key]);
else Config[Key] = var;
}
private object GetConfig(string menu, string datavalue, object defaultValue) {
var data = Config[menu] as Dictionary<string, object>;
if (data == null) {
data = new Dictionary<string, object>();
Config[menu] = data;
Changed = true;
}
object value;
if (!data.TryGetValue(datavalue, out value)) {
value = defaultValue;
data[datavalue] = value;
Changed = true;
}
return value;
}
#endregion
#region Localization
private new void LoadDefaultMessages() {
lang.RegisterMessages(new Dictionary<string, string> {
{
"noheli", "You are not flying a helicopter."
}
, {
"notallowed", "You are not allowed to access that command."
}
, {
"notflying", "You must be noclipping to activate Helicopter."
}
}
, this);
}
#endregion
#region Commands
[ChatCommand("flyheli")]
private void chatFlyHeli(BasePlayer player, string command, string[] args) {
string SteamID = player.userID.ToString();
if (isAllowed(player, "heliride.allowed")) {
var playerheli = player.GetComponent<FlyHelicopter>();
if (HeliFlying.ContainsKey(player.userID)) {
GameObject.Destroy(playerheli);
if (Vanish != null && UseAutoVanish) {
Vanish.Call("Reappear", player);
}
HeliFlying.Remove(player.userID);
return;
}
if (playerheli != null) {
GameObject.Destroy(playerheli);
if (Vanish != null && UseAutoVanish) {
Vanish.Call("Reappear", player);
}
HeliFlying.Remove(player.userID);
return;
}
if (playerheli == null) {
if (!player.IsFlying) {
SendReply(player, lang.GetMessage("notflying", this, SteamID));
return;
}
if (Vanish != null && UseAutoVanish) {
Vanish.Call("Disappear", player);
}
timer.Once(1f, () => AddHeli(player));
return;
}
}
if (!isAllowed(player, "heliride.allowed")) {
SendReply(player, lang.GetMessage("notallowed", this, SteamID));
}
}
[ConsoleCommand("flyheli")]
private void cmdConsoleFlyHeli(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Player();
string SteamID = player.userID.ToString();
if (isAllowed(player, "heliride.allowed")) {
var playerheli = player.GetComponent<FlyHelicopter>();
if (HeliFlying.ContainsKey(player.userID)) {
GameObject.Destroy(playerheli);
HeliFlying.Remove(player.userID);
if (Vanish != null && UseAutoVanish) {
Vanish.Call("Reappear", player);
}
return;
}
if (playerheli != null) {
GameObject.Destroy(playerheli);
if (Vanish != null && UseAutoVanish) {
Vanish.Call("Reappear", player);
}
HeliFlying.Remove(player.userID);
return;
}
if (playerheli == null) {
if (!player.IsFlying) {
SendReply(player, lang.GetMessage("notflying", this, SteamID));
return;
}
if (Vanish != null && UseAutoVanish) {
Vanish.Call("Disappear", player);
}
timer.Once(1f, () => AddHeli(player));
return;
}
}
if (!isAllowed(player, "heliride.allowed")) {
SendReply(player, lang.GetMessage("notallowed", this, SteamID));
}
}
[ConsoleCommand("showcockpit")]
private void cmdConsoleShowCockpit(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Player();
var playerheli = player.GetComponent<FlyHelicopter>();
if (!playerheli) {
string SteamID = player.userID.ToString();
SendReply(player, lang.GetMessage("noheli", this, SteamID));
return;
}
if (playerheli) {
playerheli.CockpitOverlay(player);
playerheli.CrosshairOverlay(player);
}
}
[ConsoleCommand("hidecockpit")]
private void cmdConsoleHideCockpit(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Player();
var playerheli = player.GetComponent<FlyHelicopter>();
if (!playerheli) {
string SteamID = player.userID.ToString();
SendReply(player, lang.GetMessage("noheli", this, SteamID));
return;
}
if (playerheli) {
CuiHelper.DestroyUi(player, "CockpitGuiOverlay");
CuiHelper.DestroyUi(player, "CrosshairGuiOverlay");
CuiHelper.DestroyUi(player, "DamageGuiOverlay");
}
}
#endregion
#region Hooks
private void OnEntityTakeDamage(BasePlayer player, HitInfo hitInfo) {
if (player == null || hitInfo == null) return;
if (HeliFlying.ContainsKey(player.userID)) {
hitInfo.damageTypes.ScaleAll(0);
}
}
private void OnPlayerTick(BasePlayer player) {
if (!UseParachutes) return;
if (UseParachutes) {
if (!AddParachute.ContainsKey(player.userID)) return;
if (AddParachute.ContainsKey(player.userID)) {
if (Chute != null) {
AddParachute.Remove(player.userID);
timer.Once(0.5f, () => Chute.Call("ExternalAddPlayerChute", player));
if (Vanish != null && UseAutoVanish) {
timer.Once(0.5f, () => Vanish.Call("Reappear", player));
}
}
if (Chute == null) {
AddParachute.Remove(player.userID);
}
}
}
}
private void AddHeli(BasePlayer player) {
if (player.IsFlying) {
player.gameObject.AddComponent<FlyHelicopter>();
HeliFlying.Add(player.userID, new HeliData {
player = player
}
);
return;
}
if (!player.IsFlying) {
string SteamID = player.userID.ToString();
SendReply(player, lang.GetMessage("notflying", this, SteamID));
}
}
private void Unload() {
DestroyAll<FlyHelicopter>();
foreach (var player in BasePlayer.activePlayerList) {
RemoveHeliComponents(player);
}
}
private static void DestroyAll<T>() {
var objects = GameObject.FindObjectsOfType(typeof(T));
if (objects != null) {
foreach (var gameObj in objects) {
GameObject.Destroy(gameObj);
}
}
}
private void RemoveHeliComponents(BasePlayer player) {
var playerheli = player.GetComponent<FlyHelicopter>();
if (playerheli != null) {
playerheli.DestroyCui(player);
GameObject.Destroy(playerheli);
}
}
private void OnPlayerDisconnected(BasePlayer player) {
RemoveHeliComponents(player);
}
private void OnPlayerRespawned(BasePlayer player) {
RemoveHeliComponents(player);
}
private bool isAllowed(BasePlayer player, string perm) => permission.UserHasPermission(player.UserIDString, perm);
#endregion
#region HeliRide Entity
private class FlyHelicopter : MonoBehaviour {
public BasePlayer player;
public BaseEntity helicopterBase;
private BaseEntity rockets;
public PatrolHelicopterAI heliAI;
public PatrolHelicopter heli;
public HelicopterTurret heliturret;
public InputState input;
private RaycastHit hitInfo;
public Vector3 PlayerPOS;
public Vector3 target;
public Vector3 CurrentPOS;
private Vector3 direction;
private float bulletDamage;
private float rocketMax;
private bool hasRockets;
private float napalmMax;
private bool hasNapalm;
private double rocketcycletimer;
private double reloadtimer;
private double rocketDelay;
private bool rocketcycle;
private bool leftTubeFiredLast;
private bool isReloading;
private double rocketNapalmReploadTime;
private void Awake() {
player = GetComponent<BasePlayer>();
if (player == null) {
OnDestroy();
return;
}
input = player.serverInput;
rocketcycletimer = 0.0;
reloadtimer = 0.0;
isReloading = false;
rocketNapalmReploadTime = RocketNapalmReloadTime;
rocketMax = RocketMax;
hasRockets = true;
napalmMax = NapalmMax;
hasNapalm = true;
rocketDelay = RocketDelay;
bulletDamage = BulletDamage;
rocketcycle = false;
PlayerPOS = player.transform.position + player.eyes.BodyForward() * 3f;
string prefab = "assets/prefabs/npc/patrol helicopter/patrolhelicopter.prefab";
helicopterBase = GameManager.server.CreateEntity(prefab);
heliAI = helicopterBase.GetComponent<PatrolHelicopterAI>();
heliAI.enabled = false;
heliturret = helicopterBase.GetComponent<HelicopterTurret>();
heli = helicopterBase.GetComponent<PatrolHelicopter>();
heli.OwnerID = player.userID;
heli.InitalizeWeakspots();
if (!SpawnCrates) heli.maxCratesToSpawn = 0;
heli.bulletDamage = bulletDamage;
heli.spotlightTarget = FindTarget(target);
helicopterBase.Spawn();
if (ShowCockpitOverlay) CockpitOverlay(player);
if (ShowCrosshair) CrosshairOverlay(player);
helicopterBase.transform.localPosition = PlayerPOS;
helicopterBase.transform.rotation = player.eyes.rotation;
}
//////////////////////////////////////////////////////////////////////////////////////
public void CockpitOverlay(BasePlayer player) {
var cockpitcui = new CuiElementContainer();
cockpitcui.Add(new CuiElement {
Name = "CockpitGuiOverlay", Components = {
new CuiRawImageComponent {
Color = "1 1 1 1", Url = "http://i.imgur.com/6O0hMC5.png", Sprite = "assets/content/textures/generic/fulltransparent.tga"
}
, new CuiRectTransformComponent {
AnchorMin = "0 0", AnchorMax = "1 1"
}
}
}
);
CuiHelper.AddUi(player, cockpitcui);
}
public void CrosshairOverlay(BasePlayer player) {
var crosshaircui = new CuiElementContainer();
crosshaircui.Add(new CuiElement {
Name = "CrosshairGuiOverlay", Components = {
new CuiRawImageComponent {
Color = "1 1 1 1", Url = "http://i.imgur.com/yweKHFT.png", Sprite = "assets/content/textures/generic/fulltransparent.tga"
}
, new CuiRectTransformComponent {
AnchorMin = "0.450 0.450", AnchorMax = "0.540 0.550"
}
}
}
);
CuiHelper.AddUi(player, crosshaircui);
}
public void DamageOverlay(BasePlayer player) {
var damageoverlay = new CuiElementContainer();
damageoverlay.Add(new CuiElement {
Name = "DamageGuiOverlay", Components = {
new CuiRawImageComponent {
Color = "1 1 1 1", Url = "http://i.imgur.com/XrpqTdP.png", Sprite = "assets/content/textures/generic/fulltransparent.tga"
}
, new CuiRectTransformComponent {
AnchorMin = "0.35 0.25", AnchorMax = "0.60 0.70"
}
}
}
);
CuiHelper.AddUi(player, damageoverlay);
}
public void HealthIndicator(BasePlayer player, float health) {
CuiHelper.DestroyUi(player, "HealthGui");
var healthstr = health.ToString();
var rocketstr = isReloading ? "R" : rocketMax.ToString();
var napalmstr = isReloading ? "R" : napalmMax.ToString();
var dispalystr = isReloading ? "Reloading " + healthstr + " Reloading" : "N: " + napalmstr + " " + healthstr + " R: " + rocketstr;
var healthindicator = new CuiElementContainer();
healthindicator.Add(new CuiButton {
Button = {
Command = "", Color = "0.0 0.0 0.0 1.0"
}
, RectTransform = {
AnchorMin = "0.40 0.15", AnchorMax = "0.60 0.18"
}
, Text = {
Text = dispalystr, FontSize = 18, Color = "1.0 0.0 0.0 0.2", Align = TextAnchor.MiddleCenter
}
}
, "Overall", "HealthGui");
CuiHelper.AddUi(player, healthindicator);
}
//////////////////////////////////////////////////////////////////////////////////////
private void FixedUpdate() {
player = GetComponent<BasePlayer>();
if (player.IsDead() || !player.IsFlying) {
heliAI._currentState = PatrolHelicopterAI.aiState.DEATH;
}
if (heliAI._currentState == PatrolHelicopterAI.aiState.DEATH) {
heliAI.enabled = true;
DestroyCui(player);
GameObject.Destroy(this);
return;
}
if (rocketMax <= 0) hasRockets = false;
if (napalmMax <= 0) hasNapalm = false;
Vector3 PlayerPOS = player.transform.position - player.eyes.BodyForward() * 5 + Vector3.down * 0.45f;
CurrentPOS = helicopterBase.transform.position;
Vector3 direction = Quaternion.Euler(input.current.aimAngles) * Vector3.fwd;
heli.spotlightTarget = FindTarget(target);
helicopterBase.transform.localPosition = PlayerPOS;
helicopterBase.transform.rotation = Quaternion.Lerp(helicopterBase.transform.rotation, player.eyes.rotation, 2f * Time.deltaTime);
helicopterBase.transform.eulerAngles = new Vector3(0, helicopterBase.transform.eulerAngles.y, 0);
BaseCombatEntity helientity = helicopterBase.GetComponent<BaseCombatEntity>();
float health = helientity.Health();
HealthIndicator(player, health);
if (health <= 3000f && ShowCockpitOverlay) {
if (!DamagedHeli.ContainsKey(player.userID)) {
if (ShowCockpitOverlay) {
DamageOverlay(player);
DamagedHeli.Add(player.userID, new HeliDamage {
player = player
}
);
}
}
}
if (isReloading) {
reloadtimer += Time.deltaTime;
if (reloadtimer >= rocketNapalmReploadTime) {
isReloading = false;
rocketMax = RocketMax;
hasRockets = true;
napalmMax = NapalmMax;
hasNapalm = true;
reloadtimer = 0.0;
}
}
if (rocketcycle) {
rocketcycletimer += Time.deltaTime;
if (rocketcycletimer >= rocketDelay) {
rocketcycle = false;
rocketcycletimer = 0.0;
}
}
if (health > 3000f && ShowCockpitOverlay) {
if (DamagedHeli.ContainsKey(player.userID)) {
CuiHelper.DestroyUi(player, "DamageGuiOverlay");
DamagedHeli.Remove(player.userID);
}
}
if (input.IsDown(BUTTON.RELOAD)) {
isReloading = true;
}
if (input.IsDown(BUTTON.DUCK)) {
Vector3 downPos = player.transform.position + Vector3.down * (UnityEngine.Time.deltaTime * 3f);
player.ClientRPCPlayer(null, player, "ForcePositionTo", downPos);
player.SendNetworkUpdate();
}
if (input.IsDown(BUTTON.FIRE_PRIMARY)) {
target = FindTarget(target);
FireGuns(target);
}
if (input.IsDown(BUTTON.FIRE_SECONDARY)) {
if (!hasRockets || isReloading) return;
if (!rocketcycle) {
leftTubeFiredLast = !leftTubeFiredLast;
FireRocket(leftTubeFiredLast, direction, PlayerPOS, true);
}
rocketcycle = true;
}
if (input.IsDown(BUTTON.FIRE_THIRD)) {
if (!hasNapalm || isReloading) return;
if (!rocketcycle) {
leftTubeFiredLast = !leftTubeFiredLast;
FireRocket(leftTubeFiredLast, direction, PlayerPOS, false);
}
rocketcycle = true;
}
}
private void FireGuns(Vector3 target) {
heliAI.FireGun(target, ConVar.PatrolHelicopter.bulletAccuracy, true);
heliAI.FireGun(target, ConVar.PatrolHelicopter.bulletAccuracy, false);
}
private void FireRocket(bool leftTubeFiredLast, Vector3 direction, Vector3 PlayerPOS, bool isrocket) {
RaycastHit hit;
string projectile;
if (isrocket) {
rocketMax = rocketMax - 1f;
}
if (!isrocket) {
napalmMax = napalmMax - 1f;
}
float num = 4f;
projectile = isrocket ? RocketPrefab : NapalmPrefab;
Vector3 origin = PlayerPOS + Vector3.down;
if (num > 0f) {
direction = (Vector3)(Quaternion.Euler(UnityEngine.Random.Range((float)(-num * 0.5f), (float)(num * 0.5f)), UnityEngine.Random.Range((float)(-num * 0.5f), (float)(num * 0.5f)), UnityEngine.Random.Range((float)(-num * 0.5f), (float)(num * 0.5f))) * direction);
}
float maxDistance = 1f;
if (Physics.Raycast(origin, direction, out hit, maxDistance, -1063040255)) {
maxDistance = hit.distance - 0.1f;
}
Transform transform = !leftTubeFiredLast ? heliAI.helicopterBase.rocket_tube_right.transform : heliAI.helicopterBase.rocket_tube_left.transform;
Effect.server.Run(heliAI.helicopterBase.rocket_fire_effect.resourcePath, heliAI.helicopterBase, StringPool.Get(!leftTubeFiredLast ? "rocket_tube_right" : "rocket_tube_left"), Vector3.zero, Vector3.forward, null, true);
Vector3 rocketPos = !leftTubeFiredLast ? heliAI.helicopterBase.rocket_tube_right.transform.position : heliAI.helicopterBase.rocket_tube_left.transform.position;
rockets = GameManager.server.CreateEntity(projectile, rocketPos);
rockets.creatorEntity = player;
if (rockets != null) {
rockets.SendMessage("InitializeVelocity", (Vector3)(direction * 50f));
rockets.Spawn();
}
}
private Vector3 FindTarget(Vector3 target) {
if (!UnityEngine.Physics.Raycast(player.eyes.HeadRay(), out hitInfo, Mathf.Infinity, -1063040255)) {
}
Vector3 hitpoint = hitInfo.point;
return hitpoint;
}
public void DestroyCui(BasePlayer player) {
CuiHelper.DestroyUi(player, "CockpitGuiOverlay");
CuiHelper.DestroyUi(player, "CrosshairGuiOverlay");
CuiHelper.DestroyUi(player, "DamageGuiOverlay");
CuiHelper.DestroyUi(player, "HealthGui");
DamagedHeli.Remove(player.userID);
}
private void addplayerchute() {
if (!UseParachutes) return;
AddParachute.Add(player.userID, new HasParachute {
player = player
}
);
}
public void OnDestroy() {
player = GetComponent<BasePlayer>();
DestroyCui(player);
DamagedHeli.Remove(player.userID);
HeliFlying.Remove(player.userID);
if (helicopterBase == null) return;
if (heliAI._currentState == PatrolHelicopterAI.aiState.DEATH) {
heliAI.enabled = true;
heli.bulletDamage = 0f;
GameObject.Destroy(this);
addplayerchute();
return;
}
helicopterBase.Kill();
GameObject.Destroy(this);
}
}
#endregion
}
}