void RemoveAll(StructureMaster master, RemoveHandler rplayer)
{
foreach (StructureComponent comp in (HashSet <StructureComponent>)structureComponents.GetValue(master))
{
TakeDamage.KillSelf(comp.GetComponent <IDMain>());
}
}
void TryToRemove(TakeDamage takedamage, RemoveHandler rplayer)
{
cachedStructure = takedamage.GetComponent <StructureComponent>();
cachedDeployable = takedamage.GetComponent <DeployableObject>();
if (cachedStructure != null && cachedStructure._master != null)
{
cachedMaster = cachedStructure._master;
if (!canRemove(rplayer, cachedMaster.ownerID.ToString()))
{
SendReply(rplayer.playerclient.netUser, noRemoveAccess); return;
}
if (rplayer.removeType == "all")
{
RemoveAll(cachedMaster, rplayer);
}
else
{
SimpleRemove(cachedStructure, rplayer);
}
}
else if (cachedDeployable != null)
{
if (!canRemove(rplayer, cachedDeployable.ownerID.ToString()))
{
SendReply(rplayer.playerclient.netUser, noRemoveAccess); return;
}
DeployableRemove(cachedDeployable, rplayer);
}
}
public StructureMaster CreateSM(Fougerite.Player p, float x, float y, float z, Quaternion rot)
{
StructureMaster master = NetCull.InstantiateClassic <StructureMaster>(Bundling.Load <StructureMaster>("content/structures/StructureMasterPrefab"), new Vector3(x, y, z), rot, 0);
master.SetupCreator(p.PlayerClient.controllable);
return(master);
}
void cmdChatProd(NetUser netuser, string command, string[] args)
{
if (!hasAccess(netuser)) { SendReply(netuser, "You don't have access to this command"); return; }
cachedCharacter = netuser.playerClient.rootControllable.idMain.GetComponent<Character>();
if (!MeshBatchPhysics.Raycast(cachedCharacter.eyesRay, out cachedRaycast, out cachedBoolean, out cachedhitInstance)) { SendReply(netuser, "Are you looking at the sky?"); return; }
if (cachedhitInstance != null)
{
cachedCollider = cachedhitInstance.physicalColliderReferenceOnly;
if (cachedCollider == null) { SendReply(netuser, "Can't prod what you are looking at"); return; }
cachedStructure = cachedCollider.GetComponent<StructureComponent>();
if (cachedStructure != null && cachedStructure._master != null)
{
cachedMaster = cachedStructure._master;
var name = PlayerDatabase?.Call("GetPlayerData", cachedMaster.ownerID.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1} - {2}", cachedStructure.gameObject.name, cachedMaster.ownerID.ToString(), name == null ? "UnknownPlayer" : name.ToString()));
return;
}
}
else
{
cachedDeployable = cachedRaycast.collider.GetComponent<DeployableObject>();
if (cachedDeployable != null)
{
var name = PlayerDatabase?.Call("GetPlayerData", cachedDeployable.ownerID.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1} - {2}", cachedDeployable.gameObject.name, cachedDeployable.ownerID.ToString(), name == null ? cachedDeployable.ownerName.ToString() : name.ToString()));
return;
}
}
SendReply(netuser, string.Format("Can't prod what you are looking at: {0}",cachedRaycast.collider.gameObject.name));
}
void PasteBuilding(List <object> structureData, Vector3 targetPoint, float targetRot, float heightAdjustment, NetUser netuser)
{
Vector3 OriginRotation = new Vector3(0f, targetRot, 0f);
Quaternion OriginRot = Quaternion.EulerRotation(OriginRotation);
StructureMaster themaster = null;
foreach (Dictionary <string, object> structure in structureData)
{
Dictionary <string, object> structPos = structure["pos"] as Dictionary <string, object>;
Dictionary <string, object> structRot = structure["rot"] as Dictionary <string, object>;
string prefabname = (string)structure["prefabname"];
Quaternion newAngles = Quaternion.EulerRotation((new Vector3(Convert.ToSingle(structRot["x"]), Convert.ToSingle(structRot["y"]), Convert.ToSingle(structRot["z"]))) + OriginRotation);
Vector3 TempPos = OriginRot * (new Vector3(Convert.ToSingle(structPos["x"]), Convert.ToSingle(structPos["y"]), Convert.ToSingle(structPos["z"])));
Vector3 NewPos = TempPos + targetPoint;
if (themaster == null)
{
themaster = NetCull.InstantiateClassic <StructureMaster>(Facepunch.Bundling.Load <StructureMaster>("content/structures/StructureMasterPrefab"), NewPos, newAngles, 0);
themaster.SetupCreator(netuser.playerClient.controllable);
}
StructureComponent block = SpawnStructure(prefabname, NewPos, newAngles);
if (block != null)
{
themaster.AddStructureComponent(block);
}
}
}
Vector3 FindFirstComponent(StructureMaster master)
{
foreach (StructureComponent comp in (HashSet <StructureComponent>)structurecomplist.GetValue(master))
{
return(comp.transform.position);
}
return(Vector3.zero);
}
public StructureController(StructureMaster structureMaster, StructureConfig structureConfig, StructureData structureData)
{
this.structureMaster = structureMaster;
this.structureConfig = structureConfig;
this.structureData = structureData;
Initialize();
}
protected internal virtual void OnOwnedByMasterStructure(StructureMaster master)
{
this._master = master;
NGCView component = base.GetComponent <NGCView>();
if (((component != null) && !this.addedDestroyCallback) && (component != null))
{
this.addedDestroyCallback = true;
component.OnPreDestroy += new NGC.EventCallback(this.cl_predestroy);
}
}
public static EventTimer TimeEvent_TeleportTo(NetUser Sender, NetUser Target, string Command, double time)
{
Class38 class2 = new Class38 {
netUser_0 = Sender,
netUser_1 = Target,
string_0 = Command
};
if (Core.CommandTeleportOutdoorsOnly)
{
foreach (Collider collider in Physics.OverlapSphere(class2.netUser_1.playerClient.controllable.character.transform.position, 1f, 0x10360401))
{
IDMain main = IDBase.GetMain(collider);
if (main != null)
{
StructureMaster component = main.GetComponent <StructureMaster>();
if (((component != null) && (component.ownerID != class2.netUser_0.userID)) && (component.ownerID != class2.netUser_1.userID))
{
UserData bySteamID = Users.GetBySteamID(component.ownerID);
if ((bySteamID == null) || (!bySteamID.HasShared(class2.netUser_0.userID) && !bySteamID.HasShared(class2.netUser_1.userID)))
{
Broadcast.Notice(class2.netUser_0, "☢", Config.GetMessage("Command.Teleport.NoTeleport", class2.netUser_0, class2.netUser_1.displayName), 5f);
Broadcast.Notice(class2.netUser_1, "☢", Config.GetMessage("Command.Teleport.NotHere", class2.netUser_1, class2.netUser_0.displayName), 5f);
return(null);
}
}
}
}
}
Broadcast.Message(class2.netUser_0, Config.GetMessage("Command.Teleport.IsConfirm", class2.netUser_0, null).Replace("%USERNAME%", class2.netUser_1.displayName), null, 0f);
Broadcast.Message(class2.netUser_1, Config.GetMessage("Command.Teleport.Confirmed", class2.netUser_1, null).Replace("%USERNAME%", class2.netUser_0.displayName), null, 0f);
if (!Character.FindByUser(class2.netUser_1.userID, out class2.character_0))
{
return(null);
}
if (time <= 0.0)
{
Teleport_PlayerTo(null, class2.netUser_0, class2.netUser_1, class2.string_0, class2.character_0.transform.position);
return(null);
}
EventTimer timer = new EventTimer {
Interval = time * 1000.0,
AutoReset = false
};
timer.Elapsed += new ElapsedEventHandler(class2.method_0);
timer.Sender = class2.netUser_0;
timer.Target = class2.netUser_1;
timer.Command = class2.string_0;
Broadcast.Notice(class2.netUser_0, "☢", Config.GetMessage("Command.Teleport.Timewait", class2.netUser_0, null).Replace("%TIME%", timer.TimeLeft.ToString()), 5f);
Broadcast.Notice(class2.netUser_1, "☢", Config.GetMessage("Command.Teleport.Timewait", class2.netUser_1, null).Replace("%TIME%", timer.TimeLeft.ToString()), 5f);
timer.Start();
return(timer);
}
public static void StructureMaster_DoDecay(StructureMaster hook, StructureComponent component, ref float damageQuantity)
{
object[] array = new object[]
{
hook,
component,
damageQuantity
};
Method.Invoke("RustExtended.RustHook.StructureMaster_DoDecay", array);
damageQuantity = (float)array[2];
}
void AddStructureMaster(StructureMaster master)
{
if (UserStructures[master.ownerID.ToString()] == null)
{
UserStructures[master.ownerID.ToString()] = new List <StructureMaster>();
}
if (!UserStructures[master.ownerID.ToString()].Contains(master))
{
UserStructures[master.ownerID.ToString()].Add(master);
}
}
public bool MasterFromRay(Ray ray)
{
foreach (StructureMaster master in StructureMaster.RayTestStructures(ray))
{
if (master != null)
{
return(true);
}
}
return(false);
}
public bool MasterFromRay(Ray ray)
{
StructureMaster[] structureMasterArray = StructureMaster.RayTestStructures(ray);
for (int i = 0; i < (int)structureMasterArray.Length; i++)
{
if (structureMasterArray[i])
{
return(true);
}
}
return(false);
}
private void SuperLogError(ServerSave obj)
{
if (obj && obj.tag != null)
{
Logger.Log("[SuperLogError] obj.tag: " + obj.tag);
}
if (obj && obj.name != null)
{
Logger.Log("[SuperLogError] obj.name: " + obj.name);
}
if (obj && obj.REGED.ToString() != null)
{
Logger.Log("[SuperLogError] obj.tag: " + obj.REGED.ToString());
}
if (obj && obj.transform != null && obj.transform.position != null)
{
Logger.Log("[SuperLogError] obj.transform.position: " + obj.transform.position);
}
if (obj && obj.gameObject && obj.gameObject.tag != null)
{
Logger.Log("[SuperLogError] obj.gameObject.tag: " + obj.gameObject.tag);
}
if (obj && obj.gameObject && obj.gameObject.name != null)
{
Logger.Log("[SuperLogError] obj.gameObject.name: " + obj.gameObject.name);
}
if (obj && obj.gameObject && obj.gameObject.transform != null && obj.gameObject.transform.position != null)
{
Logger.Log("[SuperLogError] obj.gameObject.transform.position: " + obj.gameObject.transform.position.ToString());
}
// verificar se essse item bugado é strutura master e verica se está vazia para apagar
try
{
if (obj && obj.gameObject)
{
StructureMaster element = obj.gameObject.GetComponent <StructureMaster>();
if (element && (element._structureComponents == null || element._structureComponents.Count == 0))
{
Logger.Log("[Save Error] item bugado removido = ownerID:" + element.ownerID + " " + element.name + " " + element.transform.position.ToString());
element.OnDestroy();
}
}
}
catch (Exception ex)
{
Logger.LogError("[SuperLogError] Error element.OnDestroy!!");
}
}
protected void SMSet(uLink.NetworkViewID masterViewID)
{
Facepunch.NetworkView context = Facepunch.NetworkView.Find(masterViewID);
if (context != null)
{
StructureMaster component = context.GetComponent <StructureMaster>();
if (component != null)
{
component.AppendStructureComponent(this);
}
else
{
Debug.LogWarning("No Master On GO", context);
}
}
else
{
Debug.LogWarning("Couldnt find master view", this);
}
}
protected void SMSet(uLink.NetworkViewID masterViewID)
{
Facepunch.NetworkView networkView = Facepunch.NetworkView.Find(masterViewID);
if (!networkView)
{
Debug.LogWarning("Couldnt find master view", this);
}
else
{
StructureMaster component = networkView.GetComponent <StructureMaster>();
if (!component)
{
Debug.LogWarning("No Master On GO", networkView);
}
else
{
component.AppendStructureComponent(this);
}
}
}
void OnStructurePlaced(StructureComponent component, IStructureComponentItem structureComponentItem)
{
var currettime = Time.realtimeSinceStartup;
if (MeshBatchPhysics.Raycast(component.transform.position + Vector3ABitUp, Vector3Down, out cachedRaycast, out cachedBoolean, out cachedhitInstance))
{
if (cachedhitInstance != null)
{
cachedComponent = cachedhitInstance.physicalColliderReferenceOnly.GetComponent <StructureComponent>();
if (cachedComponent != null)
{
cachedMaster = cachedComponent._master;
CheckIfCanPlace(structureComponentItem.character.playerClient, cachedMaster.ownerID.ToString(), component);
}
}
}
else
{
CheckIfCanPlace(structureComponentItem.character.playerClient, structureComponentItem.character.playerClient.userID.ToString(), component);
}
SendReply(structureComponentItem.character.playerClient.netUser, "Took: " + (currettime - Time.realtimeSinceStartup).ToString());
}
void cmdChatProd(NetUser netuser, string command, string[] args)
{
if (!hasAccess(netuser))
{
SendReply(netuser, "You don't have access to this command"); return;
}
cachedCharacter = netuser.playerClient.rootControllable.idMain.GetComponent <Character>();
if (!MeshBatchPhysics.Raycast(cachedCharacter.eyesRay, out cachedRaycast, out cachedBoolean, out cachedhitInstance))
{
SendReply(netuser, "Are you looking at the sky?"); return;
}
if (cachedhitInstance != null)
{
cachedCollider = cachedhitInstance.physicalColliderReferenceOnly;
if (cachedCollider == null)
{
SendReply(netuser, "Can't prod what you are looking at"); return;
}
cachedStructure = cachedCollider.GetComponent <StructureComponent>();
if (cachedStructure != null && cachedStructure._master != null)
{
cachedMaster = cachedStructure._master;
var name = PlayerDatabase?.Call("GetPlayerData", cachedMaster.ownerID.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1} - {2}", cachedStructure.gameObject.name, cachedMaster.ownerID.ToString(), name == null ? "UnknownPlayer" : name.ToString()));
return;
}
}
else
{
cachedDeployable = cachedRaycast.collider.GetComponent <DeployableObject>();
if (cachedDeployable != null)
{
var name = PlayerDatabase?.Call("GetPlayerData", cachedDeployable.ownerID.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1} - {2}", cachedDeployable.gameObject.name, cachedDeployable.ownerID.ToString(), name == null ? cachedDeployable.ownerName.ToString() : name.ToString()));
return;
}
}
SendReply(netuser, string.Format("Can't prod what you are looking at: {0}", cachedRaycast.collider.gameObject.name));
}
internal static StructureMaster[] SmallerThan(StructureMaster structure)
{
return Structures.SmallerThan(structure.containedBounds.size.sqrMagnitude);
}
void cmdChatProd(NetUser netuser, string command, string[] args)
{
if (!hasAccess(netuser))
{
SendReply(netuser, "You don't have access to this command"); return;
}
cachedCharacter = netuser.playerClient.rootControllable.idMain.GetComponent <Character>();
if (!MeshBatchPhysics.Raycast(cachedCharacter.eyesRay, out cachedRaycast, out cachedBoolean, out cachedhitInstance))
{
SendReply(netuser, "Are you looking at the sky?"); return;
}
//Debug.Log(cachedRaycast.collider.ToString());
//Debug.Log(LayerMask.LayerToName(cachedRaycast.collider.gameObject.layer));
//Debug.Log(cachedRaycast.collider.transform.position.y.ToString());
//Debug.Log(cachedCharacter.origin.y.ToString());
//GameObject.Destroy(cachedRaycast.collider.GetComponent<UnityEngine.MeshCollider>());
/*
*
* var components = cachedRaycast.collider.GetComponents<UnityEngine.Component>();
* foreach (var comp in components)
* {
* Debug.Log(comp.ToString());
* }
* Debug.Log("============= COMPONENTS IN PARENT =============");
* components = cachedRaycast.collider.GetComponentsInParent<UnityEngine.Component>();
* foreach (var comp in components)
* {
* Debug.Log(comp.ToString());
* }
* Debug.Log("============= COMPONENTS IN CHILDREN =============");
* components = cachedRaycast.collider.GetComponentsInChildren<UnityEngine.Component>();
* foreach (var comp in components)
* {
* Debug.Log(comp.ToString());
* }*/
if (cachedhitInstance != null)
{
cachedCollider = cachedhitInstance.physicalColliderReferenceOnly;
if (cachedCollider == null)
{
SendReply(netuser, "Can't prod what you are looking at"); return;
}
cachedStructure = cachedCollider.GetComponent <StructureComponent>();
if (cachedStructure != null && cachedStructure._master != null)
{
cachedMaster = cachedStructure._master;
var name = PlayerDatabase?.Call("GetPlayerData", cachedMaster.ownerID.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1} - {2}", cachedStructure.gameObject.name, cachedMaster.ownerID.ToString(), name == null ? "UnknownPlayer" : name.ToString()));
return;
}
}
else
{
cachedDeployable = cachedRaycast.collider.GetComponent <DeployableObject>();
if (cachedDeployable != null)
{
var name = PlayerDatabase?.Call("GetPlayerData", cachedDeployable.ownerID.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1} - {2}", cachedDeployable.gameObject.name, cachedDeployable.ownerID.ToString(), name == null ? cachedDeployable.ownerName.ToString() : name.ToString()));
if (cachedDeployable.GetComponent <PasswordLockableObject>())
{
SendReply(netuser, "Players with access to this door:");
int count = 0;
foreach (ulong userid in (HashSet <ulong>)accessUsers.GetValue(cachedDeployable.GetComponent <PasswordLockableObject>()))
{
count++;
name = PlayerDatabase?.Call("GetPlayerData", userid.ToString(), "name");
SendReply(netuser, string.Format("{0} - {1}", userid.ToString(), name == null ? "Unknown" : name.ToString()));
}
if (count == 0)
{
SendReply(netuser, "No one exept the owner.");
}
}
return;
}
}
SendReply(netuser, string.Format("Can't prod what you are looking at: {0}", cachedRaycast.collider.gameObject.name));
}
internal static StructureMaster[] EqualTo(StructureMaster structure)
{
return Structures.EqualTo(structure.containedBounds.size.sqrMagnitude);
}
internal static StructureMaster[] LargerThan(StructureMaster structure)
{
return(Structures.LargerThan(structure.containedBounds.size.sqrMagnitude));
}
public static StructureMaster[] EqualTo(StructureMaster structure)
{
return(Structures.EqualTo(structure.containedBounds.size.sqrMagnitude));
}
protected void RenderPlacementHelpers()
{
RaycastHit raycastHit;
int num;
int num1;
int num2;
StructureComponent structureComponent = this.datablock.structureToPlacePrefab;
this._master = null;
this._placePos = Vector3.zero;
this._placeRot = Quaternion.identity;
this.validLocation = false;
float axis = Input.GetAxis("Mouse ScrollWheel");
if (axis > 0f)
{
this.desiredRotation = this.desiredRotation * Quaternion.AngleAxis(90f, Vector3.up);
}
else if (axis < 0f)
{
this.desiredRotation = this.desiredRotation * Quaternion.AngleAxis(-90f, Vector3.up);
}
Character character = base.character;
if (character == null)
{
return;
}
Ray ray = character.eyesRay;
float single = (structureComponent.type != StructureComponent.StructureComponentType.Ceiling ? 8f : 4f);
Vector3 vector3 = Vector3.zero;
Vector3 vector31 = Vector3.up;
Vector3 vector32 = Vector3.zero;
bool flag = false;
if (!Physics.Raycast(ray, out raycastHit, single))
{
flag = false;
Vector3 vector33 = ray.origin + (ray.direction * single);
vector3 = vector33;
vector32 = vector33;
}
else
{
Vector3 vector34 = raycastHit.point;
vector3 = vector34;
vector32 = vector34;
vector31 = raycastHit.normal;
flag = true;
}
switch (structureComponent.type)
{
case StructureComponent.StructureComponentType.Ceiling:
case StructureComponent.StructureComponentType.Foundation:
case StructureComponent.StructureComponentType.Ramp:
{
vector3.y = vector3.y - 3.5f;
goto case StructureComponent.StructureComponentType.WindowWall;
}
case StructureComponent.StructureComponentType.Stairs:
case StructureComponent.StructureComponentType.WindowWall:
{
bool flag1 = false;
bool flag2 = false;
Vector3 vector35 = vector3;
Angle2 angle2 = character.eyesAngles;
Quaternion quaternion = TransformHelpers.LookRotationForcedUp(angle2.forward, Vector3.up) * this.desiredRotation;
StructureMaster[] structureMasterArray = StructureMaster.RayTestStructures(ray);
for (int i = 0; i < (int)structureMasterArray.Length; i++)
{
StructureMaster structureMaster = structureMasterArray[i];
if (structureMaster)
{
structureMaster.GetStructureSize(out num, out num1, out num2);
this._placePos = StructureMaster.SnapToGrid(structureMaster.transform, vector3, true);
this._placeRot = TransformHelpers.LookRotationForcedUp(structureMaster.transform.forward, structureMaster.transform.transform.up) * this.desiredRotation;
if (!flag2)
{
vector35 = this._placePos;
quaternion = this._placeRot;
flag2 = true;
}
if (structureComponent.CheckLocation(structureMaster, this._placePos, this._placeRot))
{
this._master = structureMaster;
flag1 = true;
break;
}
}
}
if (flag1)
{
this.validLocation = true;
}
else if (structureComponent.type != StructureComponent.StructureComponentType.Foundation)
{
this._placePos = vector35;
this._placeRot = quaternion;
this.validLocation = false;
}
else if (!flag || !(raycastHit.collider is TerrainCollider))
{
this._placePos = vector35;
this._placeRot = quaternion;
this.validLocation = false;
}
else
{
bool flag3 = false;
foreach (StructureMaster allStructuresWithBound in StructureMaster.AllStructuresWithBounds)
{
if (!allStructuresWithBound.containedBounds.Intersects(new Bounds(vector3, new Vector3(5f, 5f, 4f))))
{
continue;
}
flag3 = true;
break;
}
if (!flag3)
{
this._placePos = vector3;
Angle2 angle21 = character.eyesAngles;
this._placeRot = TransformHelpers.LookRotationForcedUp(angle21.forward, Vector3.up) * this.desiredRotation;
this.validLocation = true;
}
}
if (!this.datablock.CheckBlockers(this._placePos))
{
this.validLocation = false;
}
Color color = Color.red;
if (this.validLocation)
{
color = Color.green;
}
color.a = 0.5f + Mathf.Abs(Mathf.Sin(Time.time * 8f)) * 0.25f;
if (this._materialProps != null)
{
this._materialProps.Clear();
this._materialProps.AddColor("_EmissionColor", color);
this._materialProps.AddVector("_MainTex_ST", new Vector4(1f, 1f, 0f, Mathf.Repeat(Time.time, 30f)));
}
if (!this.validLocation)
{
this._placePos = vector3;
}
this.RenderDeployPreview(this._placePos, this._placeRot);
return;
}
default:
{
goto case StructureComponent.StructureComponentType.WindowWall;
}
}
}
public static void OnLootUse(LootStartEvent lootstartevent)
{
if (lootstartevent.Player == null)
{
return;
}
if (!lootstartevent.IsObject || DataStore.GetInstance().ContainsKey("LegitRaidA", lootstartevent.Player.UID) ||
DataStore.GetInstance().ContainsKey("HGIG", lootstartevent.Player.SteamID))
{
Logger.LogError("Incumple 1");
return;
}
if (DSNames.Any(table => DataStore.GetInstance().ContainsKey(table, lootstartevent.Player.SteamID) ||
DataStore.GetInstance().ContainsKey(table, lootstartevent.Player.UID)))
{
Logger.LogError("Incumple 2");
return;
}
if (!lootstartevent.Entity.IsStorage())
{
Logger.LogError("Incumple 3");
return;
}
ulong owneruid = GetHouseOwner(lootstartevent.Entity.Location);
if (owneruid == 0UL)
{
Logger.LogError("No se encuentra al dueño");
return;
}
if (owneruid == lootstartevent.Player.UID)
{
Logger.LogError("Cumple 4");
return;
}
if (CanOpenChestIfThereIsNoStructureClose)
{
Logger.LogError("Esta abierta");
var objects = Physics.OverlapSphere(lootstartevent.Entity.Location, 3.8f);
var names = new List <string>();
foreach (var x in objects.Where(x => !names.Contains(x.name.ToLower())))
{
names.Add(x.name.ToLower());
}
string ncollected = string.Join(" ", names.ToArray());
if (ncollected.Contains("shelter") && !ncollected.Contains("door"))
{
return;
}
if (!ncollected.Contains("meshbatch"))
{
return;
}
}
StructureMaster structureMaster = GetStructureMaster(lootstartevent.Entity.Location);
Logger.LogError($"SM: InstanceID: {structureMaster.GetInstanceID()}");
ulong id = GetHouseOwner(lootstartevent.Entity.Location);
RustPP.Data.Entities.User owner = RustPP.Data.Globals.GetUserBySteamID(lootstartevent.Entity.OwnerName);
RustPP.Data.Entities.User player = RustPP.Data.Globals.GetUserBySteamID(lootstartevent.Player.SteamID);
if (owner.ID == player.ID)
{
return;
}
if (FriendComponent.FriendComponent.IsFriendOf(owner, player))
{
Logger.LogError("Es amigo");
return;
}
if (OwnerTimeData.ContainsKey(id))
{
Logger.LogError("Cumple 5");
var ticks = OwnerTimeData[id];
var calc = TimeSpan.FromTicks(DateTime.Now.Ticks).TotalSeconds - ticks;
int timeraid = RaidTime;
if (RaiderTime.ContainsKey(id))
{
timeraid = RaiderTime[id];
}
if (double.IsNaN(calc) || double.IsNaN(ticks))
{
lootstartevent.Cancel();
lootstartevent.Player.Notice("", "Necesitas romper una pared con C4/Granadas en una pared y podrás raidear por " + RaidTime + " minutos!", 8f);
lootstartevent.Player.MessageFrom("LegitRaid", "[color cyan]<!>[/color] Si intentas abrir el cofre de un amigo el deberá usar /addfriend para darte permiso.");
//lootstartevent.Player.MessageFrom("LegitRaid", "After that tell him to type /friendraid !");
OwnerTimeData.Remove(id);
if (RaiderTime.ContainsKey(id))
{
RaiderTime.Remove(id);
}
}
if (calc >= (RaidTime + timeraid) * 60)
{
lootstartevent.Cancel();
lootstartevent.Player.Notice("", "Necesitas romper una pared con C4/Granadas en una pared y podrás raidear por " + RaidTime + " minutos!", 8f);
lootstartevent.Player.MessageFrom("LegitRaid", "[color cyan]<!>[/color] Si intentas abrir el cofre de un amigo el deberá usar /addfriend para darte permiso.");
OwnerTimeData.Remove(id);
if (RaiderTime.ContainsKey(id))
{
RaiderTime.Remove(id);
}
}
else
{
Logger.LogError("Cumple 5");
var done = Math.Round(calc);
lootstartevent.Player.Notice("¡Puedes lootear por " + ((timeraid * 60) - done) + " segundos!");
}
return;
}
else
{
Logger.LogError("incumple 6");
if (DataStore.GetInstance().Get("LegitRaidED", id) != null)
{
List <string> list = (List <string>)DataStore.GetInstance().Get("LegitRaidED", id);
if (list.Contains(id.ToString()) && OwnerTimeData.ContainsKey(id))
{
var ticks = OwnerTimeData[id];
var calc = TimeSpan.FromTicks(DateTime.Now.Ticks).TotalSeconds - ticks;
int timeraid = RaidTime;
if (RaiderTime.ContainsKey(id))
{
timeraid = RaiderTime[id];
}
if (double.IsNaN(calc) || double.IsNaN(ticks))
{
lootstartevent.Cancel();
lootstartevent.Player.Notice("", "Necesitas romper una pared con C4/Granadas en una pared y podrás raidear por " + RaidTime + " minutos!", 8f);
lootstartevent.Player.MessageFrom("LegitRaid", "[color cyan]<!>[/color] Si intentas abrir el cofre de un amigo el deberá usar /addfriend para darte permiso.");
OwnerTimeData.Remove(id);
if (RaiderTime.ContainsKey(id))
{
RaiderTime.Remove(id);
}
}
if (calc >= (RaidTime + timeraid) * 60)
{
lootstartevent.Cancel();
lootstartevent.Player.Notice("", "Necesitas romper una pared con C4/Granadas en una pared y podrás raidear por " + RaidTime + " minutos!", 8f);
lootstartevent.Player.MessageFrom("LegitRaid", "[color cyan]<!>[/color] Si intentas abrir el cofre de un amigo el deberá usar /addfriend para darte permiso.");
OwnerTimeData.Remove(id);
if (RaiderTime.ContainsKey(id))
{
RaiderTime.Remove(id);
}
}
else
{
var done = Math.Round(calc);
lootstartevent.Player.Notice("¡Puedes lootear por " + ((timeraid * 60) - done) + " segundos!");
}
return;
}
}
lootstartevent.Cancel();
lootstartevent.Player.Notice("", "Necesitas romper una pared con C4/Granadas en una pared y podrás raidear por " + RaidTime + " minutos!", 8f);
lootstartevent.Player.MessageFrom("LegitRaid", "[color cyan]<!>[/color] Si intentas abrir el cofre de un amigo el deberá usar /addfriend para darte permiso.");
}
}
void cmdchatbancheck(NetUser netuser, string command, string[] args)
{
if (!hasAccess(netuser, "Rbb.checkbase"))
{
SendReply(netuser, GetMessage("not allowed to use command")); return;
}
cachedCharacter = netuser.playerClient.rootControllable.idMain.GetComponent <Character>();
if (!MeshBatchPhysics.Raycast(cachedCharacter.eyesRay, out cachedRaycast, out cachedBoolean, out cachedhitInstance))
{
SendReply(netuser, "Are you looking at the sky?"); return;
}
//Debug.Log(cachedRaycast.collider.ToString());
//Debug.Log(LayerMask.LayerToName(cachedRaycast.collider.gameObject.layer));
//Debug.Log(cachedRaycast.collider.transform.position.y.ToString());
//Debug.Log(cachedCharacter.origin.y.ToString());
//GameObject.Destroy(cachedRaycast.collider.GetComponent<UnityEngine.MeshCollider>());
/*
*
* var components = cachedRaycast.collider.GetComponents<UnityEngine.Component>();
* foreach (var comp in components)
* {
* Debug.Log(comp.ToString());
* }
* Debug.Log("============= COMPONENTS IN PARENT =============");
* components = cachedRaycast.collider.GetComponentsInParent<UnityEngine.Component>();
* foreach (var comp in components)
* {
* Debug.Log(comp.ToString());
* }
* Debug.Log("============= COMPONENTS IN CHILDREN =============");
* components = cachedRaycast.collider.GetComponentsInChildren<UnityEngine.Component>();
* foreach (var comp in components)
* {
* Debug.Log(comp.ToString());
* }*/
if (cachedhitInstance != null)
{
cachedCollider = cachedhitInstance.physicalColliderReferenceOnly;
if (cachedCollider == null)
{
SendReply(netuser, GetMessage("cant tell what you are looking at")); return;
}
cachedStructure = cachedCollider.GetComponent <StructureComponent>();
if (cachedStructure != null && cachedStructure._master != null)
{
cachedMaster = cachedStructure._master;
var owner = GetPlayerdata(cachedMaster.ownerID.ToString());
var gg = owner["StaticNickname"].ToString();
var q = owner["LastSeenNickname"].ToString();
var name = (q);
rust.SendChatMessage(netuser, GetMessage("systemname"), "StaticNickName " + gg);
rust.SendChatMessage(netuser, GetMessage("systemname"), string.Format("{0} - {1} - {2}", cachedStructure.gameObject.name, cachedMaster.ownerID.ToString(), name == null ? "Unknown" : name.ToString()));
if (BanList.Contains(Convert.ToUInt64(cachedMaster.ownerID.ToString())))
{
rust.SendChatMessage(netuser, GetMessage("systemname"), GetMessage("isinbanllist"));
if (removeall)
{
foreach (StructureComponent comp in (HashSet <StructureComponent>)structureComponents.GetValue(cachedMaster))
{
TakeDamage.KillSelf(comp.GetComponent <IDMain>());
}
}
return;
}
if (!BanList.Contains(Convert.ToUInt64(cachedMaster.ownerID.ToString())))
{
rust.SendChatMessage(netuser, GetMessage("systemname"), GetMessage("isnotinbanllist"));
return;
}
}
}
else
{
cachedDeployable = cachedRaycast.collider.GetComponent <DeployableObject>();
if (cachedDeployable != null)
{
var owner2 = GetPlayerdata(cachedDeployable.ownerID.ToString());
var gg2 = owner2["StaticNickname"].ToString();
var q2 = owner2["LastSeenNickname"].ToString();
var name = (q2);
rust.SendChatMessage(netuser, GetMessage("systemname"), "StaticNickName " + gg2);
rust.SendChatMessage(netuser, GetMessage("systemname"), string.Format("{0} - {1} - {2}", cachedDeployable.gameObject.name, cachedDeployable.ownerID.ToString(), name == null ? "Unknown" : name.ToString()));
if (cachedDeployable.GetComponent <PasswordLockableObject>())
{
SendReply(netuser, GetMessage("access to door"));
int count = 0;
foreach (ulong userid in (HashSet <ulong>)accessUsers.GetValue(cachedDeployable.GetComponent <PasswordLockableObject>()))
{
count++;
SendReply(netuser, string.Format("{0} - {1}", userid.ToString(), name == null ? "Unknown" : name.ToString()));
}
if (count == 0)
{
SendReply(netuser, GetMessage("no one except the owner"));
}
}
if (BanList.Contains(Convert.ToUInt64(cachedDeployable.ownerID.ToString())))
{
var cachedcarrier = cachedDeployable._carrier;
rust.SendChatMessage(netuser, GetMessage("systemname"), GetMessage("isinbanllist"));
if (removeall)
{
foreach (DeployableObject comp in (HashSet <DeployableObject>)structureComponents.GetValue(cachedcarrier))
{
TakeDamage.KillSelf(comp.GetComponent <IDMain>());
}
}
}
rust.SendChatMessage(netuser, GetMessage("systemname"), GetMessage("isnotinbanllist"));
return;
}
}
SendReply(netuser, string.Format(GetMessage("cantprod what you are looking at phase 2")), cachedRaycast.collider.gameObject.name);
}
protected void RenderPlacementHelpers()
{
StructureComponent structureToPlacePrefab = base.datablock.structureToPlacePrefab;
this._master = null;
this._placePos = Vector3.zero;
this._placeRot = Quaternion.identity;
this.validLocation = false;
float axis = Input.GetAxis("Mouse ScrollWheel");
if (axis > 0f)
{
this.desiredRotation *= Quaternion.AngleAxis(90f, Vector3.up);
}
else if (axis < 0f)
{
this.desiredRotation *= Quaternion.AngleAxis(-90f, Vector3.up);
}
Character character = base.character;
if (character != null)
{
RaycastHit hit;
Ray eyesRay = character.eyesRay;
float distance = (structureToPlacePrefab.type != StructureComponent.StructureComponentType.Ceiling) ? 8f : 4f;
Vector3 zero = Vector3.zero;
Vector3 up = Vector3.up;
Vector3 vector3 = Vector3.zero;
bool flag = false;
if (Physics.Raycast(eyesRay, out hit, distance))
{
vector3 = zero = hit.point;
up = hit.normal;
flag = true;
}
else
{
flag = false;
vector3 = zero = eyesRay.origin + ((Vector3)(eyesRay.direction * distance));
}
switch (structureToPlacePrefab.type)
{
case StructureComponent.StructureComponentType.Ceiling:
case StructureComponent.StructureComponentType.Foundation:
case StructureComponent.StructureComponentType.Ramp:
zero.y -= 3.5f;
break;
}
bool flag2 = false;
bool flag3 = false;
Vector3 vector4 = zero;
Quaternion quaternion = TransformHelpers.LookRotationForcedUp(character.eyesAngles.forward, Vector3.up) * this.desiredRotation;
foreach (StructureMaster master in StructureMaster.RayTestStructures(eyesRay))
{
if (master != null)
{
int num4;
int num5;
int num6;
master.GetStructureSize(out num4, out num5, out num6);
this._placePos = StructureMaster.SnapToGrid(master.transform, zero, true);
this._placeRot = TransformHelpers.LookRotationForcedUp(master.transform.forward, master.transform.transform.up) * this.desiredRotation;
if (!flag3)
{
vector4 = this._placePos;
quaternion = this._placeRot;
flag3 = true;
}
if (structureToPlacePrefab.CheckLocation(master, this._placePos, this._placeRot))
{
this._master = master;
flag2 = true;
break;
}
}
}
if (flag2)
{
this.validLocation = true;
}
else if (structureToPlacePrefab.type != StructureComponent.StructureComponentType.Foundation)
{
this._placePos = vector4;
this._placeRot = quaternion;
this.validLocation = false;
}
else if (!flag || !(hit.collider is TerrainCollider))
{
this._placePos = vector4;
this._placeRot = quaternion;
this.validLocation = false;
}
else
{
bool flag4 = false;
foreach (StructureMaster master2 in StructureMaster.AllStructuresWithBounds)
{
if (master2.containedBounds.Intersects(new Bounds(zero, new Vector3(5f, 5f, 4f))))
{
flag4 = true;
break;
}
}
if (!flag4)
{
this._placePos = zero;
this._placeRot = TransformHelpers.LookRotationForcedUp(character.eyesAngles.forward, Vector3.up) * this.desiredRotation;
this.validLocation = true;
}
}
if (!base.datablock.CheckBlockers(this._placePos))
{
this.validLocation = false;
}
Color red = Color.red;
if (this.validLocation)
{
red = Color.green;
}
red.a = 0.5f + (Mathf.Abs(Mathf.Sin(Time.time * 8f)) * 0.25f);
if (this._materialProps != null)
{
this._materialProps.Clear();
this._materialProps.AddColor("_EmissionColor", red);
this._materialProps.AddVector("_MainTex_ST", new Vector4(1f, 1f, 0f, Mathf.Repeat(Time.time, 30f)));
}
if (!this.validLocation)
{
this._placePos = zero;
}
this.RenderDeployPreview(this._placePos, this._placeRot);
}
}
public virtual bool CheckLocation(StructureMaster master, Vector3 placePos, Quaternion placeRot)
{
bool flag;
bool flag1;
bool flag2;
bool flag3 = false;
bool flag4 = false;
Vector3 vector3 = master.transform.InverseTransformPoint(placePos);
if (master.GetMaterialType() != StructureMaster.StructureMaterialType.UNSET && master.GetMaterialType() != this.GetMaterialType())
{
if (StructureComponent.logFailures)
{
Debug.Log(string.Concat("Not proper material type, master is :", master.GetMaterialType()));
}
return false;
}
StructureComponent componentFromPositionWorld = master.GetComponentFromPositionWorld(placePos);
if (componentFromPositionWorld != null)
{
if (StructureComponent.logFailures)
{
Debug.Log("Occupied space", componentFromPositionWorld);
}
flag3 = true;
}
StructureComponent structureComponent = master.CompByLocal(vector3 - new Vector3(0f, StructureMaster.gridSpacingY, 0f));
if (this.type != StructureComponent.StructureComponentType.Foundation && master.GetFoundationForPoint(placePos))
{
flag4 = true;
}
if (this.type == StructureComponent.StructureComponentType.Wall || this.type == StructureComponent.StructureComponentType.Doorway || this.type == StructureComponent.StructureComponentType.WindowWall)
{
if (flag3)
{
return false;
}
Vector3 vector31 = placePos + ((placeRot * -Vector3.right) * 2.5f);
StructureComponent componentFromPositionWorld1 = master.GetComponentFromPositionWorld(vector31);
Vector3 vector32 = placePos + ((placeRot * Vector3.right) * 2.5f);
StructureComponent structureComponent1 = master.GetComponentFromPositionWorld(vector32);
if (StructureComponent.logFailures)
{
Debug.DrawLine(vector31, vector32, Color.cyan);
}
if (!componentFromPositionWorld1 || !structureComponent1)
{
if (StructureComponent.logFailures)
{
if (!componentFromPositionWorld1)
{
Debug.Log("Did not find left");
}
if (!structureComponent1)
{
Debug.Log("Did not find right");
}
}
return false;
}
if (componentFromPositionWorld1.type == StructureComponent.StructureComponentType.Pillar)
{
flag = true;
}
else
{
if (StructureComponent.logFailures)
{
Debug.Log("Left was not acceptable", componentFromPositionWorld1);
}
flag = false;
}
if (structureComponent1.type == StructureComponent.StructureComponentType.Pillar)
{
flag1 = true;
}
else
{
if (StructureComponent.logFailures)
{
Debug.Log("Right was not acceptable", structureComponent1);
}
flag1 = false;
}
return (!flag ? false : flag1);
}
if (this.type == StructureComponent.StructureComponentType.Foundation)
{
List<StructureMaster>.Enumerator enumerator = StructureMaster.AllStructuresWithBounds.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
StructureMaster current = enumerator.Current;
if (current != master)
{
if (!current.containedBounds.Intersects(new Bounds(placePos, new Vector3(5f, 5f, 4f))))
{
continue;
}
if (StructureComponent.logFailures)
{
Debug.Log("Too close to something");
}
flag2 = false;
return flag2;
}
}
bool flag5 = master.IsValidFoundationSpot(placePos);
if (StructureComponent.logFailures)
{
Debug.Log(string.Concat(new object[] { "returning here : mastervalid:", flag5, "compinplace", componentFromPositionWorld }));
}
return (!flag5 ? false : !componentFromPositionWorld);
}
finally
{
((IDisposable)(object)enumerator).Dispose();
}
return flag2;
}
if (this.type == StructureComponent.StructureComponentType.Ramp)
{
if (componentFromPositionWorld == null && (master.IsValidFoundationSpot(placePos) || structureComponent && (structureComponent.type == StructureComponent.StructureComponentType.Ceiling || structureComponent.type == StructureComponent.StructureComponentType.Foundation)))
{
return true;
}
return false;
}
if (this.type == StructureComponent.StructureComponentType.Pillar)
{
return ((!structureComponent || structureComponent.type != StructureComponent.StructureComponentType.Pillar) && !flag4 ? false : !flag3);
}
if (this.type != StructureComponent.StructureComponentType.Stairs && this.type != StructureComponent.StructureComponentType.Ceiling)
{
return false;
}
if (flag3)
{
return false;
}
Vector3[] vector3Array = new Vector3[] { new Vector3(-2.5f, 0f, -2.5f), new Vector3(2.5f, 0f, 2.5f), new Vector3(-2.5f, 0f, 2.5f), new Vector3(2.5f, 0f, -2.5f) };
for (int i = 0; i < (int)vector3Array.Length; i++)
{
Vector3 vector33 = vector3Array[i];
StructureComponent structureComponent2 = master.CompByLocal(vector3 + vector33);
if (structureComponent2 == null || structureComponent2.type != StructureComponent.StructureComponentType.Pillar)
{
return false;
}
}
return true;
}
protected internal virtual void OnOwnedByMasterStructure(StructureMaster master)
{
this._master = master;
NGCView component = base.GetComponent<NGCView>();
if (component && !this.addedDestroyCallback && component)
{
this.addedDestroyCallback = true;
component.OnPreDestroy += new NGC.EventCallback(this.cl_predestroy);
}
}
public static StructureMaster.DecayStatus DoDecay(StructureMaster SM)
{
float num = UnityEngine.Time.time - SM._lastDecayTime;
SM._lastDecayTime = UnityEngine.Time.time;
if (SM._decayRate <= 0f)
{
return StructureMaster.DecayStatus.Delaying;
}
SM._decayDelayRemaining -= num;
num = -SM._decayDelayRemaining;
if (SM._decayDelayRemaining < 0f)
{
SM._decayDelayRemaining = 0f;
}
if (num <= 0f)
{
return StructureMaster.DecayStatus.Delaying;
}
SM._pentUpDecayTime += num;
float decayTimeMaxHealth = SM.GetDecayTimeMaxHealth();
float num3 = SM._pentUpDecayTime / decayTimeMaxHealth;
if (num3 < structure.minpercentdmg)
{
return StructureMaster.DecayStatus.PentUpDecay;
}
SM._pentUpDecayTime = 0f;
foreach (StructureComponent component in SM._structureComponents)
{
Vector3 position = component.transform.position;
if (!inZone(position))
{
TakeDamage damage = component.GetComponent<TakeDamage>();
if (damage != null)
{
float damageQuantity = ((damage.maxHealth * num3) * UnityEngine.Random.Range((float)0.75f, (float)1.25f)) * SM._decayRate;
if (((component.type == StructureComponent.StructureComponentType.Wall) || (component.type == StructureComponent.StructureComponentType.Doorway)) || (component.type == StructureComponent.StructureComponentType.WindowWall))
{
RaycastHit hit;
bool flag4;
Facepunch.MeshBatch.MeshBatchInstance instance;
Ray ray = new Ray(component.transform.position + new Vector3(0f, 2.5f, 0f), component.transform.forward);
Ray ray2 = new Ray(component.transform.position + new Vector3(0f, 2.5f, 0f), -component.transform.forward);
bool flag3 = false;
if (Facepunch.MeshBatch.MeshBatchPhysics.Raycast(ray, out hit, 25f, out flag4, out instance))
{
RaycastHit hit2;
IDMain main = !flag4 ? IDBase.GetMain(hit.collider.gameObject) : instance.idMain;
if (((main != null) && ((main is StructureComponent) || main.CompareTag("Door"))) && Facepunch.MeshBatch.MeshBatchPhysics.Raycast(ray2, out hit2, 25f, out flag4, out instance))
{
main = !flag4 ? IDBase.GetMain(hit2.collider.gameObject) : instance.idMain;
if ((main != null) && ((main is StructureComponent) || main.CompareTag("Door")))
{
flag3 = true;
}
}
}
if (flag3)
{
damageQuantity *= 0.2f;
}
TakeDamage.HurtSelf(component, damageQuantity, null);
}
else if (component.type == StructureComponent.StructureComponentType.Pillar)
{
if (!SM.ComponentCarryingWeight(component))
{
TakeDamage.HurtSelf(component, damageQuantity, null);
}
}
else if (component.type == StructureComponent.StructureComponentType.Ceiling)
{
if (!SM.ComponentCarryingWeight(component))
{
TakeDamage.HurtSelf(component, damageQuantity, null);
}
}
else if (component.type == StructureComponent.StructureComponentType.Foundation)
{
if (!SM.ComponentCarryingWeight(component))
{
TakeDamage.HurtSelf(component, damageQuantity, null);
}
}
else
{
TakeDamage.HurtSelf(component, damageQuantity, null);
}
}
}
}
return StructureMaster.DecayStatus.Decaying;
}
public virtual bool CheckLocation(StructureMaster master, Vector3 placePos, Quaternion placeRot)
{
bool flag = false;
bool flag2 = false;
Vector3 vector = master.transform.InverseTransformPoint(placePos);
if ((master.GetMaterialType() != StructureMaster.StructureMaterialType.UNSET) && (master.GetMaterialType() != this.GetMaterialType()))
{
if (logFailures)
{
Debug.Log("Not proper material type, master is :" + master.GetMaterialType());
}
return(false);
}
StructureComponent componentFromPositionWorld = master.GetComponentFromPositionWorld(placePos);
if (componentFromPositionWorld != null)
{
if (logFailures)
{
Debug.Log("Occupied space", componentFromPositionWorld);
}
flag = true;
}
StructureComponent component2 = master.CompByLocal(vector - new Vector3(0f, StructureMaster.gridSpacingY, 0f));
if ((this.type != StructureComponentType.Foundation) && master.GetFoundationForPoint(placePos))
{
flag2 = true;
}
if (((this.type == StructureComponentType.Wall) || (this.type == StructureComponentType.Doorway)) || (this.type == StructureComponentType.WindowWall))
{
if (!flag)
{
Vector3 worldPos = placePos + ((Vector3)((placeRot * -Vector3.right) * 2.5f));
StructureComponent context = master.GetComponentFromPositionWorld(worldPos);
Vector3 vector3 = placePos + ((Vector3)((placeRot * Vector3.right) * 2.5f));
StructureComponent component4 = master.GetComponentFromPositionWorld(vector3);
if (logFailures)
{
Debug.DrawLine(worldPos, vector3, Color.cyan);
}
if ((context != null) && (component4 != null))
{
bool flag4;
bool flag5;
if (context.type != StructureComponentType.Pillar)
{
if (logFailures)
{
Debug.Log("Left was not acceptable", context);
}
flag4 = false;
}
else
{
flag4 = true;
}
if (component4.type != StructureComponentType.Pillar)
{
if (logFailures)
{
Debug.Log("Right was not acceptable", component4);
}
flag5 = false;
}
else
{
flag5 = true;
}
return(flag4 && flag5);
}
if (logFailures)
{
if (context == null)
{
Debug.Log("Did not find left");
}
if (component4 == null)
{
Debug.Log("Did not find right");
}
}
}
return(false);
}
if (this.type == StructureComponentType.Foundation)
{
foreach (StructureMaster master2 in StructureMaster.AllStructuresWithBounds)
{
if ((master2 != master) && master2.containedBounds.Intersects(new Bounds(placePos, new Vector3(5f, 5f, 4f))))
{
if (logFailures)
{
Debug.Log("Too close to something");
}
return(false);
}
}
bool flag6 = master.IsValidFoundationSpot(placePos);
if (logFailures)
{
Debug.Log(string.Concat(new object[] { "returning here : mastervalid:", flag6, "compinplace", componentFromPositionWorld }));
}
return(flag6 && (componentFromPositionWorld == 0));
}
if (this.type == StructureComponentType.Ramp)
{
return((componentFromPositionWorld == null) && (master.IsValidFoundationSpot(placePos) || ((component2 != null) && ((component2.type == StructureComponentType.Ceiling) || (component2.type == StructureComponentType.Foundation)))));
}
if (this.type == StructureComponentType.Pillar)
{
return((((component2 != null) && (component2.type == StructureComponentType.Pillar)) || flag2) && !flag);
}
if ((this.type != StructureComponentType.Stairs) && (this.type != StructureComponentType.Ceiling))
{
return(false);
}
if (flag)
{
return(false);
}
Vector3[] vectorArray = new Vector3[] { new Vector3(-2.5f, 0f, -2.5f), new Vector3(2.5f, 0f, 2.5f), new Vector3(-2.5f, 0f, 2.5f), new Vector3(2.5f, 0f, -2.5f) };
foreach (Vector3 vector4 in vectorArray)
{
StructureComponent component5 = master.CompByLocal(vector + vector4);
if ((component5 == null) || (component5.type != StructureComponentType.Pillar))
{
return(false);
}
}
return(true);
}
internal StructureMaster[] Filter(StructureMaster[] structures, string id)
{
return (from s in structures
where s.ownerID.ToString() == id
select s).ToArray<StructureMaster>();
}
private void OnStructureDecay(StructureMaster master)
{
HookCalled("OnStructureDecay");
// Print structure info
if (!OnStructureDecayCalled)
{
Puts("Structure at " + master.transform.position.ToString() + " owned by player with SteamID " + master.ownerID + " took decay damage.");
OnStructureDecayCalled = true;
}
}
internal StructureMaster[] Filter(StructureMaster[] structures, string[] id)
{
return (from s in structures
where id.Contains(s.ownerID.ToString())
select s).ToArray<StructureMaster>();
}
public static StructureMaster[] SmallerThan(StructureMaster structure)
{
return(Structures.SmallerThan(structure.containedBounds.size.sqrMagnitude));
}
public static EventTimer TimeEvent_TeleportTo(NetUser Sender, NetUser Target, string Command, double time)
{
Events.Class38 @class = new Events.Class38();
@class.netUser_0 = Sender;
@class.netUser_1 = Target;
@class.string_0 = Command;
EventTimer result;
if (Core.CommandTeleportOutdoorsOnly)
{
Vector3 position = @class.netUser_1.playerClient.controllable.character.transform.position;
Collider[] array = Physics.OverlapSphere(position, 1f, 271975425);
for (int i = 0; i < array.Length; i++)
{
Collider component = array[i];
IDMain main = IDBase.GetMain(component);
if (!(main == null))
{
StructureMaster component2 = main.GetComponent <StructureMaster>();
if (!(component2 == null) && component2.ownerID != @class.netUser_0.userID && component2.ownerID != @class.netUser_1.userID)
{
UserData bySteamID = Users.GetBySteamID(component2.ownerID);
if (bySteamID == null || (!bySteamID.HasShared(@class.netUser_0.userID) && !bySteamID.HasShared(@class.netUser_1.userID)))
{
Broadcast.Notice(@class.netUser_0, "☢", Config.GetMessage("Command.Teleport.NoTeleport", @class.netUser_0, @class.netUser_1.displayName), 5f);
Broadcast.Notice(@class.netUser_1, "☢", Config.GetMessage("Command.Teleport.NotHere", @class.netUser_1, @class.netUser_0.displayName), 5f);
result = null;
return(result);
}
}
}
}
}
Broadcast.Message(@class.netUser_0, Config.GetMessage("Command.Teleport.IsConfirm", @class.netUser_0, null).Replace("%USERNAME%", @class.netUser_1.displayName), null, 0f);
Broadcast.Message(@class.netUser_1, Config.GetMessage("Command.Teleport.Confirmed", @class.netUser_1, null).Replace("%USERNAME%", @class.netUser_0.displayName), null, 0f);
if (!Character.FindByUser(@class.netUser_1.userID, out @class.character_0))
{
result = null;
}
else if (time <= 0.0)
{
Events.Teleport_PlayerTo(null, @class.netUser_0, @class.netUser_1, @class.string_0, @class.character_0.transform.position);
result = null;
}
else
{
EventTimer eventTimer = new EventTimer
{
Interval = time * 1000.0,
AutoReset = false
};
eventTimer.Elapsed += new ElapsedEventHandler(@class.method_0);
eventTimer.Sender = @class.netUser_0;
eventTimer.Target = @class.netUser_1;
eventTimer.Command = @class.string_0;
Broadcast.Notice(@class.netUser_0, "☢", Config.GetMessage("Command.Teleport.Timewait", @class.netUser_0, null).Replace("%TIME%", eventTimer.TimeLeft.ToString()), 5f);
Broadcast.Notice(@class.netUser_1, "☢", Config.GetMessage("Command.Teleport.Timewait", @class.netUser_1, null).Replace("%TIME%", eventTimer.TimeLeft.ToString()), 5f);
eventTimer.Start();
result = eventTimer;
}
return(result);
}
/// <summary>
/// Checks if the object is a StructureMaster
/// </summary>
/// <returns>Returns true if it is.</returns>
public bool IsStructureMaster()
{
StructureMaster str = this.Object as StructureMaster;
return(str != null);
}
internal StructureMaster[] Filter(StructureMaster[] structures, Vector3 loc, float distance)
{
return (from s in structures
where s.containedBounds.SqrDistance(loc) <= distance * distance
select s).ToArray<StructureMaster>();
}
internal StructureMaster[] Filter(StructureMaster[] structures, Material material)
{
return (from s in structures
where s.GetMaterialType().ToString() == material.ToString()
select s).ToArray<StructureMaster>();
}
public void Command(User pl, string cmd, string[] args)
{
if(cmd == "esshelp")
{
pl.Message("Fougerite-Essentials " + Version + " by ice cold");
pl.Message("/help - see all commands");
pl.Message("/rules - see all the rules");
pl.Message("/info - See info about this plugin");
pl.Message("/friendhelp - See all information about the friends system");
pl.Message("/sharehelp - See all help about the share system");
if(EnableHome) { pl.Message("/home - See all help about the home system"); }
if(EnableRemove) { pl.Message("/remove - Enables/disables remover tool"); }
if(Enabletpr) { pl.Message("/tpr name - sends teleport request to that user"); pl.Message("/tpa - Accepts an teleport reqequest"); }
if(EnableWarps) { pl.Message("/warphelp - See all the help for the warping system"); }
if(pl.Admin || pl.Moderator)
{
pl.Message("/prod - Shows the owner of the object you are looking at");
pl.Message("/country player - Shows from which country a player comes");
pl.Message("/download url filename - downloads that object and put it in the the Downloaded folder EXAMPLE: (/download http://myitem.com myitem.zip)");
pl.Message("/addnewspawn - adds a new spawns to the overwrite spawn list");
}
}
else if(cmd == "country")
{
if(pl.Admin || pl.Moderator)
{
if(args.Length != 1) { pl.Message("Usage /country player"); return; }
User target = Server.GetServer().FindPlayer(args[0]);
if(target == null) { pl.Message("Couldn't find the target user"); return; }
string country = PlayerDatabase.GetSetting(target.SteamID, "Country");
pl.Message("[color #ffb90f]" + target.Name + " is located from [color #c1ffc1]" + country);
}
}
else if(cmd == "download")
{
if(pl.Admin)
{
if(args.Length != 2) { pl.Message("Usage /download url filename - EXAMPLE: (/download http://myitem.com myitem.zip)"); return; }
using (WebClient web = new WebClient())
{
web.DownloadFileAsync(new Uri(args[0]), Util.GetRootFolder() + "\\Save\\Fougerite-Essentials\\Downloaded\\" + args[1]);
pl.Message("[color #00ced1]Downloading " + args[1] + " to downloaded folder");
}
}
}
else if(cmd == "addnewspawn")
{
if(pl.Admin)
{
if(EnableNewSpawns)
{
string[] c = SpawnsOverwrite.EnumSection("SpawnLocations");
string co = (Convert.ToInt32(c[c.Length - 1]) + 1).ToString();
SpawnsOverwrite.AddSetting("SpawnLocations", co, pl.Location.ToString());
SpawnsOverwrite.Save();
}
}
}
else if(cmd == "warphelp")
{
pl.Message("Fougerite-Essentials WarpSystem by ice cold");
pl.Message("/warp name - Warps you to that location");
pl.Message("/warps - See all the current warps");
if(pl.Admin)
{
pl.Message("/warp_set Name");
pl.Message("/warp_remove Name");
}
}
else if(cmd == "warp")
{
if(args.Length != 1) { pl.Message("Usage /warp name"); return; }
if(Warps.ContainsSetting("Warps", args[0]))
{
if (pl.Admin)
{
Vector3 loc = Util.GetUtil().ConvertStringToVector3(Warps.GetSetting("Warps", args[0]));
pl.TeleportTo(loc);
pl.Message("[color#00bfff]Warped to " + args[0]);
}
else
{
if(!warpcd.Contains(pl.UID))
{
var dict = new Dictionary<string, object>();
dict["pl"] = pl;
warpcd.Add(pl.UID);
Warpcooldown(WarpCooldown * 1000, dict).Start();
Warpdelaytimer(WarpDelay * 1000, dict).Start();
string message = WarpDelayMessage.Replace("{warpname}", args[0]);
}
else
{
pl.Message(WarpCooldownMessage);
}
}
}
}
else if(cmd == "warps")
{
pl.Message("WarpsList");
string[] l = Warps.EnumSection("Warps");
foreach(var num in l)
{
pl.Message(num);
}
}
else if(cmd == "warp_set")
{
if(pl.Admin)
{
if(args.Length != 1) { pl.Message("Usage /warp_set Name"); return; }
if(Warps.ContainsSetting("Warps", args[0])) { pl.Message("There is already a warp with the name " + args[0]); return; }
Warps.AddSetting("Warps", args[0], pl.Location.ToString());
Warps.Save();
pl.Message("Warp saved");
}
}
else if(cmd == "warp_remove")
{
if(pl.Admin)
{
if(args.Length != 1) { pl.Message("Usage /warp_remove Name"); return; }
if(!Warps.ContainsSetting("Warps", args[0])) { pl.Message("There is no warp with the name " + args[0]); return; }
Warps.DeleteSetting("Warps", args[0]);
Warps.Save();
pl.Message("The warp " + args[0] + " has been succesfully removed");
}
}
else if(cmd == "help")
{
if(EnableHelp)
{
foreach (var h in HelpList.EnumSection("Help"))
{
string d = HelpList.GetSetting("Help", h);
pl.MessageFrom("Help", d);
}
}
}
else if(cmd == "rules")
{
if(EnableRules)
{
foreach (var r in RulesList.EnumSection("Rules"))
{
string d = RulesList.GetSetting("Help", r);
pl.MessageFrom("Help", d);
}
}
}
else if(cmd == "info")
{
pl.MessageFrom(Name, "[color #87cefa][Fougerite-Essentials " + Version + " plugin brought by ice cold");
pl.MessageFrom(Name, "[color #20b2aa]Wanna support ice cold? https://www.patreon.com/uberrust");
pl.MessageFrom(Name, "[color #8470ff]You can download this plugin at ");
}
else if(cmd == "friendhelp")
{
pl.Message("[Fougerite-Essentials] Friends system brought by ice cold");
pl.Message("/addfriend Name - ads player to your friends list");
pl.Message("/unfriend Name - Unfriend someone");
pl.Message("/friends - See all your friends");
}
else if(cmd == "sharehelp")
{
pl.Message("[Fougerite-Essentials] Share system brought by ice cold");
pl.Message("/share Name - Door/structure share the player");
pl.Message("/unshare Name - unshare someone");
pl.Message("/sharelist - See all the people you have shared");
}
else if(cmd == "addfriend")
{
if(EnableFriendsSystem)
{
if (args.Length != 1) { pl.Message("Usage /addfriend Name"); return; }
User target = Server.GetServer().FindPlayer(args[0]);
if (target == null) { pl.Message("Couldn't find the target user"); return; }
if (friends.ContainsSetting(pl.SteamID, target.SteamID)) { string message = AlreadyFriendedMessage.Replace("{friend}", target.Name); pl.Message(message); return; }
string me = AddFriendMessage.Replace("{friend}", target.Name);
pl.Message(me);
friends.AddSetting(pl.SteamID, target.SteamID, target.Name);
friends.Save();
}
}
else if(cmd == "unfriend")
{
if(EnableShareSystem)
{
if (args.Length != 1) { pl.Message("Usage /unfriend Name"); return; }
User target = Server.GetServer().FindPlayer(args[0]);
if(target == null) { pl.Message("Couldn't find the target user"); return; }
if(!friends.ContainsSetting(pl.SteamID, target.SteamID)) { pl.Message(target.Name + " Isnt in your friends list"); return; }
friends.DeleteSetting(pl.SteamID, target.SteamID);
friends.Save();
string message = UnfriendMessage.Replace("{target}", target.Name);
pl.Message(message);
friends.DeleteSetting(pl.SteamID, target.SteamID);
friends.Save();
}
}
else if(cmd == "friends")
{
if(EnableFriendsSystem)
{
pl.Message("===FriendsList===");
foreach (var id in friends.EnumSection(pl.SteamID))
{
string m = friends.GetSetting(pl.SteamID, id);
pl.Message("_ " + m);
}
}
}
else if(cmd == "share")
{
if(EnableShareSystem)
{
if(args.Length != 1) { pl.Message("Usage /share Name"); return; }
User target = Server.GetServer().FindPlayer(args[0]);
if (target == null) { pl.Message("Couldn't find the target user"); return; }
if(share.ContainsSetting(pl.SteamID, target.SteamID)) { string message = AlreadySharedMessage.Replace("{player}", target.Name); pl.Message(message); return; }
share.AddSetting(pl.SteamID, target.SteamID, target.Name);
share.Save();
string me = SharedMessage.Replace("{player}", target.Name);
pl.Message(me);
}
}
else if(cmd == "unshare")
{
if(EnableShareSystem)
{
if(args.Length != 1) { pl.Message("Usage /unshare Name"); return; }
User target = Server.GetServer().FindPlayer(args[0]);
if(target == null) { pl.Message("Couldn't find the target user"); return; }
if(!share.ContainsSetting(pl.SteamID, target.SteamID)) { pl.Message("You are not sharing with " + target.Name); return; }
share.DeleteSetting(pl.SteamID, target.SteamID);
share.Save();
string message = UnSharedMessage.Replace("{player}", target.Name);
pl.Message(message);
}
}
else if(cmd == "sharelist")
{
if(EnableShareSystem)
{
pl.Message("===ShareList===");
foreach(var id in share.EnumSection(pl.SteamID))
{
string m = share.GetSetting(pl.SteamID, id);
pl.Message("- " + m);
}
}
}
else if(cmd == "prod")
{
if(pl.Admin || pl.Moderator)
{
cachedCharacter = pl.PlayerClient.rootControllable.idMain.GetComponent<Character>();
if (!MeshBatchPhysics.Raycast(cachedCharacter.eyesRay, out cachedRaycast, out cachedBoolean, out cachedhitInstance)) { pl.Message("He Hello thats the sky bro"); return; }
if(cachedhitInstance != null)
{
cachedCollider = cachedhitInstance.physicalColliderReferenceOnly;
if (cachedCollider == null) { pl.Message("Sorry but i cannot prod that"); return; }
cachedStructure = cachedCollider.GetComponent<StructureComponent>();
if (cachedStructure != null && cachedStructure._master != null)
{
cachedMaster = cachedStructure._master;
var name = PlayerDatabase.GetSetting(cachedMaster.ownerID.ToString(), "Name");
pl.Message(string.Format("{object} - {ID} - {name}", cachedStructure.gameObject.name, cachedMaster.ownerID.ToString(), name == null ? "Unknown" : name.ToString()));
}
}
else
{
cachedDeployable = cachedRaycast.collider.GetComponent<DeployableObject>();
if(cachedDeployable != null)
{
var name = PlayerDatabase.GetSetting(cachedMaster.ownerID.ToString(), "Name");
pl.Message(string.Format("{object} - {ID} - {name}", cachedDeployable.gameObject.name, cachedDeployable.ownerID.ToString(), name == null ? cachedDeployable.ownerName.ToString() : name.ToString()));
}
}
pl.Message("Failed to prod " + cachedRaycast.collider.gameObject.name);
}
}
else if(cmd == "home")
{
if(EnableHome)
{
if(args.Length != 1)
{
pl.Message("[Fougerite-Essentials] Home system brought by ice cold");
if(!SleepingHome)
{
pl.Message("/home Name - teleports you the home");
pl.Message("/sethome Name - Enabled sethome mode (hit a foundation or ceiling to save your home)");
pl.Message("/delhome Name - Deletes that home");
pl.Message("/homes - Shows the list of homes");
}
else
{
pl.Message("/homeon - Enables home mode (place a Sleepingbag or Bed to save that as your current home)");
pl.Message("/gohome - Teleports you to your sleepingBag or Bed");
}
}
else
{
if(!SleepingHome)
{
if(!homecd.Contains(pl.UID))
{
if (StructureHome.ContainsSetting(pl.SteamID, args[0]))
{
var homeloc = StructureHome.GetSetting(pl.SteamID, args[0]);
var dict = new Dictionary<string, object>();
dict["pl"] = pl;
dict["homeloc"] = homeloc;
HomeTimer(HomeDelay * 1000, dict).Start();
string message = HomeDelayMessage.Replace("{home}", args[0]).Replace("{delay}", HomeDelay.ToString());
pl.Message(message);
HomeCooldown(HomeCooldown * 1000, dict).Start();
homecd.Add(pl.UID);
}
else
{
string message = NoHomeMessage.Replace("{home}", args[0]);
pl.Message(message);
}
}
else
{
string message = HomeCooldownMessage.Replace("{cooldown}", HomeCooldown.ToString());
pl.Message(message);
}
}
}
}
}
else if(cmd == "sethome")
{
if(EnableHome)
{
if(!homemode.Contains(pl.UID))
{
if (args.Length != 1) { pl.Message("Usage /sethome Name"); return; }
string[] l = StructureHome.EnumSection(pl.SteamID);
if ((Convert.ToBoolean(l.Length == MaxHomes)))
{
pl.Message(MaxHomesMessage);
}
else
{
homemode.Add(pl.UID);
pl.Message("Sethome mode activated hit a foundation/ceiling to set your home");
homenum.Add(pl.UID, args[0]);
}
}
else
{
pl.Message("Please do /homestop first");
}
}
}
else if(cmd == "")
}
private void OnCommand(Fougerite.Player player, string cmd, string[] args)
{
switch (cmd)
{
case "record":
{
if (player.Admin || PermissionSystem.GetPermissionSystem().PlayerHasPermission(player, "recorder.record"))
{
if (args.Length == 0)
{
player.MessageFrom("Recorder", "Usage: /record name");
return;
}
object state = DataStore.GetInstance().Get("Recorder", player.UID);
if (state != null)
{
player.MessageFrom("Recorder", "Already Recording!");
return;
}
string name = string.Join("_", args).ToLower();
DataStore.GetInstance().Flush("RecordedData" + player.UID);
DataStore.GetInstance().Add("Recorder", player.UID, 1);
DataStore.GetInstance().Add("Recorder_Name", player.UID, name);
player.MessageFrom("Recorder", "Recording " + name + ".ini (/rstop to finish!)");
}
break;
}
case "rspawn":
if (player.Admin || PermissionSystem.GetPermissionSystem().PlayerHasPermission(player, "recorder.rspawn"))
{
if (args.Length != 2)
{
player.MessageFrom("Recorder", "Usage: /rspawn name.ini distance");
return;
}
float distance = 0f;
bool success = float.TryParse(args[1], out distance);
if (!success)
{
player.MessageFrom("Recorder", "Usage: /rspawn name.ini distance");
return;
}
if (!File.Exists(Path.Combine(ModuleFolder, "Buildings\\" + args[0])))
{
player.MessageFrom("Recorder", "Building not found!");
return;
}
IniParser file = new IniParser(Path.Combine(ModuleFolder, "Buildings\\" + args[0]));
DataStore.GetInstance().Flush("SpawnedData" + player.UID);
DataStore.GetInstance().Remove("RecorderSMs", player.UID);
Vector3 playerFront = Util.GetUtil().Infront(player, distance);
float groundposition = World.GetWorld().GetGround(playerFront.x, playerFront.z);
//playerFront.y = World.GetGround(playerFront.x, playerFront.z);
List <string> sections = file.Sections.Where(x => x != "Init").ToList();
StructureMaster master = null;
int failures = 0;
for (int i = 0; i < sections.Count; i++)
{
Vector3 entPos = Util.GetUtil().CreateVector(float.Parse(file.GetSetting("Part" + i, "PosX")),
float.Parse(file.GetSetting("Part" + i, "PosY")),
float.Parse(file.GetSetting("Part" + i, "PosZ")));
Vector3 spawnPos = Util.GetUtil().CreateVector(entPos.x + playerFront.x, entPos.y + groundposition,
entPos.z + playerFront.z);
Quaternion spawnRot = Util.GetUtil().CreateQuat(float.Parse(file.GetSetting("Part" + i, "RotX")),
float.Parse(file.GetSetting("Part" + i, "RotY")),
float.Parse(file.GetSetting("Part" + i, "RotZ")),
float.Parse(file.GetSetting("Part" + i, "RotW")));
if (master == null)
{
master = World.GetWorld()
.CreateSM(player, spawnPos.x, spawnPos.y, spawnPos.z, spawnRot);
}
Entity go = null;
try
{
go = World.GetWorld().SpawnEntity(file.GetSetting("Part" + i, "Prefab"), spawnPos,
spawnRot);
}
catch
{
failures++;
// Ignore.
continue;
}
try
{
if (go.IsLootableObject())
{
LootableObject lootableObject = (LootableObject)go.Object;
go.ChangeOwner(player);
DataStore.GetInstance().Add("SpawnedData" + player.UID, "Part" + i,
lootableObject.gameObject);
}
else if (go.IsDeployableObject())
{
go.ChangeOwner(player);
DeployableObject deployableObject = (DeployableObject)go.Object;
DataStore.GetInstance().Add("SpawnedData" + player.UID, "Part" + i,
deployableObject.gameObject);
}
else if (go.IsBasicDoor())
{
BasicDoor door = (BasicDoor)go.Object;
go.ChangeOwner(player);
DataStore.GetInstance().Add("SpawnedData" + player.UID, "Part",
door.gameObject);
}
else if (go.IsStructure())
{
StructureComponent structureComponent = (StructureComponent)go.Object;
master.AddStructureComponent(structureComponent);
DataStore.GetInstance().Add("SpawnedData" + player.UID, "Part" + i,
structureComponent.gameObject);
}
}
catch (Exception ex)
{
Logger.LogError("[Recorder] Error: " + ex);
Logger.LogError("At prefab: " + file.GetSetting("Part" + i, "Prefab"));
}
}
player.MessageFrom("Recorder", args[0] + " was spawned !");
if (failures > 0)
{
player.MessageFrom("Recorder", failures + " amount of failures happened. This file might have wrong values!");
}
}
break;
case "rlist":
if (player.Admin || PermissionSystem.GetPermissionSystem().PlayerHasPermission(player, "recorder.rlist"))
{
string[] files = Directory.GetFiles(Path.Combine(ModuleFolder, "Buildings\\"), "*.ini");
for (int i = 0; i < files.Length; i++)
{
files[i] = Path.GetFileName(files[i]);
}
player.MessageFrom("Recorder", "=== Files ===");
player.MessageFrom("Recorder", string.Join(", ", files));
}
break;
case "rcancel":
if (player.Admin || PermissionSystem.GetPermissionSystem().PlayerHasPermission(player, "recorder.rcancel"))
{
int cpt = DataStore.GetInstance().Count("SpawnedData" + player.UID);
for (int i = 0; i < cpt; i++)
{
GameObject ent = DataStore.GetInstance().Get("SpawnedData" + player.UID, "Part" + i) as GameObject;
if (ent != null)
{
Util.GetUtil().DestroyObject(ent);
}
DataStore.GetInstance().Remove("Recorder", player.UID);
DataStore.GetInstance().Flush("RecordedData" + player.UID);
DataStore.GetInstance().Flush("SpawnedData" + player.UID);
DataStore.GetInstance().Remove("RecorderInit", player.UID);
DataStore.GetInstance().Remove("RecorderSMs", player.UID);
}
DataStore.GetInstance().Flush("SpawnedData" + player.UID);
player.Message("Cancelled recording");
}
break;
case "rstop":
if (player.Admin || PermissionSystem.GetPermissionSystem().PlayerHasPermission(player, "recorder.rstop"))
{
string name = (string)DataStore.GetInstance().Get("Recorder_Name", player.UID);
if (File.Exists(Path.Combine(ModuleFolder, "Buildings\\" + name)))
{
var rnd = new Random();
int rnd2 = rnd.Next(0, 500000);
player.Message(name + ".ini already exists ! renaming..");
name = name + rnd2;
}
name = name + ".ini";
Vector3 loc = (Vector3)DataStore.GetInstance().Get("RecorderInit", player.UID);
float groundposition = World.GetWorld().GetGround(loc.x, loc.z);
//loc.y = World.GetGround(loc.x, loc.z)
int cpt = DataStore.GetInstance().Count("RecordedData" + player.UID);
if (cpt == 0)
{
DataStore.GetInstance().Flush("RecordedData" + player.UID);
return;
}
if (!File.Exists(Path.Combine(ModuleFolder, "Buildings\\" + name)))
{
File.Create(Path.Combine(ModuleFolder, "Buildings\\" + name)).Dispose();
}
IniParser rfile = new IniParser(Path.Combine(ModuleFolder, "Buildings\\" + name));
for (int i = 0; i < cpt; i++)
{
Entity ent = (Entity)DataStore.GetInstance().Get("RecordedData" + player.UID, "Part" + i);
Vector3 entPos = new Vector3((ent.X - loc.x), (ent.Y - groundposition),
(ent.Z - loc.z));
Quaternion spawnRot = ent.Rotation;
rfile.AddSetting("Part" + i, "Prefab", Prefabs[ent.Name]);
rfile.AddSetting("Part" + i, "PosX", entPos.x.ToString(CultureInfo.CurrentCulture));
rfile.AddSetting("Part" + i, "PosY", entPos.y.ToString(CultureInfo.CurrentCulture));
rfile.AddSetting("Part" + i, "PosZ", entPos.z.ToString(CultureInfo.CurrentCulture));
rfile.AddSetting("Part" + i, "RotX", spawnRot.x.ToString(CultureInfo.CurrentCulture));
rfile.AddSetting("Part" + i, "RotY", spawnRot.y.ToString(CultureInfo.CurrentCulture));
rfile.AddSetting("Part" + i, "RotZ", spawnRot.z.ToString(CultureInfo.CurrentCulture));
rfile.AddSetting("Part" + i, "RotW", spawnRot.w.ToString(CultureInfo.CurrentCulture));
}
DataStore.GetInstance().Remove("Recorder", player.UID);
DataStore.GetInstance().Flush("RecordedData" + player.UID);
DataStore.GetInstance().Flush("SpawnedData" + player.UID);
DataStore.GetInstance().Remove("RecorderInit", player.UID);
DataStore.GetInstance().Remove("RecorderSMs", player.UID);
DataStore.GetInstance().Flush("SpawnedData" + player.UID);
rfile.Save();
player.MessageFrom("Recorder", name + " was saved !");
}
break;
}
}
Vector3 FindFirstComponent(StructureMaster master)
{
foreach( StructureComponent comp in (HashSet<StructureComponent>)structurecomplist.GetValue(master))
{
return comp.transform.position;
}
return default(Vector3);
}
