/**
* Checks whether the block requires power and parses the power sources.
*/
protected void CheckRequiresPower()
{
if (!this.blockTransformerBlock.Block.Properties.Values.ContainsKey(propRequirePower))
{
this.requirePower = false;
this.powerSources = new List <string>()
{
"electricwirerelay"
};
return;
}
string requirePowerValue = blockTransformerBlock.Block.Properties.Values[propRequirePower].ToString();
bool requirePower;
this.requirePower = (StringParsers.TryParseBool(requirePowerValue, out requirePower) ? requirePower : false);
this.powerSources = new List <string>();
if (!this.blockTransformerBlock.Block.Properties.Values.ContainsKey(propPowerSources))
{
this.powerSources.Add("electricwirerelay");
}
else
{
this.powerSources = StringHelpers.WriteStringToList(this.blockTransformerBlock.Block.Properties.Values[propPowerSources]);
}
this.CheckBlocksDefined(this.powerSources);
}
public static void RemoveRadiusEffect(String strItemClass, ref Block myBlock)
{
ItemClass itemClass = ItemClass.GetItemClass(strItemClass, false);
if (itemClass.Properties.Values.ContainsKey("ActivatedBuff"))
{
String strBuff = itemClass.Properties.Values["ActivatedBuff"];
string[] array5 = strBuff.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
// Grab the current radius effects
List <BlockRadiusEffect> list2 = myBlock.RadiusEffects.OfType <BlockRadiusEffect>().ToList();
foreach (string text4 in array5)
{
int num12 = text4.IndexOf('(');
int num13 = text4.IndexOf(')');
BlockRadiusEffect item = default(BlockRadiusEffect);
if (num12 != -1 && num13 != -1 && num13 > num12 + 1)
{
item.radius = StringParsers.ParseFloat(text4.Substring(num12 + 1, num13 - num12 - 1), 0, -1, NumberStyles.Any);
item.variable = text4.Substring(0, num12);
}
else
{
item.radius = 1f;
item.variable = text4;
}
if (list2.Contains(item))
{
list2.Remove(item);
}
}
myBlock.RadiusEffects = list2.ToArray();
}
}
public static bool CheckFeatureStatus(string strClass, string strFeature)
{
BlockValue ConfigurationFeatureBlock = Block.GetBlockValue("ConfigFeatureBlock");
if (ConfigurationFeatureBlock.type == 0)
{
// AdvLogging.DisplayLog("Configuration", "Feature: " + strFeature + " No Configuration Block");
return(false);
}
bool result = false;
if (ConfigurationFeatureBlock.Block.Properties.Classes.ContainsKey(strClass))
{
DynamicProperties dynamicProperties3 = ConfigurationFeatureBlock.Block.Properties.Classes[strClass];
foreach (System.Collections.Generic.KeyValuePair <string, object> keyValuePair in dynamicProperties3.Values.Dict.Dict)
{
if (string.Equals(keyValuePair.Key, strFeature, System.StringComparison.CurrentCultureIgnoreCase))
{
result = StringParsers.ParseBool(dynamicProperties3.Values[keyValuePair.Key]);
}
}
}
// UnityEngine.Debug.Log(" Configuration: " + strClass + " : " + strFeature + " : Result: " + result);
//ConsoleCmdAIDirectorDebug.("Configuration", "Feature: " + strFeature + " Result: " + result);
return(result);
}
public static bool CheckFeatureStatus(string strClass, string strFeature)
{
BlockValue ConfigurationFeatureBlock = Block.GetBlockValue("ConfigFeatureBlock");
if (ConfigurationFeatureBlock.type == 0)
{
return(false);
}
bool result = false;
if (ConfigurationFeatureBlock.Block.Properties.Classes.ContainsKey(strClass))
{
DynamicProperties dynamicProperties3 = ConfigurationFeatureBlock.Block.Properties.Classes[strClass];
foreach (System.Collections.Generic.KeyValuePair <string, object> keyValuePair in dynamicProperties3.Values.Dict.Dict)
{
if (string.Equals(keyValuePair.Key, strFeature, System.StringComparison.CurrentCultureIgnoreCase))
{
result = StringParsers.ParseBool(dynamicProperties3.Values[keyValuePair.Key]);
}
}
}
return(result);
}
// Over-ride for CopyProperties to allow it to read in StartingQuests.
public override void CopyPropertiesFromEntityClass()
{
base.CopyPropertiesFromEntityClass();
EntityClass entityClass = EntityClass.list[this.entityClass];
flEyeHeight = EntityUtilities.GetFloatValue(entityId, "EyeHeight");
// Read in a list of names then pick one at random.
if (entityClass.Properties.Values.ContainsKey("Names"))
{
string text = entityClass.Properties.Values["Names"];
string[] Names = text.Split(',');
int index = UnityEngine.Random.Range(0, Names.Length);
strMyName = Names[index];
}
if (entityClass.Properties.Values.ContainsKey("SleeperInstantAwake"))
{
isAlwaysAwake = true;
}
if (entityClass.Properties.Values.ContainsKey("Titles"))
{
string text = entityClass.Properties.Values["Titles"];
string[] Names = text.Split(',');
int index = UnityEngine.Random.Range(0, Names.Length);
strTitle = Names[index];
}
if (entityClass.Properties.Classes.ContainsKey("Boundary"))
{
DisplayLog(" Found Bandary Settings");
String strBoundaryBox = "0,0,0";
String strCenter = "0,0,0";
DynamicProperties dynamicProperties3 = entityClass.Properties.Classes["Boundary"];
foreach (KeyValuePair <string, object> keyValuePair in dynamicProperties3.Values.Dict.Dict)
{
DisplayLog("Key: " + keyValuePair.Key);
if (keyValuePair.Key == "BoundaryBox")
{
DisplayLog(" Found a Boundary Box");
strBoundaryBox = dynamicProperties3.Values[keyValuePair.Key];
continue;
}
if (keyValuePair.Key == "Center")
{
DisplayLog(" Found a Center");
strCenter = dynamicProperties3.Values[keyValuePair.Key];
continue;
}
}
Vector3 Box = StringParsers.ParseVector3(strBoundaryBox, 0, -1);
Vector3 Center = StringParsers.ParseVector3(strCenter, 0, -1);
ConfigureBounaryBox(Box, Center);
}
}
/**
* Checks whether block requires heat and parses the heat sources.
*/
protected void CheckRequiresHeat()
{
this.requireHeat = false;
this.heatSources = new List <string>()
{
"campfire"
};
string requireHeatValue;
if (!this.PropExists(propRequireHeat, out requireHeatValue))
{
return;
}
if (!StringParsers.TryParseBool(requireHeatValue, out this.requireHeat))
{
throw new Exception("Could not parse require heat parameter as a boolean.");
}
this.heatSources = new List <string>();
string heatSources;
if (this.PropExists(propHeatSources, out heatSources))
{
this.heatSources = StringHelpers.WriteStringToList(heatSources);
this.CheckBlocksDefined(this.heatSources);
}
this.heatSources.Add("campfire");
}
/**
* Checks whether the block requires power and parses the power sources.
*/
protected void CheckRequiresPower()
{
this.requirePower = false;
this.powerSources = new List <string>()
{
"electricwirerelay"
};
string requirePowerValue;
if (!this.PropExists(propRequirePower, out requirePowerValue))
{
return;
}
if (!StringParsers.TryParseBool(requirePowerValue, out this.requirePower))
{
throw new Exception("Require power could noot be parsed as a boolean value.");
}
this.powerSources = new List <string>();
string powerSources;
if (this.PropExists(propPowerSources, out powerSources))
{
this.powerSources = StringHelpers.WriteStringToList(powerSources);
this.CheckBlocksDefined(this.powerSources);
return;
}
this.powerSources.Add("electricwirerelay");
}
public override bool ParseXmlAttribute(XmlAttribute _attribute)
{
bool flag = base.ParseXmlAttribute(_attribute);
if (!flag)
{
string name = _attribute.Name;
if (name != null)
{
if (name == "item")
{
this.CreateItem = _attribute.Value;
return(true);
}
if (name == "lootgroup")
{
lootgroup = (int)StringParsers.ParseSInt64(_attribute.Value, 0, -1, NumberStyles.Any);
return(true);
}
if (name == "count")
{
this.CreateItemCount = (int)StringParsers.ParseFloat(_attribute.Value, 0, -1, NumberStyles.Any);
return(true);
}
}
}
return(flag);
}
/**
* Checks whether block requires heat and parses the heat sources.
*/
protected void CheckRequiresHeat()
{
if (!this.blockTransformerBlock.Block.Properties.Values.ContainsKey(propRequireHeat))
{
this.requireHeat = false;
this.heatSources = new List <string>()
{
"campfire"
};
return;
}
string requireHeatValue = blockTransformerBlock.Block.Properties.Values[propRequireHeat].ToString();
bool requireHeat;
this.requireHeat = (StringParsers.TryParseBool(requireHeatValue, out requireHeat) ? requireHeat : false);
this.heatSources = new List <string>();
if (!this.blockTransformerBlock.Block.Properties.Values.ContainsKey(propHeatSources))
{
this.heatSources.Add("canpfire");
}
else
{
this.heatSources = StringHelpers.WriteStringToList(this.blockTransformerBlock.Block.Properties.Values[propHeatSources]);
}
this.CheckBlocksDefined(this.heatSources);
}
public override bool ParseXmlAttribute(XmlAttribute _attribute)
{
bool flag = base.ParseXmlAttribute(_attribute);
if (!flag)
{
string name = _attribute.Name;
if (name == "effect_name")
{
this.effect_name = _attribute.Value;
return(true);
}
else if (name == "intensity")
{
this.intensity = StringParsers.ParseFloat(_attribute.Value, 0, -1, NumberStyles.Any);
return(true);
}
else if (name == "rate0")
{
this.rate0 = float.Parse(_attribute.Value);
return(true);
}
else if (name == "fade")
{
this.fade = StringParsers.ParseFloat(_attribute.Value, 0, -1, NumberStyles.Any);
return(true);
}
}
return(flag);
}
/**
* Reads the data from a string.
*/
public static TransformationJob Read(string _s, bool fromHash = false)
{
Match jobExists = TransformationQueue.queueEntryParse.Match(_s);
if (!jobExists.Success)
{
throw new Exception("Could not read job string " + _s);
}
string timeString = jobExists.Groups[1].ToString();
string dataString = jobExists.Groups[2].ToString();
string boolString = jobExists.Groups[3].ToString();
ulong transformTime;
if (!StringParsers.TryParseUInt64(timeString, out transformTime))
{
throw new Exception("Could not parse time string " + timeString);
}
bool inProgress;
if (!StringParsers.TryParseBool(boolString, out inProgress))
{
throw new Exception("Could not parse in progress string " + boolString);
}
TransformationData tData = TransformationData.Read(dataString, fromHash);
return(new TransformationJob(transformTime, tData, inProgress));
}
public override void Init()
{
base.Init();
// SoundSource is the referenced SoundDataNode
if (this.Properties.Values.ContainsKey("SoundDataNode"))
{
this.strSoundSource = this.Properties.Values["SoundDataNode"];
}
// Audio Source is the prefab name, without the asset bundle reference.
// This is used to keep track of which audio source is actually playing, so we can turn it on and off.
if (this.Properties.Values.ContainsKey("AudioSource"))
{
this.strAudioSource = this.Properties.Values["AudioSource"];
}
// The VideoSource can be an asset bundle or URL. If there is an embedded clip on the Video Player, it'll play that in preference to the URL, but
// a video in the asset bundle will over-ride
if (this.Properties.Values.ContainsKey("VideoSource"))
{
this.strVideoSource = this.Properties.Values["VideoSource"];
}
if (this.Properties.Values.ContainsKey("LootContainerSize"))
{
this.vLootContainerSize = StringParsers.ParseVector2i(this.Properties.Values["LootContainerSize"], ',');
}
else
{
this.vLootContainerSize = new Vector2i(2, 3);
}
}
/**
* Converts the XML into the drop info needed.
*/
public override bool ParseXmlAttribute(XmlAttribute _attribute)
{
bool flag = base.ParseXmlAttribute(_attribute);
if (!flag)
{
string name = _attribute.Name;
if (name == "block_name")
{
this.blockName = _attribute.Value;
return(true);
}
if (name == "range")
{
this.range = StringHelpers.WriteStringToVector3i(_attribute.Value);
if (range == Vector3i.zero)
{
return(false);
}
}
if (name == "require_materials")
{
bool requireMaterials;
if (!StringParsers.TryParseBool(_attribute.Value, out requireMaterials))
{
throw new Exception("Could not parse value as an boolean.");
}
this.requireMaterials = requireMaterials;
}
}
return(flag);
}
private bool ValidatePassport(string passport, int version)
{
var requiredFields = new HashSet <string>()
{
"byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"
};
var fields = StringParsers.SplitDelimitedStringIntoStringList(passport, new char[0]);
foreach (var field in fields)
{
var fieldAndValue = field.Split(':');
var fieldName = fieldAndValue[0];
var value = fieldAndValue[1];
if (ValidateField(fieldName, value, version))
{
if (requiredFields.Contains(fieldName))
{
requiredFields.Remove(fieldName);
}
}
}
return(requiredFields.Count() == 0);
}
public override bool ParseXmlAttribute(XmlAttribute _attribute)
{
bool based = base.ParseXmlAttribute(_attribute);
string name = _attribute.Name;
bool used = true;
if (name == "scale")
{
string val = _attribute.Value;
if (val.Contains(','))
{
scale = StringParsers.ParseVector3(val);
}
else
{
float v = float.Parse(val);
scale = v * Vectors.Float.One;
}
}
else
{
used = false;
}
return(used || based);
}
public Vector3 dsi = new Vector3(4f, 1f, 1f); // duration, speed, interleave
// NB:
// - depends on entity mass ...
// - (ghost) (4f, 1f, 1f) is very small (4f, 1f, 0f) is way too strong
// - (4,2,1): very strong, but remains alive most of the time
// todo: random duration / trigger on duration
public override bool ParseXmlAttribute(XmlAttribute _attribute)
{
bool based = base.ParseXmlAttribute(_attribute);
string name = _attribute.Name;
bool used = true;
if (name == "checkothers")
{
this.CheckOthers = bool.Parse(_attribute.Value);
}
if (name == "dirrandom")
{
this.dirrandom = float.Parse(_attribute.Value);
}
if (name == "strength")
{
this.strength = float.Parse(_attribute.Value);
}
if (name == "dsi")
{
this.dsi = StringParsers.ParseVector3(_attribute.Value);
}
else
{
used = false;
}
return(used || based);
}
public string SolveFirstStar(StreamReader reader)
{
var estimate = int.Parse(reader.ReadLine());
var nextLine = reader.ReadLine();
var buses = StringParsers.SplitDelimitedStringIntoStringList(nextLine, ",".ToCharArray());
long shortestWait = Int64.MaxValue;
int closestBus = 0;
foreach (var bus in buses)
{
if (bus == "x")
{
continue;
}
var busInterval = int.Parse(bus);
// Effectively computes -estimate % busInterval, picks the smallest positive unique solution
var waitTime = (-estimate % busInterval + busInterval) % busInterval;
if (waitTime < shortestWait)
{
shortestWait = waitTime;
closestBus = busInterval;
}
}
return((shortestWait * closestBus).ToString());
}
public override void Init()
{
base.Init();
if (this.Properties.Values.ContainsKey("RandomIndex"))
{
this.RandomIndex = StringParsers.ParseSInt32(this.Properties.Values["RandomIndex"], 0, -1, NumberStyles.Any);
}
}
public override void Init()
{
base.Init();
if (this.Properties.Values.ContainsKey("TakeDelay"))
{
this.fTakeDelay = StringParsers.ParseFloat(this.Properties.Values["TakeDelay"], 0, -1, NumberStyles.Any);
}
}
public override void GiveReward(EntityPlayer player)
{
float value = StringParsers.ParseFloat(base.Value, 0, -1, System.Globalization.NumberStyles.Float);
if (base.OwnerQuest.OwnerJournal.OwnerPlayer.Buffs.HasCustomVar(base.ID))
{
value += base.OwnerQuest.OwnerJournal.OwnerPlayer.Buffs.GetCustomVar(base.ID);
}
base.OwnerQuest.OwnerJournal.OwnerPlayer.Buffs.SetCustomVar(base.ID, value, true);
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
/*
* Direction not perfect, always moving up, jumping diagonally (issue of not waiting callback ?)
*
*/
Entity target = GameManager.Instance.World.GetLocalPlayers()[0];
if (_params.Count > 0 && _params[0] == "sg")
{
Vector3 pos = target.GetPosition();
Vector3i ipos = Vectors.ToInt(pos);
Printer.Print("pos: ", pos, "=>", ipos, "=>", Vectors.ToFloat(ipos));
Printer.Print("pos: ", ipos, "=>", Vectors.ToFloat(ipos), "=>", Vectors.ToInt(Vectors.ToFloat(ipos)));
target.SetPosition(pos); // _MoveSetPos only
return;
// also check conversion in Emplacement
}
int check = 0;
int eid = -1;
Vector3 dir = Vectors.Float.UnitY;
if (_params.Count > 0)
{
eid = int.Parse(_params[0]);
}
if (_params.Count > 1)
{
check = int.Parse(_params[1]);
}
if (_params.Count > 2)
{
dir = StringParsers.ParseVector3(_params[2]);
}
if (eid > 0)
{
target = GameManager.Instance.World.GetEntity(eid);
}
if (target == null)
{
Printer.Print("Entity not there ", eid); return;
}
Printer.Print("ConsoleCmdEMover", eid, check, dir);
EntityMover mover = new EntityMover(3, 0.2f); // .Config(1);
mover.checkCollision = check == 1;
mover.Apply(target, dir); // This is a routine... so check not executed ...
}
public override void Init()
{
base.Init();
if (this.Properties.Values.ContainsKey("ParticleName"))
{
this.particleName = this.Properties.Values["ParticleName"];
ConfigureParticles(this.particleName);
}
if (this.Properties.Values.ContainsKey("ParticleOffset"))
{
this.offset = StringParsers.ParseVector3(this.Properties.Values["ParticleOffset"], 0, -1);
}
}
// don't open the loot container.
public override bool OnBlockActivated(WorldBase _world, int _cIdx, Vector3i _blockPos, BlockValue _blockValue, EntityAlive _player)
{
if (_blockValue.Block.Properties.Values.ContainsKey("IsContainer"))
{
bool IsContainer = StringParsers.ParseBool(_blockValue.Block.Properties.Values["IsContainer"], 0, -1, true);
if (IsContainer)
{
base.OnBlockActivated(_world, _cIdx, _blockPos, _blockValue, _player);
return(true);
}
}
return(true);
}
public static void Postfix(ref EntityAlive __instance)
{
// Check if this feature is enabled.
if (Configuration.CheckFeatureStatus(AdvFeatureClass, Feature))
{
if (__instance is EntityPlayerLocal)
{
return;
}
if (RandomSizeHelper.AllowedRandomSize(__instance))
{
// This is the distributed random heigh multiplier. Add or adjust values as you see fit. By default, it's just a small adjustment.
float[] numbers = new float[9] {
0.7f, 0.8f, 0.9f, 0.9f, 1.0f, 1.0f, 1.0f, 1.1f, 1.2f
};
System.Random random = new System.Random();
int randomIndex = random.Next(0, numbers.Length);
float flScale = numbers[randomIndex];
AdvLogging.DisplayLog(AdvFeatureClass, " Random Size: " + flScale);
__instance.Buffs.AddCustomVar("RandomSize", flScale);
// scale down the zombies, or upscale them
__instance.gameObject.transform.localScale = new Vector3(flScale, flScale, flScale);
}
// Check if there's random ranges
EntityClass entityClass = __instance.EntityClass;
if (entityClass.Properties.Values.ContainsKey("RandomSizes"))
{
List <float> Ranges = new List <float>();
float flScale = 1f;
foreach (string text in entityClass.Properties.Values["RandomSizes"].Split(new char[] { ',' }))
{
Ranges.Add(StringParsers.ParseFloat(text));
}
System.Random random = new System.Random();
int randomIndex = random.Next(0, Ranges.Count);
flScale = Ranges[randomIndex];
AdvLogging.DisplayLog(AdvFeatureClass, " Random Size: " + flScale);
__instance.Buffs.AddCustomVar("RandomSize", flScale);
// scale down the zombies, or upscale them
__instance.gameObject.transform.localScale = new Vector3(flScale, flScale, flScale);
}
}
}
private void BtnOk_OnPressed(XUiController _sender, OnPressEventArgs _onPressEventArgs)
{
string text = this.txtPassword.Text;
float code = 0f;
StringParsers.TryParseFloat(text, out code);
myEntity.Buffs.AddCustomVar("PathingCode", code);
SphereCache.RemovePaths(myEntity.entityId);
EntityUtilities.GetNewPositon(myEntity.entityId);
EntityUtilities.SetCurrentOrder(myEntity.entityId, EntityUtilities.Orders.Wander);
GameManager.ShowTooltip(base.xui.playerUI.entityPlayer, "Pathing Code Set");
base.xui.playerUI.windowManager.Close(base.WindowGroup.ID);
}
public override void CopyPropertiesFromEntityClass()
{
this.npcID = "animalFarm";
base.CopyPropertiesFromEntityClass();
EntityClass entityClass = EntityClass.list[this.entityClass];
if (entityClass.Properties.Values.ContainsKey("BoundaryBox"))
{
Vector3 dim = StringParsers.ParseVector3(entityClass.Properties.Values["BoundaryBox"], 0, -1);
ConfigureBounaryBox(dim);
}
InvokeRepeating("CheckAnimalEvent", 1f, 60f);
}
public void SetupAutoPathingBlocks()
{
if (this.Buffs.HasCustomVar("PathingCode"))
{
return;
}
// Check if pathing blocks are defined.
List <string> Blocks = EntityUtilities.ConfigureEntityClass(this.entityId, "PathingBlocks");
if (Blocks.Count == 0)
{
Blocks = new List <string>()
{
"PathingCube"
}
}
;
//Scan for the blocks in the area
List <Vector3> PathingVectors = ModGeneralUtilities.ScanForTileEntityInChunksListHelper(this.position, Blocks, this.entityId);
if (PathingVectors == null || PathingVectors.Count == 0)
{
return;
}
// Find the nearest block, and if its a sign, read its code.
Vector3 target = ModGeneralUtilities.FindNearestBlock(this.position, PathingVectors);
TileEntitySign tileEntitySign = GameManager.Instance.World.GetTileEntity(0, new Vector3i(target)) as TileEntitySign;
if (tileEntitySign == null)
{
return;
}
// Since signs can have multiple codes, splite with a ,, parse each one.
String text = tileEntitySign.GetText();
float code = 0f; // Defined here as DMT compiler doesn't like inlining it.
foreach (String temp in text.Split(','))
{
if (StringParsers.TryParseFloat(temp, out code))
{
this.Buffs.AddCustomVar("PathingCode", code);
return;
}
}
}
/**
* Checks whether the user is needed to be accessing the block in order for processing to occur.
*/
protected void CheckRequireUserAccess()
{
this.requireUserAccess = false;
string requireUserAccess;
if (!this.PropExists(this.propRequireUserAccess, out requireUserAccess))
{
return;
}
if (!StringParsers.TryParseBool(requireUserAccess, out this.requireUserAccess))
{
throw new Exception("Could not parse value as boolean.");
}
}
public override bool ParseXmlAttribute(XmlAttribute _attribute)
{
bool based = base.ParseXmlAttribute(_attribute);
string name = _attribute.Name;
bool used = true;
if (name == "particle")
{
this.particle = _attribute.Value;
if (this.particle.StartsWith("p_"))
{
this.particle = this.particle.Substring(2);
}
}
else if (name == "offset")
{
this.offset = StringParsers.ParseVector3(_attribute.Value);
}
else if (name == "rcol")
{
this.rcol = StringParsers.ParseVector3(_attribute.Value);
}
else if (name == "rpos")
{
this.rpos = StringParsers.ParseVector3(_attribute.Value);
}
else if (name == "sound")
{
this.sound = _attribute.Value;
}
else if (name == "color")
{
this.color = ParseColor(_attribute.Value);
}
else if (name == "rep")
{
this.rep = int.Parse(_attribute.Value);
}
else if (name == "dt")
{
this.dt = int.Parse(_attribute.Value);
}
else
{
used = false;
}
return(used || based);
}
public static float GetFloatValue(int EntityID, String strProperty)
{
float result = -1;
EntityAliveSDX myEntity = GameManager.Instance.World.GetEntity(EntityID) as EntityAliveSDX;
if (myEntity)
{
EntityClass entityClass = EntityClass.list[myEntity.entityClass];
if (entityClass.Properties.Values.ContainsKey(strProperty))
{
result = StringParsers.ParseFloat(entityClass.Properties.Values[strProperty], 0, -1, NumberStyles.Any);
}
}
return(result);
}