public static void PhysicsChanged(GameObject obj)
{
Collider component = (Collider)obj.GetComponent <Collider>();
if (!Object.op_Implicit((Object)component))
{
return;
}
Bounds bounds = component.get_bounds();
List <BaseEntity> list1 = (List <BaseEntity>)Pool.GetList <BaseEntity>();
Vector3 center = ((Bounds) ref bounds).get_center();
Vector3 extents = ((Bounds) ref bounds).get_extents();
double num = (double)((Vector3) ref extents).get_magnitude() + 1.0;
List <BaseEntity> list2 = list1;
Vis.Entities <BaseEntity>(center, (float)num, list2, 2228480, (QueryTriggerInteraction)2);
foreach (BaseEntity baseEntity in list1)
{
if (!baseEntity.IsDestroyed && !baseEntity.isClient && !(baseEntity is BuildingBlock))
{
((Component)baseEntity).BroadcastMessage("OnPhysicsNeighbourChanged", (SendMessageOptions)1);
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
}
protected override void RunJob(Bounds bounds)
{
if (!ConVar.Server.stability)
{
return;
}
List <BaseEntity> list = Facepunch.Pool.GetList <BaseEntity>();
Vector3 vector3 = bounds.center;
Vector3 vector31 = bounds.extents;
Vis.Entities <BaseEntity>(vector3, vector31.magnitude + 1f, list, 2228480, QueryTriggerInteraction.Collide);
foreach (BaseEntity baseEntity in list)
{
if (baseEntity.IsDestroyed || baseEntity.isClient)
{
continue;
}
if (!(baseEntity is StabilityEntity))
{
baseEntity.BroadcastMessage("OnPhysicsNeighbourChanged", SendMessageOptions.DontRequireReceiver);
}
else
{
(baseEntity as StabilityEntity).OnPhysicsNeighbourChanged();
}
}
Facepunch.Pool.FreeList <BaseEntity>(ref list);
}
void DestroyRemoteCarpet(BasePlayer player)
{
if (player == null)
{
return;
}
List <BaseEntity> carpetlist = new List <BaseEntity>();
Vis.Entities <BaseEntity>(new Vector3(0, 0, 0), 3500f, carpetlist);
bool foundcarpet = false;
foreach (BaseEntity p in carpetlist)
{
var foundent = p.GetComponentInParent <CarpetEntity>() ?? null;
if (foundent != null)
{
foundcarpet = true;
if (foundent.ownerid != player.userID)
{
return;
}
foundent.entity.Kill(BaseNetworkable.DestroyMode.Gib);
PrintMsgL(player, "carpetdestroyed");
}
}
if (!foundcarpet)
{
PrintMsgL(player, "notfound", MinDistance.ToString());
}
}
private List <BaseEntity> FindObjects(Vector3 startPos, string entity, RemoveOptions options)
{
var entities = new List <BaseEntity>();
if (options.Radius > 0)
{
var entitiesList = new List <BaseEntity>();
Vis.Entities(startPos, options.Radius, entitiesList);
var entitiesCount = entitiesList.Count;
for (var i = entitiesCount - 1; i >= 0; i--)
{
var ent = entitiesList[i];
if (IsNeededObject(ent, entity, options))
{
entities.Add(ent);
}
}
}
else
{
var ents = UnityEngine.Object.FindObjectsOfType <BaseEntity>();
var entsCount = ents.Length;
for (var i = 0; i < entsCount; i++)
{
var ent = ents[i];
if (IsNeededObject(ent, entity, options))
{
entities.Add(ent);
}
}
}
return(entities);
}
void RaiderBlock(string source, string target, Vector3 position, List <string> sourceMembers = null)
{
var targetMembers = new List <string>();
if ((raiderClanShare || raiderFriendShare) && sourceMembers == null)
{
sourceMembers = getFriends(source);
}
var nearbyTargets = new List <BasePlayer>();
Vis.Entities <BasePlayer>(position, raidDistance, nearbyTargets, blockLayer);
if (nearbyTargets.Count > 0)
{
foreach (BasePlayer nearbyTarget in nearbyTargets)
{
if (ShouldBlockEscape(target, source, sourceMembers) &&
(
nearbyTarget.UserIDString == source ||
(
sourceMembers != null &&
sourceMembers.Contains(nearbyTarget.UserIDString)
)
)
)
{
StartRaidBlocking(nearbyTarget.UserIDString, position);
}
}
}
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BuildingBlock> list1 = (List <BuildingBlock>)Pool.GetList <BuildingBlock>();
double sphereRadius = (double)this.sphereRadius;
List <BuildingBlock> list2 = list1;
int layerMask = ((LayerMask) ref this.layerMask).get_value();
QueryTriggerInteraction queryTriggers = this.queryTriggers;
Vis.Entities <BuildingBlock>(position, (float)sphereRadius, list2, layerMask, queryTriggers);
bool flag = list1.Count > 0;
if (flag && this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list1);
return(true);
}
if (flag && !this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list1);
return(false);
}
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list1);
return(!this.wantsCollide);
}
void OwnerBlock(string source, string target, UnityEngine.Vector3 position, List <string> sourceMembers = null)
{
var targetMembers = new List <string>();
if (clanShare || friendShare)
{
targetMembers = getFriends(target);
}
var nearbyTargets = new List <BasePlayer>();
Vis.Entities <BasePlayer>(position, raidDistance, nearbyTargets, blockLayer);
if (nearbyTargets.Count > 0)
{
foreach (BasePlayer nearbyTarget in nearbyTargets)
{
if (ShouldBlockEscape(target, source, sourceMembers) &&
(
nearbyTarget.UserIDString == target ||
(
targetMembers != null &&
targetMembers.Contains(nearbyTarget.UserIDString)
)
)
)
{
StartRaidBlocking(nearbyTarget.UserIDString);
}
}
}
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BaseEntity> list1 = (List <BaseEntity>)Pool.GetList <BaseEntity>();
double sphereRadius = (double)this.sphereRadius;
List <BaseEntity> list2 = list1;
int layerMask = ((LayerMask) ref this.layerMask).get_value();
QueryTriggerInteraction queryTriggers = this.queryTriggers;
Vis.Entities <BaseEntity>(position, (float)sphereRadius, list2, layerMask, queryTriggers);
foreach (BaseEntity baseEntity in list1)
{
BaseEntity ent = baseEntity;
bool flag = ((IEnumerable <BaseEntity>) this.entityTypes).Any <BaseEntity>((Func <BaseEntity, bool>)(x => (int)x.prefabID == (int)ent.prefabID));
if (flag && this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(true);
}
if (flag && !this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(false);
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(!this.wantsCollide);
}
object GetSpawnPoint(int attempt = 0)
{
if (attempt >= 10)
{
return(null);
}
var position = remainingPoints.GetRandom();
List <BaseEntity> entities = Facepunch.Pool.GetList <BaseEntity>();
Vis.Entities(position, configData.Detect, entities, LayerMask.GetMask("Construction", "Deployable"));
int count = entities.Count;
Facepunch.Pool.FreeList(ref entities);
remainingPoints.Remove(position);
if (remainingPoints.Count == 0)
{
remainingPoints = new List <Vector3>(spawnPoints);
}
if (count > 0)
{
return(GetSpawnPoint(++attempt));
}
return(position);
}
// Code stolen from Assembly-CSharp.dll -> BasePlayer.cs
public static BuildingPrivlidge GetBuildingPrivilege(OBB obb)
{
BuildingBlock buildingBlock1 = (BuildingBlock)null;
BuildingPrivlidge buildingPrivlidge = (BuildingPrivlidge)null;
System.Collections.Generic.List <BuildingBlock> list = Facepunch.Pool.GetList <BuildingBlock>();
Vis.Entities <BuildingBlock>(obb.position, 16f + obb.extents.magnitude, list, 2097152, QueryTriggerInteraction.Collide);
for (int index = 0; index < list.Count; ++index)
{
BuildingBlock buildingBlock2 = list[index];
if (buildingBlock2.IsOlderThan((BaseEntity)buildingBlock1) && (double)obb.Distance(buildingBlock2.WorldSpaceBounds()) <= 16.0)
{
BuildingManager.Building building = buildingBlock2.GetBuilding();
if (building != null)
{
BuildingPrivlidge buildingPrivilege = building.GetDominatingBuildingPrivilege();
if (!((UnityEngine.Object)buildingPrivilege == (UnityEngine.Object)null))
{
buildingBlock1 = buildingBlock2;
buildingPrivlidge = buildingPrivilege;
}
}
}
}
Facepunch.Pool.FreeList <BuildingBlock>(ref list);
return(buildingPrivlidge);
}
void CheckWherePlaced(BaseEntity cupboard, BaseEntity entity, BasePlayer player, string found)
{
if (debug)
{
Puts($"CheckWherePlaced");
}
List <BaseEntity> wotsaround = new List <BaseEntity>();
Vis.Entities(new Vector3(entity.transform.position.x, entity.transform.position.y + 0.5f, entity.transform.position.z), 1, wotsaround);
if (debug)
{
Puts($"processing one foundation entity");
}
foreach (BaseEntity foundentity in wotsaround)
{
if (foundentity.ShortPrefabName.Contains("cupboard"))
{
if (found == "floor")
{
CancelThisCupboard(cupboard, player);
return;
}
if (debug)
{
Puts($"placing a cupboard");
}
}
}
}
private bool SpawnJunkPileWater()
{
var position = GetPosition(true);
if (position == null)
{
return(false);
}
var jp = new List <JunkPileWater>();
Vis.Entities(position.Value, _config.JunkPileRange, jp);
if (jp.Count > 0)
{
return(false);
}
var entity = GameManager.server.CreateEntity(PrefabsJunkPile[Random.Next(0, PrefabsJunkPile.Length - 1)],
position.Value, GetRotation(true)) as JunkPileWater;
if (entity == null)
{
return(true);
}
entity.gameObject.AddComponent <JunkPileWaterController>();
entity.Spawn();
return(true);
}
private bool SpawnDiveSite()
{
var position = GetPosition(false);
if (position == null)
{
return(false);
}
var ds = new List <DiveSite>();
Vis.Entities(position.Value, _config.DiveSiteRange, ds);
if (ds.Count > 0)
{
return(false);
}
var entity =
GameManager.server.CreateEntity(PrefabsDiveSite[Random.Next(0, PrefabsDiveSite.Length - 1)],
position.Value, GetRotation(false)) as DiveSite;
if (entity == null)
{
return(true);
}
entity.gameObject.AddComponent <DiveSiteController>();
entity.Spawn();
return(true);
}
private bool CheckBadBuilding(Vector3 position)
{
var buildings = new List <BuildingBlock>();
Vis.Entities(position, _config.DistanceBuilding, buildings, Layers.Construction);
return(buildings.Count > 0);
}
private bool IsValidForBuilding(Vector3 position)
{
_listBuildingBlocks.Clear();
Vis.Entities(position, _config.DistanceBuilding, _listBuildingBlocks, Layers.Construction);
return(_listBuildingBlocks.Count <= 0);
}
public void GatherStaticCameras()
{
if (Rust.Application.isLoadingSave)
{
Invoke(GatherStaticCameras, 1f);
}
else
{
if (!isStatic || !(autoGatherRadius > 0f))
{
return;
}
List <BaseEntity> obj = Facepunch.Pool.GetList <BaseEntity>();
Vis.Entities(base.transform.position, autoGatherRadius, obj, 256, QueryTriggerInteraction.Ignore);
foreach (BaseEntity item in obj)
{
IRemoteControllable component = item.GetComponent <IRemoteControllable>();
if (component != null)
{
CCTV_RC component2 = item.GetComponent <CCTV_RC>();
if ((!component2 || component2.IsStatic()) && !controlBookmarks.ContainsKey(component.GetIdentifier()))
{
ForceAddBookmark(component.GetIdentifier());
}
}
}
Facepunch.Pool.FreeList(ref obj);
}
}
public void Greeting()
{
List <BasePlayer> list = (List <BasePlayer>)Pool.GetList <BasePlayer>();
Vis.Entities <BasePlayer>(((Component)this).get_transform().get_position(), 10f, list, 131072, (QueryTriggerInteraction)2);
((Component)this).get_transform().get_position();
BasePlayer basePlayer1 = (BasePlayer)null;
foreach (BasePlayer basePlayer2 in list)
{
if (!basePlayer2.isClient && !basePlayer2.IsNpc && (!Object.op_Equality((Object)basePlayer2, (Object)this) && basePlayer2.IsVisible(this.eyes.position, float.PositiveInfinity)) && (!Object.op_Equality((Object)basePlayer2, (Object)this.lastWavedAtPlayer) && (double)Vector3.Dot(Vector3Ex.Direction2D(basePlayer2.eyes.position, this.eyes.position), this.initialFacingDir) >= 0.200000002980232))
{
basePlayer1 = basePlayer2;
break;
}
}
if (Object.op_Equality((Object)basePlayer1, (Object)null) && !list.Contains(this.lastWavedAtPlayer))
{
this.lastWavedAtPlayer = (BasePlayer)null;
}
if (Object.op_Inequality((Object)basePlayer1, (Object)null))
{
this.SignalBroadcast(BaseEntity.Signal.Gesture, "wave", (Connection)null);
this.SetAimDirection(Vector3Ex.Direction2D(basePlayer1.eyes.position, this.eyes.position));
this.lastWavedAtPlayer = basePlayer1;
}
else
{
this.SetAimDirection(this.initialFacingDir);
}
// ISSUE: cast to a reference type
Pool.FreeList <BasePlayer>((List <M0>&) ref list);
}
List <BasePlayer> GetAroundPlayers(Vector3 position)
{
var coliders = new List <BaseEntity>();
Vis.Entities(position, radius, coliders, Rust.Layers.Server.Players);
return(coliders.OfType <BasePlayer>().ToList());
}
public override void ServerInit()
{
blockDefinition = PrefabAttribute.server.Find <Construction>(prefabID);
if (blockDefinition == null)
{
Debug.LogError("Couldn't find Construction for prefab " + prefabID);
}
base.ServerInit();
UpdateSkin();
if (HasFlag(Flags.Reserved1) || !Rust.Application.isLoadingSave)
{
StartBeingRotatable();
}
if (HasFlag(Flags.Reserved2) || !Rust.Application.isLoadingSave)
{
StartBeingDemolishable();
}
if (!CullBushes || Rust.Application.isLoadingSave)
{
return;
}
List <BushEntity> obj = Facepunch.Pool.GetList <BushEntity>();
Vis.Entities(WorldSpaceBounds(), obj, 67108864);
foreach (BushEntity item in obj)
{
if (item.isServer)
{
item.Kill();
}
}
Facepunch.Pool.FreeList(ref obj);
}
List <ulong> GetOwnersByOwner(ulong owner, Vector3 position)
{
var coliders = new List <BaseEntity>();
Vis.Entities(position, radius, coliders, Rust.Layers.Server.Deployed);
var codelocks =
coliders.OfType <BoxStorage>()
.Select(s => s.GetSlot(BaseEntity.Slot.Lock))
.OfType <CodeLock>()
.ToList();
var owners = new HashSet <ulong>();
foreach (var codelock in codelocks)
{
var whitelist = codelock.whitelistPlayers;
if (whitelist == null)
{
continue;
}
if (!whitelist.Contains(owner))
{
continue;
}
foreach (var uid in whitelist)
{
if (uid != owner)
{
owners.Add(uid);
}
}
}
return(owners.ToList());
}
private static IEnumerator GetNearbyEntities <T>(T sourceEntity, HashSet <T> entities, int layers, Func <T, bool> filter = null) where T : BaseEntity
{
int current = 0;
var checkFrom = Pool.Get <Queue <Vector3> >();
var nearbyEntities = Pool.GetList <T>();
checkFrom.Enqueue(sourceEntity.transform.position);
while (checkFrom.Count > 0)
{
nearbyEntities.Clear();
var position = checkFrom.Dequeue();
Vis.Entities(position, 3f, nearbyEntities, layers);
for (var i = 0; i < nearbyEntities.Count; i++)
{
var entity = nearbyEntities[i];
if (filter != null && !filter(entity))
{
continue;
}
if (!entities.Add(entity))
{
continue;
}
checkFrom.Enqueue(entity.transform.position);
}
if (++current % instance.configData.globalS.perFrame == 0)
{
yield return(CoroutineEx.waitForEndOfFrame);
}
}
Pool.Free(ref checkFrom);
Pool.FreeList(ref nearbyEntities);
}
public BuildingBlock GetNearbyBuildingBlock()
{
float num1 = float.MaxValue;
BuildingBlock buildingBlock1 = (BuildingBlock)null;
Vector3 position = this.PivotPoint();
List <BuildingBlock> list = (List <BuildingBlock>)Pool.GetList <BuildingBlock>();
Vis.Entities <BuildingBlock>(position, 1.5f, list, 2097152, (QueryTriggerInteraction)2);
for (int index = 0; index < list.Count; ++index)
{
BuildingBlock buildingBlock2 = list[index];
if (buildingBlock2.isServer == this.isServer)
{
float num2 = buildingBlock2.SqrDistance(position);
if ((double)num2 < (double)num1)
{
num1 = num2;
buildingBlock1 = buildingBlock2;
}
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list);
return(buildingBlock1);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
void findTarget(BasePlayer player, HitInfo hitInfo, Vector3 newPos)
{
List <BasePlayer> plist = new List <BasePlayer>();
List <BaseNpc> nlist = new List <BaseNpc>();
Vis.Entities <BasePlayer>(hitInfo.HitPositionWorld, FreezeRadius, plist);
Vis.Entities <BaseNpc>(hitInfo.HitPositionWorld, FreezeRadius, nlist);
if (freezePlayers)
{
foreach (BasePlayer p in plist)
{
if (isFrozen.ContainsKey(p.userID))
{
return;
}
isFrozen.Add(p.userID, new FreezeArrowData
{
player = p,
oldPos = p.transform.position
});
SendReply(p, lang.GetMessage("yourfrozetxt", this));
repeater(p, hitInfo, newPos);
}
}
if (freezeNPCs)
{
foreach (BaseNpc n in nlist)
{
timer.Repeat(0.1f, FreezeTime * 10, () => n.StopMoving());
timer.Once(FreezeTime + 1f, () => n.UpdateDestination(newPos));
}
}
}
private bool IsFlipped(BaseEntity entity)
{
if (!entity.ShortPrefabName.Contains(""))
{
PrintWarning("Error Flipping Turret... Error Code: 2592... Please report this to the plugin developer.");
return(false);
}
List <BaseEntity> nearby = new List <BaseEntity>();
Vis.Entities(entity.transform.position, 0.5f, nearby);
var turret = new BaseEntity();
foreach (var ent in nearby)
{
if (ent.ShortPrefabName.Contains("autoturret_deployed") && ent.transform.eulerAngles.z == 180)
{
turret = entity;
}
}
if (turret == null)
{
return(false);
}
else
{
return(true);
}
}
private object CanBuild(Planner plan, Construction prefab, Vector3 pos)
{
if (!plan || !prefab || !plan.GetOwnerPlayer())
{
return(null);
}
if (!prefab.hierachyName.StartsWith("cupboard.tool"))
{
return(null);
}
var list = Pool.GetList <BuildingPrivlidge>();
Vis.Entities(pos, CupboardRadius, list, Layers.Server.Deployed, QueryTriggerInteraction.Ignore);
//var result = list.Any(col => col.GetComponent<BuildPrivilegeTrigger>());
var result = list.Count > 0;
Pool.FreeList(ref list);
if (!result)
{
return(null);
}
var player = plan.GetOwnerPlayer();
rust.SendChatMessage(player, string.Empty, "You\'re placing cupboard too close to another.", player.UserIDString);
return(false);
}
private bool CupboardPrivlidge(Vector3 position, ulong hitEntityOwnerID)
{
float distance = 1f;
List <BaseEntity> list = new List <BaseEntity>();
Vis.Entities <BaseEntity>(position, distance, list);
foreach (var ent in list)
{
var buildingPrivlidge = ent.GetComponentInParent <BuildingPrivlidge>();
if (buildingPrivlidge != null)
{
if (configData.CheckAuth)
{
foreach (var auth in buildingPrivlidge.authorizedPlayers.Select(x => x.userid).ToArray())
{
if (auth.ToString() == hitEntityOwnerID.ToString())
{
if (HasPerm(auth.ToString()))
{
return(true);
}
}
}
return(false);
}
return(true);
}
}
return(false);
}
public Door FindDoor(bool allowLocked = true)
{
List <Door> list = Pool.GetList <Door>();
Vis.Entities <Door>(base.transform.position, 1f, list, 2097152, QueryTriggerInteraction.Ignore);
Door door = null;
float single = Single.PositiveInfinity;
foreach (Door door1 in list)
{
if (!door1.isServer)
{
continue;
}
if (!allowLocked)
{
BaseLock slot = door1.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (slot != null && slot.IsLocked())
{
continue;
}
}
float single1 = Vector3.Distance(door1.transform.position, base.transform.position);
if (single1 >= single)
{
continue;
}
door = door1;
single = single1;
}
Pool.FreeList <Door>(ref list);
return(door);
}
public Door FindDoor(bool allowLocked = true)
{
List <Door> list = (List <Door>)Pool.GetList <Door>();
Vis.Entities <Door>(((Component)this).get_transform().get_position(), 1f, list, 2097152, (QueryTriggerInteraction)1);
Door door1 = (Door)null;
float num1 = float.PositiveInfinity;
foreach (Door door2 in list)
{
if (door2.isServer)
{
if (!allowLocked)
{
BaseLock slot = door2.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (Object.op_Inequality((Object)slot, (Object)null) && slot.IsLocked())
{
continue;
}
}
float num2 = Vector3.Distance(((Component)door2).get_transform().get_position(), ((Component)this).get_transform().get_position());
if ((double)num2 < (double)num1)
{
door1 = door2;
num1 = num2;
}
}
}
// ISSUE: cast to a reference type
Pool.FreeList <Door>((List <M0>&) ref list);
return(door1);
}
internal void FindTargets()
{
if (Instance.disabledTurrets.Contains(turret.net.ID))
{
return;
}
if (turret.target == null && turret.IsPowered())
{
List <BaseAnimalNPC> localpig = new List <BaseAnimalNPC>();
Vis.Entities(turret.eyePos.transform.position, 30f, localpig);
foreach (BaseCombatEntity bce in localpig)
{
if (string.IsNullOrEmpty(bce.ShortPrefabName))
{
continue;
}
if (turret.ObjectVisible(bce) && !Instance.configData.exclusions.Contains(bce.ShortPrefabName))
{
turret.target = bce;
break;
}
}
}
}
private void CmdRemove(IPlayer iplayer, string command, string[] args)
{
if (!iplayer.HasPermission(permSpawn_Use))
{
Message(iplayer, "notauthorized"); return;
}
List <RidableHorse> hlist = new List <RidableHorse>();
BasePlayer player = iplayer.Object as BasePlayer;
Vis.Entities(player.transform.position, 1f, hlist);
bool found = false;
foreach (RidableHorse horse in hlist)
{
if (horse)
{
found = true;
if (horse.OwnerID == player.userID && horses.ContainsKey(horse.net.ID))
{
//horses.Remove(horse.net.ID); // Handled by OnEntityDeath()
horse.Hurt(500);
}
else
{
Message(iplayer, "notyourhorse");
}
}
}
if (!found)
{
Message(iplayer, "nohorses");
}
}