public int GetItemTypeFromStatueStyle(StatueStyle statueStyle) {
int itemType;
if (!statueStyleItemTypeLookup.Value.TryGetValue(statueStyle, out itemType))
throw new ArgumentException("StatueStyle");
return itemType;
}
private void TellNoStatueWiringPermission(TSPlayer player, StatueStyle statue)
{
player.SendErrorMessage("You don't have the required permission to wire up statues of type ");
player.SendErrorMessage(string.Concat('"', statue.ToString(), '"'));
this.PluginTrace.WriteLineInfo(
"Player \"{0}\" tried to wire a statue of type \"{1}\" but didn't have the necessary permissions to do so.",
player.Name, statue.ToString()
);
}
public static Configuration Read(string filePath)
{
XmlReaderSettings configReaderSettings = new XmlReaderSettings {
ValidationType = ValidationType.Schema,
ValidationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints | XmlSchemaValidationFlags.ReportValidationWarnings
};
string configSchemaPath = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath) + ".xsd");
configReaderSettings.Schemas.Add(null, configSchemaPath);
XmlDocument document = new XmlDocument();
using (XmlReader configReader = XmlReader.Create(filePath, configReaderSettings))
document.Load(configReader);
// Before validating using the schema, first check if the configuration file's version matches with the supported version.
XmlElement rootElement = document.DocumentElement;
string fileVersionRaw;
if (rootElement.HasAttribute("Version"))
{
fileVersionRaw = rootElement.GetAttribute("Version");
}
else
{
fileVersionRaw = "1.0";
}
if (fileVersionRaw != Configuration.CurrentVersion)
{
throw new FormatException(string.Format(
"The configuration file is either outdated or too new. Expected version was: {0}. File version is: {1}",
Configuration.CurrentVersion, fileVersionRaw
));
}
Configuration resultingConfig = new Configuration(false);
resultingConfig.OverrideVanillaCircuits = BoolEx.ParseEx(rootElement["OverrideVanillaCircuits"].InnerXml);
resultingConfig.AdvancedCircuitsEnabled = BoolEx.ParseEx(rootElement["AdvancedCircuitsEnabled"].InnerText);
resultingConfig.MaxTrapsPerCircuit = int.Parse(rootElement["MaxTrapsPerCircuit"].InnerText);
resultingConfig.MaxStatuesPerCircuit = int.Parse(rootElement["MaxStatuesPerCircuit"].InnerText);
resultingConfig.MaxPumpsPerCircuit = int.Parse(rootElement["MaxPumpsPerCircuit"].InnerText);
resultingConfig.MaxCircuitLength = int.Parse(rootElement["MaxCircuitLength"].InnerText);
if (string.IsNullOrWhiteSpace(rootElement["MaxTimerActivityTime"].InnerText))
{
resultingConfig.MaxTimerActivityTime = TimeSpan.Zero;
}
else
{
TimeSpan maxTimerActivityTime;
if (TimeSpanEx.TryParseShort(rootElement["MaxTimerActivityTime"].InnerText, out maxTimerActivityTime))
{
resultingConfig.MaxTimerActivityTime = maxTimerActivityTime;
}
}
resultingConfig.SignConfig = SignConfig.FromXmlElement(rootElement["SignConfig"]);
resultingConfig.BlockActivatorConfig = BlockActivatorConfig.FromXmlElement(rootElement["BlockActivatorConfig"]);
XmlElement pumpConfigsNode = rootElement["PumpConfigs"];
foreach (XmlNode pumpConfigNode in pumpConfigsNode.ChildNodes)
{
XmlElement pumpConfigElement = (pumpConfigNode as XmlElement);
if (pumpConfigElement == null)
{
continue;
}
PaintColor paintColor = (PaintColor)Enum.Parse(typeof(PaintColor), pumpConfigElement.Attributes["Paint"].Value);
resultingConfig.PumpConfigs.Add(paintColor, PumpConfig.FromXmlElement(pumpConfigElement));
}
XmlElement trapConfigsNode = rootElement["TrapConfigs"];
foreach (XmlNode trapConfigNode in trapConfigsNode.ChildNodes)
{
XmlElement trapConfigElement = (trapConfigNode as XmlElement);
if (trapConfigElement == null)
{
continue;
}
TrapStyle trapStyle = (TrapStyle)Enum.Parse(typeof(TrapStyle), trapConfigElement.Attributes["TrapType"].Value);
PaintColor paintColor = (PaintColor)Enum.Parse(typeof(PaintColor), trapConfigElement.Attributes["Paint"].Value);
resultingConfig.TrapConfigs.Add(new TrapConfigKey(trapStyle, paintColor), TrapConfig.FromXmlElement(trapConfigElement));
}
/*XmlElement explosivesConfigsNode = rootElement["ExplosivesConfigs"];
* foreach (XmlNode explosivesConfigNode in explosivesConfigsNode.ChildNodes) {
* XmlElement explosivesConfigElement = (explosivesConfigNode as XmlElement);
* if (explosivesConfigElement == null)
* continue;
*
* ComponentConfigProfile componentConfigProfile = (ComponentConfigProfile)Enum.Parse(typeof(ComponentConfigProfile), explosivesConfigElement.Attributes["Profile"].Value);
* resultingConfig.explosivesConfigs.Add(componentConfigProfile, ExplosivesConfig.FromXmlElement(explosivesConfigElement));
* }*/
XmlElement wirelessTransmitterConfigsNode = rootElement["WirelessTransmitterConfigs"];
foreach (XmlNode wirelessTransmitterConfigNode in wirelessTransmitterConfigsNode.ChildNodes)
{
XmlElement wirelessTransmitterConfigElement = (wirelessTransmitterConfigNode as XmlElement);
if (wirelessTransmitterConfigElement == null)
{
continue;
}
PaintColor paintColor = (PaintColor)Enum.Parse(typeof(PaintColor), wirelessTransmitterConfigElement.Attributes["Paint"].Value);
resultingConfig.WirelessTransmitterConfigs.Add(paintColor, WirelessTransmitterConfig.FromXmlElement(wirelessTransmitterConfigElement));
}
XmlElement statueConfigsNode = rootElement["StatueConfigs"];
foreach (XmlNode statueConfigNode in statueConfigsNode.ChildNodes)
{
XmlElement statueConfigElement = (statueConfigNode as XmlElement);
if (statueConfigElement == null)
{
continue;
}
StatueStyle statueStyle = (StatueStyle)Enum.Parse(typeof(StatueStyle), statueConfigElement.Attributes["StatueType"].Value);
resultingConfig.StatueConfigs.Add(statueStyle, StatueConfig.FromXmlElement(statueConfigElement));
}
return(resultingConfig);
}
private bool HandleWirePlace(TSPlayer player, DPoint location)
{
if (this.IsDisposed)
{
return(false);
}
DPoint[] tilesToCheck = new[] {
location,
new DPoint(location.X - 1, location.Y),
new DPoint(location.X + 1, location.Y),
new DPoint(location.X, location.Y - 1),
new DPoint(location.X, location.Y + 1),
};
foreach (DPoint tileToCheck in tilesToCheck)
{
ITile tile = TerrariaUtils.Tiles[tileToCheck];
if (!tile.active())
{
continue;
}
if (tileToCheck != location && tile.type != AdvancedCircuits.BlockType_WirelessTransmitter)
{
continue;
}
bool hasPermission = true;
ObjectMeasureData measureData = TerrariaUtils.Tiles.MeasureObject(tileToCheck);
PaintColor componentPaint = (PaintColor)TerrariaUtils.Tiles[measureData.OriginTileLocation].color();
switch (tile.type)
{
case TileID.Statues: {
StatueStyle statueStyle = TerrariaUtils.Tiles.GetStatueStyle(tile);
StatueConfig statueConfig;
if (!this.Config.StatueConfigs.TryGetValue(statueStyle, out statueConfig))
{
return(false);
}
if (string.IsNullOrEmpty(statueConfig.WirePermission))
{
return(false);
}
hasPermission = player.Group.HasPermission(statueConfig.WirePermission);
if (!hasPermission)
{
this.TellNoStatueWiringPermission(player, statueStyle);
player.SendTileSquare(location, 1);
return(true);
}
break;
}
case TileID.Traps: {
TrapConfig trapConfig;
TrapConfigKey configKey = new TrapConfigKey(TerrariaUtils.Tiles.GetTrapStyle(TerrariaUtils.Tiles[location].frameY / 18), componentPaint);
if (!this.Config.TrapConfigs.TryGetValue(configKey, out trapConfig))
{
break;
}
if (string.IsNullOrEmpty(trapConfig.WirePermission))
{
break;
}
hasPermission = player.Group.HasPermission(trapConfig.WirePermission);
break;
}
case TileID.Boulder: {
hasPermission = player.Group.HasPermission(AdvancedCircuitsPlugin.WireBoulder_Permission);
break;
}
case TileID.Signs: {
hasPermission = player.Group.HasPermission(AdvancedCircuitsPlugin.WireSign_Permission);
break;
}
case TileID.InletPump:
case TileID.OutletPump: {
PumpConfig pumpConfig;
if (!this.Config.PumpConfigs.TryGetValue(componentPaint, out pumpConfig))
{
break;
}
hasPermission = player.Group.HasPermission(pumpConfig.WirePermission);
break;
}
case AdvancedCircuits.BlockType_WirelessTransmitter: {
WirelessTransmitterConfig transmitterConfig;
if (!this.Config.WirelessTransmitterConfigs.TryGetValue(componentPaint, out transmitterConfig))
{
break;
}
hasPermission = player.Group.HasPermission(transmitterConfig.WirePermission);
break;
}
case TileID.Teleporter: {
hasPermission = player.Group.HasPermission(AdvancedCircuitsPlugin.WireTeleporter_Permission);
break;
}
}
if (!hasPermission)
{
this.TellMissingComponentWiringPermission(player, tile.type);
player.SendTileSquare(location, 1);
return(true);
}
}
return(false);
}
private bool CheckTilePermission(TSPlayer player, DPoint location, int blockType, int objectStyle, PaintColor paint, bool dropItem = false)
{
switch (blockType)
{
case TileID.Statues: {
DPoint originTileLocation = new DPoint(location.X - 1, location.Y - 2);
if (!TerrariaUtils.Tiles.IsObjectWired(originTileLocation, new DPoint(2, 3)))
{
break;
}
StatueStyle statueStyle = TerrariaUtils.Tiles.GetStatueStyle(objectStyle);
StatueConfig statueConfig;
if (!this.Config.StatueConfigs.TryGetValue(statueStyle, out statueConfig) || statueConfig == null)
{
break;
}
if (!player.Group.HasPermission(statueConfig.WirePermission))
{
player.SendTileSquareEx(location, 10);
if (dropItem)
{
int itemTypeToDrop;
itemTypeToDrop = TerrariaUtils.Tiles.GetItemTypeFromStatueStyle(statueStyle);
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, itemTypeToDrop);
}
this.TellNoStatueWiringPermission(player, statueStyle);
return(false);
}
break;
}
case TileID.Traps: {
ITile destTile = TerrariaUtils.Tiles[location];
if (!destTile.HasWire())
{
break;
}
TrapConfig trapConfig;
TrapStyle trapStyle = TerrariaUtils.Tiles.GetTrapStyle(destTile.frameY / 18);
TrapConfigKey configKey = new TrapConfigKey(trapStyle, paint);
if (!this.Config.TrapConfigs.TryGetValue(configKey, out trapConfig))
{
break;
}
if (!player.Group.HasPermission(trapConfig.WirePermission))
{
player.SendTileSquareEx(location, 10);
if (dropItem)
{
int itemTypeToDrop = TerrariaUtils.Tiles.GetItemTypeFromTrapStyle(trapStyle);
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, itemTypeToDrop);
}
this.TellMissingComponentWiringPermission(player, blockType);
return(false);
}
break;
}
case TileID.Boulder: {
DPoint originTileLocation = new DPoint(location.X - 1, location.Y - 1);
if (!TerrariaUtils.Tiles.IsObjectWired(originTileLocation, new DPoint(2, 2)))
{
break;
}
if (!player.Group.HasPermission(AdvancedCircuitsPlugin.WireBoulder_Permission))
{
player.SendTileSquareEx(location, 10);
if (dropItem)
{
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, ItemID.Boulder);
}
this.TellMissingComponentWiringPermission(player, blockType);
return(false);
}
break;
}
case TileID.Signs: {
if (!TerrariaUtils.Tiles.IsObjectWired(location, new DPoint(2, 2)))
{
break;
}
if (!player.Group.HasPermission(AdvancedCircuitsPlugin.WireSign_Permission))
{
player.SendTileSquareEx(location, 10);
if (dropItem)
{
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, ItemID.Sign);
}
this.TellMissingComponentWiringPermission(player, blockType);
return(false);
}
break;
}
case TileID.InletPump:
case TileID.OutletPump: {
DPoint originTileLocation = new DPoint(location.X - 1, location.Y - 1);
if (!TerrariaUtils.Tiles.IsObjectWired(originTileLocation, new DPoint(2, 2)))
{
break;
}
PumpConfig pumpConfig;
if (!this.Config.PumpConfigs.TryGetValue(paint, out pumpConfig))
{
break;
}
if (string.IsNullOrEmpty(pumpConfig.WirePermission))
{
break;
}
if (!player.Group.HasPermission(pumpConfig.WirePermission))
{
player.SendTileSquareEx(location, 10);
if (dropItem)
{
int itemTypeToDrop = ItemID.OutletPump;
if (blockType == ItemID.InletPump)
{
itemTypeToDrop = ItemID.InletPump;
}
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, itemTypeToDrop);
}
this.TellMissingComponentWiringPermission(player, blockType);
return(false);
}
break;
}
case AdvancedCircuits.BlockType_WirelessTransmitter: {
if (!AdvancedCircuits.IsComponentWiredByPort(location, new DPoint(1, 1)))
{
break;
}
WirelessTransmitterConfig transmitterConfig;
if (!this.Config.WirelessTransmitterConfigs.TryGetValue(paint, out transmitterConfig))
{
break;
}
if (!player.Group.HasPermission(transmitterConfig.WirePermission))
{
player.SendTileSquareEx(location, 1);
if (dropItem)
{
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, ItemID.AdamantiteOre);
}
this.TellMissingComponentWiringPermission(player, blockType);
return(false);
}
break;
}
case ItemID.Teleporter: {
DPoint originTileLocation = new DPoint(location.X - 1, location.Y - 1);
if (!TerrariaUtils.Tiles.IsObjectWired(originTileLocation, new DPoint(3, 1)))
{
break;
}
if (!player.Group.HasPermission(AdvancedCircuitsPlugin.WireTeleporter_Permission))
{
player.SendTileSquareEx(location, 10);
if (dropItem)
{
Item.NewItem(location.X * TerrariaUtils.TileSize, location.Y * TerrariaUtils.TileSize, 0, 0, ItemID.Teleporter);
}
this.TellMissingComponentWiringPermission(player, blockType);
return(false);
}
break;
}
}
return(true);
}
public ItemType GetItemTypeFromStatueStyle(StatueStyle statueStyle)
{
switch (statueStyle) {
case StatueStyle.Armor:
return ItemType.Statue;
case StatueStyle.Angel:
return ItemType.AngelStatue;
case StatueStyle.Star:
return ItemType.StarStatue;
case StatueStyle.Sword:
return ItemType.SwordStatue;
case StatueStyle.Slime:
return ItemType.SlimeStatue;
case StatueStyle.Goblin:
return ItemType.GoblinStatue;
case StatueStyle.Shield:
return ItemType.ShieldStatue;
case StatueStyle.Bat:
return ItemType.BatStatue;
case StatueStyle.Fish:
return ItemType.FishStatue;
case StatueStyle.Bunny:
return ItemType.BunnyStatue;
case StatueStyle.Skeleton:
return ItemType.SkeletonStatue;
case StatueStyle.Reaper:
return ItemType.ReaperStatue;
case StatueStyle.Woman:
return ItemType.WomanStatue;
case StatueStyle.Imp:
return ItemType.ImpStatue;
case StatueStyle.Gargoyle:
return ItemType.GargoyleStatue;
case StatueStyle.Gloom:
return ItemType.GloomStatue;
case StatueStyle.Hornet:
return ItemType.HornetStatue;
case StatueStyle.Bomb:
return ItemType.BombStatue;
case StatueStyle.Crab:
return ItemType.CrabStatue;
case StatueStyle.Hammer:
return ItemType.HammerStatue;
case StatueStyle.Potion:
return ItemType.PotionStatue;
case StatueStyle.Spear:
return ItemType.SpearStatue;
case StatueStyle.Cross:
return ItemType.CrossStatue;
case StatueStyle.Jellyfish:
return ItemType.JellyfishStatue;
case StatueStyle.Bow:
return ItemType.BowStatue;
case StatueStyle.Boomerang:
return ItemType.BoomerangStatue;
case StatueStyle.Boot:
return ItemType.BootStatue;
case StatueStyle.Chest:
return ItemType.ChestStatue;
case StatueStyle.Bird:
return ItemType.BirdStatue;
case StatueStyle.Axe:
return ItemType.AxeStatue;
case StatueStyle.Corrupt:
return ItemType.CorruptStatue;
case StatueStyle.Tree:
return ItemType.TreeStatue;
case StatueStyle.Anvil:
return ItemType.AnvilStatue;
case StatueStyle.Pickaxe:
return ItemType.PickaxeStatue;
case StatueStyle.Mushroom:
return ItemType.MushroomStatue;
case StatueStyle.Eyeball:
return ItemType.EyeballStatue;
case StatueStyle.Pillar:
return ItemType.PillarStatue;
case StatueStyle.Heart:
return ItemType.HeartStatue;
case StatueStyle.Pot:
return ItemType.PotStatue;
case StatueStyle.Sunflower:
return ItemType.SunflowerStatue;
case StatueStyle.King:
return ItemType.KingStatue;
case StatueStyle.Queen:
return ItemType.QueenStatue;
case StatueStyle.Piranha:
return ItemType.PiranhaStatue;
case StatueStyle.Lihzahrd:
return ItemType.LihzahrdStatue;
case StatueStyle.LihzahrdGuardian:
return ItemType.LihzahrdGuardianStatue;
case StatueStyle.LihzahrdWatcher:
return ItemType.LihzahrdWatcherStatue;
case StatueStyle.BlueDungeonVase:
return ItemType.BlueDungeonVase;
case StatueStyle.GreenDungeonVase:
return ItemType.GreenDungeonVase;
case StatueStyle.PinkDungeonVase:
return ItemType.PinkDungeonVase;
case StatueStyle.ObsidianVase:
return ItemType.ObsidianVase;
case StatueStyle.Shark:
return ItemType.SharkStatue;
default:
throw new ArgumentException("StatueStyle");
}
}
private void TellNoStatueWiringPermission(TSPlayer player, StatueStyle statue)
{
player.SendErrorMessage("You don't have the required permission to wire up statues of type ");
player.SendErrorMessage(string.Concat('"', statue.ToString(), '"'));
this.PluginTrace.WriteLineInfo(
"Player \"{0}\" tried to wire a statue of type \"{1}\" but didn't have the necessary permissions to do so.",
player.Name, statue.ToString()
);
}
