public void SpawnBradley()
{
if (Object.op_Inequality((Object)this.spawned, (Object)null))
{
Debug.LogWarning((object)"Bradley attempting to spawn but one already exists!");
}
else
{
if (!Bradley.enabled)
{
return;
}
Vector3 position = ((Component)this.path.interestZones[Random.Range(0, this.path.interestZones.Count)]).get_transform().get_position();
BaseEntity entity = GameManager.server.CreateEntity(this.bradleyPrefab.resourcePath, position, (Quaternion)null, true);
BradleyAPC component = (BradleyAPC)((Component)entity).GetComponent <BradleyAPC>();
if (Object.op_Implicit((Object)component))
{
entity.Spawn();
component.InstallPatrolPath(this.path);
}
else
{
entity.Kill(BaseNetworkable.DestroyMode.None);
}
Debug.Log((object)("BradleyAPC Spawned at :" + (object)position));
this.spawned = component;
}
}
public void SpawnBradley()
{
if (this.spawned != null)
{
Debug.LogWarning("Bradley attempting to spawn but one already exists!");
return;
}
if (!Bradley.enabled)
{
return;
}
Vector3 item = this.path.interestZones[UnityEngine.Random.Range(0, this.path.interestZones.Count)].transform.position;
GameManager gameManager = GameManager.server;
string str = this.bradleyPrefab.resourcePath;
Quaternion quaternion = new Quaternion();
BaseEntity baseEntity = gameManager.CreateEntity(str, item, quaternion, true);
BradleyAPC component = baseEntity.GetComponent <BradleyAPC>();
if (!component)
{
baseEntity.Kill(BaseNetworkable.DestroyMode.None);
}
else
{
baseEntity.Spawn();
component.InstallPatrolPath(this.path);
}
Debug.Log(string.Concat("BradleyAPC Spawned at :", item));
this.spawned = component;
}
private object CanBradleyApcTarget(BradleyAPC apc, BaseEntity entity)
{
var player = entity as BasePlayer;
return(player == null || player.IsNpc || player.net?.connection == null || !IsLimited(player)
? (object)null
: false);
}
private object CanBradleyApcTarget(BradleyAPC apc, BaseEntity entity)
{
if (IsWearingBarrel(entity))
{
return(false);
}
return(null);
}
private void RemoveBradley(BradleyAPC bradley)
{
if (bradley == null || (bradley?.IsDestroyed ?? true))
{
return;
}
bradley.Kill();
}
public void DoSimpleAI()
{
if (base.isClient)
{
return;
}
base.SetFlag(BaseEntity.Flags.Reserved5, TOD_Sky.Instance.IsNight, false, true);
if (!this.DoAI)
{
return;
}
if (this.targetList.Count <= 0)
{
this.mainGunTarget = null;
this.UpdateMovement_Patrol();
}
else
{
if (!this.targetList[0].IsValid() || !this.targetList[0].IsVisible())
{
this.mainGunTarget = null;
}
else
{
this.mainGunTarget = this.targetList[0].entity as BaseCombatEntity;
}
this.UpdateMovement_Hunt();
}
this.AdvancePathMovement();
float single = Vector3.Distance(base.transform.position, this.destination);
float single1 = Vector3.Distance(base.transform.position, this.finalDestination);
if (single > this.stoppingDist)
{
Vector3 vector3 = BradleyAPC.Direction2D(this.destination, base.transform.position);
float single2 = Vector3.Dot(vector3, base.transform.right);
float single3 = Vector3.Dot(vector3, base.transform.right);
float single4 = Vector3.Dot(vector3, -base.transform.right);
if (Vector3.Dot(vector3, -base.transform.forward) <= single2)
{
this.turning = Mathf.Clamp(single2 * 3f, -1f, 1f);
}
else if (single3 < single4)
{
this.turning = -1f;
}
else
{
this.turning = 1f;
}
float single5 = 1f - Mathf.InverseLerp(0f, 0.3f, Mathf.Abs(this.turning));
float single6 = Mathf.InverseLerp(0.1f, 0.4f, Vector3.Dot(base.transform.forward, Vector3.up));
this.throttle = (0.1f + Mathf.InverseLerp(0f, 20f, single1) * 1f) * single5 + single6;
}
this.DoWeaponAiming();
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
// Hide from the bradley APC
private object CanBradleyApcTarget(BradleyAPC bradleyApc, BaseEntity entity)
{
var player = entity as BasePlayer;
if (player != null && IsInvisible(player))
{
return(false);
}
return(null);
}
private bool CanShowPanel(BradleyAPC bradley)
{
object result = Interface.Call("MagicPanelCanShow", Name, bradley);
if (result is bool)
{
return((bool)result);
}
return(true);
}
//apc
private object CanBradleyApcTarget(BradleyAPC apc, BaseEntity entity)
{
var basePlayer = entity as BasePlayer;
if (basePlayer != null && _data.Contains(basePlayer))
{
return(false);
}
return(null);
}
// Hide from the bradley APC
private object CanBradleyApcTarget(BradleyAPC apc, BaseEntity entity)
{
BasePlayer basePlayer = entity as BasePlayer;
if (IsInvisible(basePlayer))
{
return(false);
}
return(null);
}
bool CanBradleyApcTarget(BradleyAPC apc, BaseEntity entity)
{
BasePlayer player = entity as BasePlayer;
if (player != null && permission.UserHasPermission(player.UserIDString, permAllow) && (bool)Config["Turrets"])
{
return(false);
}
return(true);
}
private void OnEntitySpawned(BradleyAPC bradley)
{
NextTick(() =>
{
if (!CanShowPanel(bradley))
{
return;
}
_activeBradlys.Add(bradley);
CheckBradley();
});
}
public float GetPriorityScore(BradleyAPC apc)
{
BasePlayer basePlayer = this.entity as BasePlayer;
if (!basePlayer)
{
return(0f);
}
float single = Vector3.Distance(this.entity.transform.position, apc.transform.position);
float single1 = (1f - Mathf.InverseLerp(10f, 80f, single)) * 50f;
float single2 = Mathf.InverseLerp(4f, 20f, (basePlayer.GetHeldEntity() == null ? 0f : basePlayer.GetHeldEntity().hostileScore)) * 100f;
float single3 = Mathf.InverseLerp(10f, 3f, UnityEngine.Time.time - this.lastSeenTime) * 100f;
float single4 = Mathf.InverseLerp(0f, 100f, this.damageReceivedFrom) * 50f;
return(single1 + single2 + single4 + single3);
}
public float GetPriorityScore(BradleyAPC apc)
{
BasePlayer basePlayer = entity as BasePlayer;
if ((bool)basePlayer)
{
float value = Vector3.Distance(entity.transform.position, apc.transform.position);
float num = (1f - Mathf.InverseLerp(10f, 80f, value)) * 50f;
float value2 = ((basePlayer.GetHeldEntity() == null) ? 0f : basePlayer.GetHeldEntity().hostileScore);
float num2 = Mathf.InverseLerp(4f, 20f, value2) * 100f;
float num3 = Mathf.InverseLerp(10f, 3f, UnityEngine.Time.time - lastSeenTime) * 100f;
float num4 = Mathf.InverseLerp(0f, 100f, damageReceivedFrom) * 50f;
return(num + num2 + num4 + num3);
}
return(0f);
}
private object CanBradleyApcTarget(BradleyAPC bradley, BaseEntity target)
{
if (target is NPCPlayer)
{
return(false);
}
var player = target as BasePlayer;
if (player != null)
{
Vector3 mainTurretPosition = bradley.mainTurret.transform.position;
if (!(player.IsVisible(mainTurretPosition, bradley.CenterPoint()) || player.IsVisible(mainTurretPosition, player.eyes.position) || player.IsVisible(mainTurretPosition, player.transform.position)))
{
return(false);
}
if (!configs.options.targetsNakeds)
{
foreach (var item in player.inventory.containerWear.itemList)
{
if (configs.targetable.targetable.Contains(item.info.shortname) && !configs.targetable.nonTargetable.Contains(item.info.shortname))
{
return(true);
}
}
if (player.inventory.containerWear.itemList.Count > configs.targetable.mostClothing)
{
return(true);
}
foreach (var item in player.inventory.containerBelt.itemList)
{
if (configs.targetable.targetable.Contains(item.info.shortname) && !configs.targetable.nonTargetable.Contains(item.info.shortname))
{
return(true);
}
}
return(false);
}
}
return(bradley.IsVisible(target.CenterPoint()));
}
void OnBradleyApcInitialize(BradleyAPC apc)
{
if (!configData.alerts.bradleyAPC)
{
return;
}
NextTick(() =>
{
if (apc == null)
{
return;
}
SendMsg(Lang("BradleyAPC", null, GetLocation(apc.transform.position, null, null)));
});
}
private void Awake()
{
/*
* var paths = UnityEngine.Object.FindObjectsOfType<TerrainPath>();
* var allRoads = paths.Select(x => x.Roads);
* foreach (var road in allRoads)
* {
* foreach (var path in road)
* {
* var eachPathPoints = path.Path.Points;
* }
* }
*/
entity = GetComponent <BradleyAPC>();
entity.enabled = true;
entity.ClearPath();
entity.IsAtFinalDestination();
entity.searchRange = 100f;
entity.maxCratesToSpawn = 5;
entity._maxHealth = 300;
entity.health = 300;
}
void OnBradleyApcInitialize(BradleyAPC apc)
{
if (!configData.Alerts.BradleyAPC)
{
return;
}
if (apc == null)
{
return;
}
var pos = apc.transform.position;
string msg = Lang("BradleyAPC", null, GetLocation(pos, null, null));
Server.Broadcast(msg);
if (configData.Misc.LogToConsole)
{
Puts(msg);
}
if (configData.Misc.LogToFile)
{
LogToFile("log", $"[{DateTime.Now.ToString("HH:mm:ss")}] {msg}", this);
}
}
private bool CanBradleyApcTarget(BradleyAPC bradley, BaseEntity target)
{
if (target is NPCPlayer)
{
return(false);
}
var player = target as BasePlayer;
if (player != null)
{
var canNetwork = Vanish?.Call("IsInvisible", player);
if (canNetwork is bool)
{
if ((bool)canNetwork)
{
return(false);
}
}
}
return(true);
}
public void AdvancePathMovement()
{
if (!this.HasPath())
{
return;
}
if (this.AtCurrentPathNode() || this.currentPathIndex == -1)
{
this.currentPathIndex = this.GetLoopedIndex(this.currentPathIndex + 1);
}
if (this.PathComplete())
{
this.ClearPath();
return;
}
Vector3 vector3 = this.IdealPathPosition();
float single = Vector3.Distance(vector3, this.currentPath[this.currentPathIndex]);
float single1 = Vector3.Distance(base.transform.position, vector3);
float single2 = Mathf.InverseLerp(8f, 0f, single1);
vector3 = vector3 + (BradleyAPC.Direction2D(this.currentPath[this.currentPathIndex], vector3) * Mathf.Min(single, single2 * 20f));
this.SetDestination(vector3);
}
private void OnBradleyApcInitialize(BradleyAPC bradley)
{
bradley._maxHealth = configs.options.startHealth;
bradley.health = bradley._maxHealth;
bradley.viewDistance = configs.options.maxTurretRange;
bradley.searchRange = configs.options.maxTurretRange;
bradley.throttle = configs.options.speed; // TODO: Ensure Bradley speed.
bradley.leftThrottle = bradley.throttle;
bradley.rightThrottle = bradley.throttle;
bradley.maxCratesToSpawn = configs.options.maxLootCrates;
// Ensures there is a AI path to follow.
Vector3 position = BradleySpawner.singleton.path.interestZones[UnityEngine.Random.Range(0, BradleySpawner.singleton.path.interestZones.Count)].transform.position;
bradley.transform.position = position;
bradley.DoAI = true;
bradley.DoSimpleAI();
bradley.InstallPatrolPath(BradleySpawner.singleton.path);
if (!configs.options.bradleyEnabled)
{
bradley.Kill();
}
}
public void SpawnBradley()
{
if (spawned != null)
{
Debug.LogWarning("Bradley attempting to spawn but one already exists!");
}
else if (Bradley.enabled)
{
Vector3 position = path.interestZones[UnityEngine.Random.Range(0, path.interestZones.Count)].transform.position;
BaseEntity baseEntity = GameManager.server.CreateEntity(bradleyPrefab.resourcePath, position);
BradleyAPC component = baseEntity.GetComponent <BradleyAPC>();
if ((bool)component)
{
baseEntity.Spawn();
component.InstallPatrolPath(path);
}
else
{
baseEntity.Kill();
}
Debug.Log("BradleyAPC Spawned at :" + position);
spawned = component;
}
}
private object CanBradleyApcTarget(BradleyAPC apc, BasePlayer player) => IsInvisible(player) ? (object)false : null;
private void OnEntitySpawned(BradleyAPC entity)
{
HandleEntity(entity);
}
private void RustEdit_APCSpawned(BradleyAPC apc)
{
Puts("An APC was just spawned on a custom APC path");
}
