private IEnumerator DowngradeBuildingBlocks(BasePlayer player, BuildingGrade.Enum targetGrade, PermissionSettings permS, bool isAdmin)
{
int current = 0, success = 0;
var autoGrade = targetGrade == BuildingGrade.Enum.None;
foreach (var buildingBlock in allBuildingBlocks)
{
if (buildingBlock == null || buildingBlock.IsDestroyed)
{
continue;
}
BuildingGrade.Enum grade = targetGrade;
if (CheckBuildingGrade(buildingBlock, false, ref grade))
{
if (!autoGrade || tempGrantedGrades.Contains(grade))
{
if (TryDowngradeToGrade(buildingBlock, player, grade /*, permS.refund*/, isAdmin: isAdmin))
{
success++;
}
}
}
if (current++ % configData.globalS.perFrame == 0)
{
yield return(CoroutineEx.waitForEndOfFrame);
}
}
if (player != null && player.IsConnected)
{
Print(player, success > 0 ? Lang("FinishedDowngrade", player.UserIDString, success) : Lang("NotDowngraded", player.UserIDString));
}
}
void PasteBuilding(List <object> structureData, Vector3 targetPoint, float targetRot, float heightAdjustment)
{
Vector3 OriginRotation = new Vector3(0f, targetRot, 0f);
Quaternion OriginRot = Quaternion.EulerRotation(OriginRotation);
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"];
if (!prefabname.Contains(".prefab"))
{
prefabname = "assets/bundled/prefabs/" + prefabname + ".prefab";
}
BuildingGrade.Enum grade = (BuildingGrade.Enum)structure["grade"];
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;
GameObject newPrefab = GameManager.server.FindPrefab(prefabname);
if (newPrefab != null)
{
var block = SpawnStructure(newPrefab, NewPos, newAngles, grade);
if (block && block.HasSlot(BaseEntity.Slot.Lock))
{
TryPasteLock(block, structure);
}
}
}
}
void OnStructureUpgrade(BuildingBlock block, BasePlayer player, BuildingGrade.Enum grade)
{
if (sd.OnUpgrade.ContainsKey("From" + block.grade.ToString() + "To" + grade.ToString()) == false)
{
sd.OnUpgrade.Add("From" + block.grade.ToString() + "To" + grade.ToString(), 1);
}
else
{
if (sd.PlayerXP.ContainsKey(player.UserIDString) == false)
{
sd.PlayerXP.Add(player.UserIDString, 0);
}
if (sd.PlayerLevel.ContainsKey(player.UserIDString) == false)
{
sd.PlayerLevel.Add(player.UserIDString, 1);
}
XPToAdd[player] = XPToAdd[player] + sd.OnUpgrade["From" + block.grade.ToString() + "To" + grade.ToString()];
PlayerStreakEnded[player] = false;
PlayerStreakTime[player] = sd.StreakTimeEnd;
if (sd.PlayerXP[player.UserIDString] >= (sd.XpNeededPerLevel_Will_be_Mutiplied_By_Level * sd.PlayerLevel[player.UserIDString]) * sd.PlayerLevel[player.UserIDString])
{
sd.PlayerXP[player.UserIDString] = 0;
sd.PlayerLevel[player.UserIDString] = sd.PlayerLevel[player.UserIDString] + 1;
Reconomy.Call("GiveMoney", player, sd.MoneyPerLevel_Will_be_Mutiplied_By_Level * sd.PlayerLevel[player.UserIDString], "You leveled up!", true);
}
}
}
public override float GetDecayDelay(BaseEntity entity)
{
BuildingBlock buildingBlock = entity as BuildingBlock;
BuildingGrade.Enum grade = (buildingBlock ? buildingBlock.grade : BuildingGrade.Enum.Twigs);
return(GetDecayDelay(grade));
}
HashSet <BuildingBlock> FindAllCupboardlessBlocks(BuildingGrade.Enum grade)
{
var blocks = FindAllBuildingBlocks(grade);
FilterAllCupboardless(blocks);
return(blocks);
}
// Upgrading construction blocks.
private object CanAffordUpgrade(BasePlayer player, BuildingBlock block, BuildingGrade.Enum iGrade)
{
var ruleset = GetPlayerRuleset(player.UserIDString);
if (ruleset == null)
{
return(null);
}
var args = new object[] { player, block, iGrade };
object otherPluginResult;
if (PluginReturnedResult(VerificationGatekeeper, nameof(OnPayForPlacement), out otherPluginResult, args))
{
return(otherPluginResult);
}
if (!ruleset.PlayerHasAmountList(player, block.GetGrade(iGrade).costToBuild))
{
return(false);
}
// Return true to allow placement, skipping vanilla validation.
return(true);
}
private bool CanDemolish(BasePlayer player, BuildingBlock block, BuildingGrade.Enum grade)
{
var @event =
new RustPlayerDemolishingBuildingBlockEvent(new RustPlayer(player), new RustBuildingBlock(block));
return(EmitCancellableReturnsBool(@event));
}
//Oxide Hook
void OnStructureUpgrade(BuildingBlock block, BasePlayer player, BuildingGrade.Enum grade)
{
if (block.grade == BuildingGrade.Enum.Twigs)
{
if (allowDemolish)
{
block.SetFlag(BaseEntity.Flags.Reserved2, true);
if (this.amountOfMinutesAfterUpgrade > 0)
{
addBlockToList(block, DateTime.Now);
}
}
}
else if (block.name.Contains("build/door.hinged") && block.grade == BuildingGrade.Enum.Wood)
{
if (allowDemolishDoors)
{
block.SetFlag(BaseEntity.Flags.Reserved2, true);
if (this.amountOfMinutesAfterUpgrade > 0)
{
addBlockToList(block, DateTime.Now);
}
}
}
}
void OnStructureUpgrade(BaseCombatEntity block, BasePlayer player, BuildingGrade.Enum grade)
{
if (block != null && upgradeBlockCheck.Contains(block as BuildingBlock))
{
upgradeBlockCheck.Remove(block as BuildingBlock);
return;
}
if (!playersInfo.ContainsKey(player.userID))
{
playersInfo[player.userID] = new PlayerDetails();
}
if ((enablePermission && !permission.UserHasPermission(player.UserIDString, permissionName)) || PlayerHasFlag(player.userID, PlayerFlags.PLUGIN_DISABLED))
{
return;
}
if (playersInfo[player.userID].upgradeInfo != grade)
{
playersInfo[player.userID].upgradeInfo = grade;
RenderMode(player, false);
if (!PlayerHasFlag(player.userID, PlayerFlags.MESSAGES_DISABLED))
{
player.ChatMessage(pluginPrefix + string.Format(lang.GetMessage("UpgradeModeGrade", this, player.UserIDString), grade.ToString()));
}
}
if (enableDistanceUpgrade && player.GetComponent <EHammer>() == null)
{
player.gameObject.AddComponent <EHammer>();
}
RefreshTimer(player);
}
private bool CanAffordUpgrade(BuildingGrade.Enum iGrade, BasePlayer player)
{
bool flag;
object obj = Interface.CallHook("CanAffordUpgrade", player, this, iGrade);
if (obj as bool)
{
return((bool)obj);
}
List <ItemAmount> .Enumerator enumerator = this.GetGrade(iGrade).costToBuild.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
ItemAmount current = enumerator.Current;
if ((float)player.inventory.GetAmount(current.itemid) >= current.amount)
{
continue;
}
flag = false;
return(flag);
}
return(true);
}
finally
{
((IDisposable)enumerator).Dispose();
}
return(flag);
}
void PasteBuilding(List <object> structureData, Vector3 targetPoint, float targetRot, float heightAdjustment)
{
Vector3 OriginRotation = new Vector3(0f, targetRot, 0f);
//Quaternion OriginRot = Quaternion.EulerRotation(OriginRotation);
Quaternion OriginRot = Quaternion.Euler(OriginRotation);;
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"];
BuildingGrade.Enum grade = (BuildingGrade.Enum)structure["grade"];
Quaternion newAngles = Quaternion.Euler((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;
GameObject newPrefab = GameManager.server.FindPrefab(prefabname);
if (newPrefab != null)
{
var block = SpawnStructure(newPrefab, NewPos, newAngles, grade);
block.enableStability = false;
//block.isClient = true;
//supports.SetValue(block, null);
//var supp = supports.GetValue(block) as BuildingBlock.Support;
if (block && block.HasSlot(BaseEntity.Slot.Lock))
{
TryPasteLock(block, structure);
}
}
}
}
object CanChangeGrade(BasePlayer player, BuildingBlock block, BuildingGrade.Enum grade)
{
if (permission.UserHasPermission(player.UserIDString, "upgradepermissions.all"))
{
return(true);
}
if (grade == BuildingGrade.Enum.Wood && !permission.UserHasPermission(player.UserIDString, WoodPermission))
{
SendReply(player, Lang("Wood", player.UserIDString));
return(false);
}
if (grade == BuildingGrade.Enum.Stone && !permission.UserHasPermission(player.UserIDString, StonePermission))
{
SendReply(player, Lang("Stone", player.UserIDString));
return(false);
}
if (grade == BuildingGrade.Enum.Metal && !permission.UserHasPermission(player.UserIDString, SheetMetalPermission))
{
SendReply(player, Lang("SheetMetal", player.UserIDString));
return(false);
}
if (grade == BuildingGrade.Enum.TopTier && !permission.UserHasPermission(player.UserIDString, ArmouredPermission))
{
SendReply(player, Lang("Armoured", player.UserIDString));
return(false);
}
return(null);
}
public BuildingPartGradeChangeEvent(BuildingBlock bb, BuildingGrade.Enum bgrade, BasePlayer player)
{
BuildingPart = new BuildingPart(bb);
Builder = Server.GetPlayer(player);
grade = bgrade;
HasPrivilege = (bool)bb.CallMethod("CanChangeToGrade", bgrade, player);
}
public BuildingPartGradeChangeEvent(BuildingBlock bb, BuildingGrade.Enum bgrade, BasePlayer player)
{
BuildingPart = new BuildingPart(bb);
Builder = Server.GetPlayer(player);
grade = bgrade;
HasPrivilege = (bool)bb.CallMethod("CanChangeToGrade", bgrade, player);
}
ConstructionGrade GetGrade(BuildingBlock block, BuildingGrade.Enum iGrade)
{
if (block.grade >= (BuildingGrade.Enum)block.blockDefinition.grades.Length)
{
return(block.blockDefinition.defaultGrade);
}
return(block.blockDefinition.grades[(int)iGrade]);
}
private bool HasUpgradePrivilege(BuildingGrade.Enum iGrade, BasePlayer player)
{
if (iGrade == this.grade || iGrade >= (BuildingGrade.Enum) this.blockDefinition.grades.Length || (iGrade < BuildingGrade.Enum.Twigs || iGrade < this.grade))
{
return(false);
}
return(!player.IsBuildingBlocked(((Component)this).get_transform().get_position(), ((Component)this).get_transform().get_rotation(), this.bounds));
}
private void OnStructureUpgrade(BuildingBlock block, BasePlayer player, BuildingGrade.Enum grade)
{
if (block == null || player == null || !HasPerms(player.UserIDString, "hammertime.allowed"))
{
return;
}
NextTick(() => DoInvokes(block, false, block?.blockDefinition?.canRotate ?? true));
}
public RustBuildingBlockUpgradingEvent(
RustBuildingBlock buildingBlock,
RustPlayer player,
BuildingGrade.Enum grade) : base(buildingBlock)
{
Player = player;
Grade = grade;
}
private object CanChangeGrade(BasePlayer player, BuildingBlock block, BuildingGrade.Enum iGrade)
{
if (DeployVolume.Check(block.transform.position, block.transform.rotation, PrefabAttribute.server.FindAll <DeployVolume>(block.prefabID), ~(1 << block.gameObject.layer)))
{
return(false);
}
return(null);
}
private bool HasGradePermission(BasePlayer player, BuildingGrade.Enum grade, bool isUpgrade)
{
return(isUpgrade
? permission.UserHasPermission(player.UserIDString, PERMISSION_UP_ALL) ||
permission.UserHasPermission(player.UserIDString, PERMISSION_UP + (int)grade)
: permission.UserHasPermission(player.UserIDString, PERMISSION_DOWN_ALL) ||
permission.UserHasPermission(player.UserIDString, PERMISSION_DOWN + (int)grade));
}
HashSet <BuildingBlock> FindAllBuildingBlocks(BuildingGrade.Enum grade)
{
var started_at = Time.realtimeSinceStartup;
var blocks = new HashSet <BuildingBlock>(((ListDictionary <uint, BaseNetworkable>)entityListField.GetValue(BaseNetworkable.serverEntities)).Values.OfType <BuildingBlock>().Where(block => block.grade == grade));
Puts($"Finding {blocks.Count} {grade} blocks took {Time.realtimeSinceStartup - started_at:0.000} seconds");
return(blocks);
}
private ConstructionGrade GetGrade(BuildingGrade.Enum iGrade)
{
if ((int)this.grade < (int)this.blockDefinition.grades.Length)
{
return(this.blockDefinition.grades[(int)iGrade]);
}
Debug.LogWarning(string.Concat(new object[] { "Grade out of range ", base.gameObject, " ", this.grade, " / ", (int)this.blockDefinition.grades.Length }));
return(this.blockDefinition.defaultGrade);
}
bool?OnStructureUpgrade(BaseCombatEntity entity, BasePlayer player, BuildingGrade.Enum grade)
{
JDeployable.Child c = entity?.GetComponent <JDeployable.Child>();
if (c != null && c.parent != null && player != null)
{
return(c.parent.OnStructureUpgrade(c, player, grade));
}
return(null);
}
private ConstructionGrade GetGrade(BuildingGrade.Enum iGrade)
{
if (this.grade < (BuildingGrade.Enum) this.blockDefinition.grades.Length)
{
return(this.blockDefinition.grades[(int)iGrade]);
}
Debug.LogWarning((object)("Grade out of range " + (object)((Component)this).get_gameObject() + " " + (object)this.grade + " / " + (object)this.blockDefinition.grades.Length));
return(this.blockDefinition.defaultGrade);
}
public ConstructionGrade GetGrade(BuildingGrade.Enum iGrade)
{
if ((int)grade >= blockDefinition.grades.Length)
{
Debug.LogWarning(string.Concat("Grade out of range ", base.gameObject, " ", grade, " / ", blockDefinition.grades.Length));
return(blockDefinition.defaultGrade);
}
return(blockDefinition.grades[(int)iGrade]);
}
public void SetGrade(BuildingGrade.Enum iGradeID)
{
if (this.blockDefinition.grades == null || (int)iGradeID >= (int)this.blockDefinition.grades.Length)
{
Debug.LogError(string.Concat("Tried to set to undefined grade! ", this.blockDefinition.fullName), base.gameObject);
return;
}
this.grade = iGradeID;
this.grade = this.currentGrade.gradeBase.type;
this.UpdateGrade();
}
void DrawUI(BasePlayer player, BuildingGrade.Enum grade, int seconds)
{
if (!loaded)
{
return;
}
DestroyUI(player);
CuiHelper.AddUi(player,
GUI.Replace("{0}", gradesString[grade]).Replace("{1}", seconds.ToString())
.Replace("{2}", gradeImages[$"building.upgrade.{(int) grade}"]));
}
object OnStructureUpgrade(BuildingBlock block, BasePlayer player, BuildingGrade.Enum gradeEnum)
{
var grade = gradeEnum.ToString();
if ((bool)Config[grade] || IsAllowed(player.UserIDString, $"{Title}.{grade}"))
{
return(null);
}
PrintToChat(player, Lang("NotAllowed", player.UserIDString, grade));
return(true);
}
public void SetGrade(BuildingGrade.Enum iGradeID)
{
if (blockDefinition.grades == null || (int)iGradeID >= blockDefinition.grades.Length)
{
Debug.LogError("Tried to set to undefined grade! " + blockDefinition.fullName, base.gameObject);
return;
}
grade = iGradeID;
grade = currentGrade.gradeBase.type;
UpdateGrade();
}
void DrawUI(BasePlayer player, BuildingGrade.Enum grade, int seconds)
{
if (!loaded)
{
return;
}
string imgString = seconds.ToString("00");
string image1 = ImageStorage.FetchPng(imgString[0].ToString());
string image2 = ImageStorage.FetchPng(imgString[1].ToString());
core.DrawUI(player, "BuildingUpgrade", "menu", gradeImages[$"building.upgrade.{(int) grade}"], image1, image2);
}
public override void ResetState()
{
base.ResetState();
this.blockDefinition = null;
this.forceSkinRefresh = false;
this.modelState = 0;
this.lastModelState = 0;
this.grade = BuildingGrade.Enum.Twigs;
this.lastGrade = BuildingGrade.Enum.None;
this.DestroySkin();
this.UpdatePlaceholder(true);
}
public StructureComponent(BuildingPart bp, SerializedVector3 v3, SerializedQuaternion q)
{
Grade = bp.buildingBlock.grade;
Prefab = bp.buildingBlock.LookupPrefabName();
LocalPosition = v3;
LocalRotation = q;
Health = (float)((int)Math.Floor((double)(bp.Health / 85)) * 85);
if (bp.buildingBlock.HasSlot(BaseEntity.Slot.Lock))
{
var baseLock = bp.buildingBlock.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (baseLock == null)
{
HasCodeLock = false;
HasKeyLock = false;
}
else if (baseLock.GetComponent<CodeLock>())
{
HasCodeLock = true;
HasKeyLock = false;
CodeLock codeLock = baseLock.GetComponent<CodeLock>();
if (!string.IsNullOrEmpty((string)codeLock.GetFieldValue("code")))
{
LockCode = (string)codeLock.GetFieldValue("code");
LockWList = new List<ulong>();
LockWList = (List<ulong>)codeLock.GetFieldValue("whitelistPlayers");
}
}
else if (baseLock.GetComponent<KeyLock>())
{
HasCodeLock = false;
HasKeyLock = true;
KeyLock keyLock = baseLock.GetComponent<KeyLock>();
int keyCode = (int)keyLock.GetFieldValue("keyCode");
keyCode = (bool)keyLock.GetFieldValue("firstKeyCreated") ? keyCode |= 0x80 : (int)keyLock.GetFieldValue("keyCode");
LockCode = keyCode.ToString();
}
}
}
public BuildingUpgradeEvent(BuildingBlock buildingBlock, BuildingGrade.Enum buildingGrade, BasePlayer basePlayer)
{
BuildingPart = new BuildingPart(buildingBlock);
Grade = buildingGrade;
Player = Server.GetPlayer(basePlayer);
}
