public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
// Shared //
var ripIsEnabled = new BooleanCondition(Settings.RipEnabled);
var minComboPoints = new MyComboPointsCondition(5, 5);
var healthCheck = new ConditionTestSwitchCondition(
new BooleanCondition(Settings.RipEnemyHealthCheck),
new MyTargetHealthMultiplierCondition(Settings.RipEnemyHealthMultiplier)
);
var energy = new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
new MyEnergyRangeCondition(30.0 / 2.0),
new MyEnergyRangeCondition(30.0)
);
// Normal //
Conditions.Add(ripIsEnabled);
Conditions.Add(minComboPoints);
Conditions.Add(healthCheck);
Conditions.Add(energy);
Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, SpellBook.Rip));
// Pandemic //
PandemicConditions.Add(ripIsEnabled);
PandemicConditions.Add(minComboPoints);
PandemicConditions.Add(healthCheck);
PandemicConditions.Add(energy);
PandemicConditions.Add(new BooleanCondition(Settings.RipAllowClipping));
PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, SpellBook.Rip));
PandemicConditions.Add(new TargetHealthRangeCondition(TargetType.MyCurrentTarget, 25, 100));
PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, SpellBook.Rip,
TimeSpan.FromSeconds(7)));
}
static void Main(string[] args)
{
BooleanCondition greater = (a, b) => a > b;
BooleanCondition lessThan = (a, b) => a < b;
BooleanCondition equal = (a, b) => a == b;
Console.WriteLine("Greater");
Console.WriteLine(new string('-', 20)); // initialize string with 20 times '-'
Console.WriteLine($"7 > 77 => { greater(7, 77) }");
Console.WriteLine($"1 > 1 => { greater(1, 1) }");
Console.WriteLine($"100 > 49 => { greater(100, 49) }\n");
Console.WriteLine("Less Than");
Console.WriteLine(new string('-', 20)); // initialize string with 20 times '-'
Console.WriteLine($"7 < 77 => { lessThan(7, 77) }");
Console.WriteLine($"1 < 1 => { lessThan(1, 1) }");
Console.WriteLine($"100 < 49 => { lessThan(100, 49) }\n");
Console.WriteLine("Equal");
Console.WriteLine(new string('-', 20)); // initialize string with 20 times '-'
Console.WriteLine($"7 == 77 => { equal(7, 77) }");
Console.WriteLine($"1 == 1 => { equal(1, 1) }");
Console.WriteLine($"100 == 49 => { equal(100, 49) }\n");
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
var lacerateIsEnabled = new BooleanCondition(Settings.LacerateEnabled);
var inBearForm = new MeIsInBearFormCondition();
var attackableTarget = new MeHasAttackableTargetCondition();
var targetIsWithinMeleeRange = new MyTargetIsWithinMeleeRangeCondition();
var facingTarget = new MeIsFacingTargetCondition();
Conditions.Add(lacerateIsEnabled);
Conditions.Add(inBearForm);
Conditions.Add(attackableTarget);
Conditions.Add(targetIsWithinMeleeRange);
Conditions.Add(facingTarget);
Conditions.Add(new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.MyCurrentTarget, SpellBook.Lacerate),
new TargetHasAuraMaxStacksCondition(TargetType.MyCurrentTarget, Spell.Id, 3)
));
PandemicConditions.Add(lacerateIsEnabled);
PandemicConditions.Add(inBearForm);
PandemicConditions.Add(attackableTarget);
PandemicConditions.Add(targetIsWithinMeleeRange);
PandemicConditions.Add(facingTarget);
PandemicConditions.Add(new BooleanCondition(Settings.LacerateAllowClipping));
PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, Spell.Id,
TimeSpan.FromSeconds(4.5)));
}
public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
// Shared //
var rakeIsEnabled = new BooleanCondition(Settings.RakeEnabled);
var meIsNotProwling = new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.Prowl);
var energy = new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
new MyEnergyRangeCondition(35.0 / 2.0),
new MyEnergyRangeCondition(35.0)
);
// Normal //
Conditions.Add(rakeIsEnabled);
Conditions.Add(meIsNotProwling);
Conditions.Add(energy);
Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, SpellBook.RakeBleedDebuff));
Conditions.Add(new MyMaxRakedUnitsCondition(Settings.RakeMaxEnemies));
// Pandemic //
PandemicConditions.Add(rakeIsEnabled);
PandemicConditions.Add(meIsNotProwling);
PandemicConditions.Add(energy);
PandemicConditions.Add(new BooleanCondition(Settings.RakeAllowClipping));
PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, SpellBook.RakeBleedDebuff));
PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget,
SpellBook.RakeBleedDebuff, TimeSpan.FromSeconds(4.5)));
}
public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
var thrashIsEnabled = new BooleanCondition(Settings.GuardianThrashEnabled);
var inBearForm = new MeIsInBearFormCondition();
var attackableTarget = new MeHasAttackableTargetCondition();
var targetIsWithinMeleeRange = new MyTargetIsWithinMeleeRangeCondition();
var facingTarget = new MeIsFacingTargetCondition();
var minEnemies = new AttackableTargetsMinCountCondition(Settings.GuardianThrashMinEnemies);
Conditions.Add(thrashIsEnabled);
Conditions.Add(inBearForm);
Conditions.Add(attackableTarget);
Conditions.Add(targetIsWithinMeleeRange);
Conditions.Add(facingTarget);
Conditions.Add(minEnemies);
Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
PandemicConditions.Add(thrashIsEnabled);
PandemicConditions.Add(inBearForm);
PandemicConditions.Add(attackableTarget);
PandemicConditions.Add(targetIsWithinMeleeRange);
PandemicConditions.Add(facingTarget);
PandemicConditions.Add(minEnemies);
PandemicConditions.Add(new BooleanCondition(Settings.GuardianThrashAllowClipping));
PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, Spell.Id,
TimeSpan.FromSeconds(4.8)));
}
protected virtual string CompileBooleanCondition(SqlResult ctx, BooleanCondition item)
{
var column = Wrap(item.Column);
var value = item.Value ? CompileTrue() : CompileFalse();
var op = item.IsNot ? "!=" : "=";
return($"{column} {op} {value}");
}
protected virtual string CompileBooleanCondition(SqlResult context, BooleanCondition item)
{
string column = wrapper.Wrap(item.Column);
string value = item.Value ? CompileTrue() : CompileFalse();
string op = item.IsNot ? "!=" : "=";
return($"{column} {op} {value}");
}
public void Not()
{
var bc = new BooleanCondition();
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.AND | BooleanCondition.ConditionType.NOT);
var isMet = bc.IsMet(null);
Assert.IsTrue(isMet);
}
public ZippedFilesUpdateTask()
{
Attributes = new Dictionary <string, string>();
_coldUpdates = new Dictionary <string, string>();
_warmUpdates = new Dictionary <string, string>();
_directoriesToCreate = new List <string>();
UpdateConditions = new BooleanCondition();
// TODO: replace this with something from the updatemanager
_appPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
}
public void MultipleANDFail2()
{
var bc = new BooleanCondition();
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.AND);
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.AND);
var isMet = bc.IsMet(null);
Assert.IsFalse(isMet);
}
public void MultipleAND()
{
BooleanCondition bc = new BooleanCondition();
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.AND);
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.AND);
bool isMet = bc.IsMet(null);
Assert.IsTrue(isMet);
}
public void MiddleORFail()
{
BooleanCondition bc = new BooleanCondition();
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.AND);
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.OR);
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.AND);
bool isMet = bc.IsMet(null);
Assert.IsFalse(isMet);
}
public void LastORPass()
{
var bc = new BooleanCondition();
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.AND);
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.AND);
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.OR);
var isMet = bc.IsMet(null);
Assert.IsTrue(isMet);
}
public void ShortCircuitOR()
{
var bc = new BooleanCondition();
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.OR);
bc.AddCondition(new MockCondition(true), BooleanCondition.ConditionType.OR);
bc.AddCondition(new MockCondition(false), BooleanCondition.ConditionType.OR);
var isMet = bc.IsMet(null);
Assert.IsTrue(isMet, "Expected the second or to short circuit the condition list");
}
public void BooleanCondition_ReturnFalse(BooleanOperator booleanOperator, params bool[] conditionResults)
{
//Arrange
var contex = Mock.Of <IExecutionContext>();
var conditions = MockHelper.MakeMoqConditions(contex, conditionResults);
//Action
var booleanCondition = new BooleanCondition(booleanOperator, conditions);
var result = booleanCondition.Evaluate(contex);
//Assert
Assert.False(result, $"should true");
}
private IUpdateCondition ReadCondition(XmlNode cnd)
{
IUpdateCondition conditionObject = null;
if (cnd.ChildNodes.Count > 0 || "GroupCondition".Equals(cnd.Name))
{
var bc = new BooleanCondition();
foreach (XmlNode child in cnd.ChildNodes)
{
var childCondition = ReadCondition(child);
if (childCondition != null)
{
bc.AddCondition(childCondition,
BooleanCondition.ConditionTypeFromString(child.Attributes != null && child.Attributes["type"] != null
? child.Attributes["type"].Value
: null));
}
}
if (bc.ChildConditionsCount > 0)
{
conditionObject = bc.Degrade();
}
}
else if (_updateConditions.ContainsKey(cnd.Name))
{
conditionObject = (IUpdateCondition)Activator.CreateInstance(_updateConditions[cnd.Name]);
if (cnd.Attributes != null)
{
var dict = new Dictionary <string, string>();
// Store all other attributes, to be used by the condition object later
foreach (XmlAttribute att in cnd.Attributes)
{
if ("type".Equals(att.Name))
{
continue;
}
dict.Add(att.Name, att.Value);
}
if (dict.Count > 0)
{
Reflection.SetNauAttributes(conditionObject, dict);
}
}
}
return(conditionObject);
}
public void SMG_04_05_SimplyifyBool()
{
var sm = new StateMachine();
var btype = sm.GetStateType("boolean");
var v = sm.AddVariable("v", btype);
var u = sm.AddVariable("u", btype);
var w = sm.AddVariable("w", btype);
var c1 = new BooleanCondition(v);
var c2 = new BooleanCondition(u);
var c3 = new BooleanCondition(w);
IGate g;
g = Gate.ComposeAND(c1, c2);
g = Gate.ComposeOR(g, Gate.Invert(c3));
Trace("{0}", g);
Assert.AreEqual("vu + !w", g.ToString());
}
public void BooleanCondition_AddCondition_IncreasesSubConditionsCount(BooleanOperator booleanOpeartor)
{
//Arrange
var contex = Mock.Of <IExecutionContext>();
var initialContidionList = new List <ICondition>()
{
Mock.Of <ICondition>(), Mock.Of <ICondition>()
};
var conditionToAdd = Mock.Of <ICondition>();
//Action
var booleanCondition = new BooleanCondition(booleanOpeartor, initialContidionList);
int initialConditionsCount = booleanCondition.subConditions.Count;
booleanCondition.AddCondition(conditionToAdd);
//Assert
bool isIncreasedByOne = booleanCondition.subConditions.Count == initialConditionsCount + 1;
Assert.True(isIncreasedByOne, $"should true");
}
public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
// Shared //
var savageRoarIsEnabled = new BooleanCondition(Settings.SavageRoarEnabled);
var minComboPoints = new MyComboPointsCondition(Settings.SavageRoarMinComboPoints, 5);
var energy = new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
new MyEnergyRangeCondition(25.0 / 2.0),
new MyEnergyRangeCondition(25.0)
);
// Normal //
Conditions.Add(savageRoarIsEnabled);
Conditions.Add(minComboPoints);
Conditions.Add(energy);
Conditions.Add(new MySavageRoarAuraCondition(false));
// Pandemic //
PandemicConditions.Add(savageRoarIsEnabled);
PandemicConditions.Add(minComboPoints);
PandemicConditions.Add(energy);
PandemicConditions.Add(new BooleanCondition(Settings.SavageRoarAllowClipping));
PandemicConditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.Me, SpellBook.GlyphOfSavagery));
PandemicConditions.Add(new ConditionOrList(
new TargetHasAuraCondition(TargetType.Me, SpellBook.SavageRoar),
new TargetHasAuraCondition(TargetType.Me, SpellBook.GlyphOfSavageRoar)
));
PandemicConditions.Add(new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.Me, SpellBook.SavageRoar),
new TargetAuraMinTimeLeftCondition(TargetType.Me, SpellBook.SavageRoar, TimeSpan.FromSeconds(3.5))
));
PandemicConditions.Add(new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.Me, SpellBook.GlyphOfSavageRoar),
new TargetAuraMinTimeLeftCondition(TargetType.Me, SpellBook.GlyphOfSavageRoar, TimeSpan.FromSeconds(3.5))
));
}
public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
var enabled = new BooleanCondition(Settings.ThrashEnabled);
var minTargetCount = new ConditionTestSwitchCondition(
new BooleanCondition(Settings.ThrashClearcastingProcEnabled),
new TargetHasAuraCondition(TargetType.Me, SpellBook.ClearcastingProc),
new AttackableTargetsMinCountCondition(Settings.ThrashMinEnemies)
);
var distance = new MyTargetDistanceCondition(0, Settings.AoeRange);
Conditions.Add(enabled);
Conditions.Add(minTargetCount);
Conditions.Add(distance);
Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
if (Settings.SavageRoarEnabled)
{
Conditions.Add(new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.SavageRoar),
new MySavageRoarAuraCondition()
));
}
PandemicConditions.Add(enabled);
PandemicConditions.Add(minTargetCount);
PandemicConditions.Add(distance);
PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget, Spell.Id));
PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget, Spell.Id,
TimeSpan.FromSeconds(4)));
if (Settings.SavageRoarEnabled)
{
PandemicConditions.Add(new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.SavageRoar),
new MySavageRoarAuraCondition()
));
}
}
protected override void OnInitialized()
{
if (FilterTypes.Contains(Column.Type.GetNonNullableType()))
{
Column.FilterControl = this;
if (Column.Filter != null)
{
var nodeType = Column.Filter.Body.NodeType;
if (Column.Filter.Body is BinaryExpression binaryExpression &&
binaryExpression.NodeType == ExpressionType.AndAlso)
{
nodeType = binaryExpression.Right.NodeType;
}
switch (nodeType)
{
case ExpressionType.IsTrue:
Condition = BooleanCondition.True;
break;
case ExpressionType.IsFalse:
Condition = BooleanCondition.False;
break;
case ExpressionType.Equal:
Condition = BooleanCondition.IsNull;
break;
case ExpressionType.NotEqual:
Condition = BooleanCondition.IsNotNull;
break;
}
}
}
}
/// <summary>
/// Evaluates a boolean condition against a template context
/// </summary>
/// <param name="context">The template context</param>
/// <param name="condition">The condition</param>
/// <returns>The evaluation result</returns>
private bool Evaluate
(
ref TemplateContext context,
BooleanCondition condition
)
{
Validate.IsNotNull(condition);
var result = false;
if (condition.RightValue == null)
{
result = Evaluate
(
ref context,
condition.LeftValue
);
}
else
{
var leftValue = ResolveValue
(
ref context,
condition.LeftValue.Value,
condition.LeftValue.ValueType
);
var rightValue = ResolveValue
(
ref context,
condition.RightValue.Value,
condition.RightValue.ValueType
);
switch (condition.CompareOperator)
{
case BooleanConditionOperator.And:
{
var leftResult = ToBool(ref context, leftValue);
var rightResult = ToBool(ref context, rightValue);
result = (leftResult && rightResult);
break;
}
case BooleanConditionOperator.Or:
{
var leftResult = ToBool(ref context, leftValue);
var rightResult = ToBool(ref context, rightValue);
result = (leftResult || rightResult);
break;
}
case BooleanConditionOperator.Equal:
{
result = Compare(leftValue, rightValue);
break;
}
case BooleanConditionOperator.NotEqual:
{
result = (false == Compare(leftValue, rightValue));
break;
}
case BooleanConditionOperator.GreaterThan:
{
var leftNumber = ToNumber(leftValue);
var rightNumber = ToNumber(rightValue);
result = (leftNumber > rightNumber);
break;
}
case BooleanConditionOperator.GreaterThanOrEqual:
{
var leftNumber = ToNumber(leftValue);
var rightNumber = ToNumber(rightValue);
result = (leftNumber >= rightNumber);
break;
}
case BooleanConditionOperator.LessThan:
{
var leftNumber = ToNumber(leftValue);
var rightNumber = ToNumber(rightValue);
result = (leftNumber < rightNumber);
break;
}
case BooleanConditionOperator.LessThanOrEqual:
{
var leftNumber = ToNumber(leftValue);
var rightNumber = ToNumber(rightValue);
result = (leftNumber <= rightNumber);
break;
}
}
}
return(result);
}
public WeatherWallpaper(string name, BooleanCondition cond)
{
WallpaperFilename = name;
Condition = cond;
}
public override void ApplyDefaultSettings()
{
base.ApplyDefaultSettings();
// Shared //
var isEnabled = new BooleanCondition(Settings.MoonfireEnabled);
var isLowLevelCheck = new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.CatForm),
new ConditionDependencyList(
new BooleanCondition(Settings.MoonfireEnabled),
new MeIsInCatFormCondition()
)
);
var energy = new ConditionTestSwitchCondition(
new TargetHasAuraCondition(TargetType.Me, SpellBook.BerserkDruid),
new MyEnergyRangeCondition(35.0 / 2.0),
new MyEnergyRangeCondition(35.0)
);
// Normal //
Conditions.Add(isEnabled);
Conditions.Add(isLowLevelCheck);
Conditions.Add(energy);
Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget,
SpellBook.MoonfireDotDebuffLowLevel));
Conditions.Add(new TargetDoesNotHaveAuraCondition(TargetType.MyCurrentTarget,
SpellBook.MoonfireDotDebuffHighLevel));
if (Settings.MoonfireOnlyWithLunarInspiration)
{
Conditions.Add(new MeKnowsSpellCondition(SpellBook.LunarInspiration));
}
if (Settings.FerociousBiteEnabled)
{
Conditions.Add(new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.FerociousBite),
new MyComboPointsCondition(0, 4)
));
}
if (Settings.RipEnabled)
{
Conditions.Add(new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.Rip),
new MyComboPointsCondition(0, 4)
));
}
// Pandemic //
PandemicConditions.Add(isEnabled);
PandemicConditions.Add(isLowLevelCheck);
PandemicConditions.Add(energy);
PandemicConditions.Add(new BooleanCondition(Settings.MoonfireAllowClipping));
PandemicConditions.Add(new TargetHasAuraCondition(TargetType.MyCurrentTarget,
SpellBook.MoonfireDotDebuffHighLevel));
PandemicConditions.Add(new TargetAuraMinTimeLeftCondition(TargetType.MyCurrentTarget,
SpellBook.MoonfireDotDebuffHighLevel, TimeSpan.FromSeconds(4)));
if (Settings.FerociousBiteEnabled)
{
PandemicConditions.Add(new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.FerociousBite),
new MyComboPointsCondition(0, 4)
));
}
if (Settings.RipEnabled)
{
PandemicConditions.Add(new ConditionTestSwitchCondition(
new MeKnowsSpellCondition(SpellBook.Rip),
new MyComboPointsCondition(0, 4)
));
}
}
public void Json_From()
{
Signer signer = new()
{
Account = UInt160.Zero,
Scopes = WitnessScope.CustomContracts | WitnessScope.CustomGroups | WitnessScope.WitnessRules,
AllowedContracts = new[] { UInt160.Zero },
AllowedGroups = new[] { ECPoint.Parse("03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c", ECCurve.Secp256r1) },
Rules = new WitnessRule[] { new() { Action = WitnessRuleAction.Allow, Condition = new BooleanCondition {
Expression = true
} } }
};
var json = signer.ToJson();
var new_signer = Signer.FromJson(json);
Assert.IsTrue(new_signer.Account.Equals(signer.Account));
Assert.IsTrue(new_signer.Scopes == signer.Scopes);
Assert.AreEqual(1, new_signer.AllowedContracts.Length);
Assert.IsTrue(new_signer.AllowedContracts[0].Equals(signer.AllowedContracts[0]));
Assert.AreEqual(1, new_signer.AllowedGroups.Length);
Assert.IsTrue(new_signer.AllowedGroups[0].Equals(signer.AllowedGroups[0]));
}
public static ICollection <JavaScriptBlock> GetAll(kCura.Relativity.Client.IRSAPIClient client)
{
var javaScriptBlocks = new List <JavaScriptBlock>();
var qry = new kCura.Relativity.Client.DTOs.Query <kCura.Relativity.Client.DTOs.RDO>();
qry.ArtifactTypeGuid = Helper.Constants.Javascripts.ObjectTypeGuid;
//qry.Fields = kCura.Relativity.Client.DTOs.FieldValue.AllFields;
qry.Fields = new List <kCura.Relativity.Client.DTOs.FieldValue> {
new kCura.Relativity.Client.DTOs.FieldValue(Helper.Constants.Javascripts.Fields.Text)
, new kCura.Relativity.Client.DTOs.FieldValue(Helper.Constants.Javascripts.Fields.ViewMode)
};
BooleanCondition onlyActiveJavaScript = new BooleanCondition(Helper.Constants.Javascripts.Fields.Disabled, BooleanConditionEnum.EqualTo, false);
qry.Condition = onlyActiveJavaScript;
try
{
var ActiveJavaScriptsResults = client.Repositories.RDO.Query(qry);
if (ActiveJavaScriptsResults.Success)
{
foreach (var result in ActiveJavaScriptsResults.Results)
{
var javaScript = new JavaScriptBlock();
var resultArtifact = result.Artifact;
javaScript.Text = resultArtifact.Fields.First(x => x.Guids.Contains(Helper.Constants.Javascripts.Fields.Text)).ValueAsLongText;
javaScript.ArtifactID = resultArtifact.ArtifactID;
var viewModeChoiceField = resultArtifact.Fields.First(x => x.Guids.Contains(Helper.Constants.Javascripts.Fields.ViewMode)).ValueAsSingleChoice;
javaScript.ViewMode = JavaScriptBlock.ViewModeValue.All;
if (viewModeChoiceField != null)
{
var viewModeChoice = client.Repositories.Choice.ReadSingle(viewModeChoiceField.ArtifactID);
if (viewModeChoice.Guids.Contains(Helper.Constants.Javascripts.Choices.ViewMode.ViewOnly))
{
javaScript.ViewMode = JavaScriptBlock.ViewModeValue.ViewOnly;
}
else if (viewModeChoice.Guids.Contains(Helper.Constants.Javascripts.Choices.ViewMode.EditOnly))
{
javaScript.ViewMode = JavaScriptBlock.ViewModeValue.EditOnly;
}
}
javaScriptBlocks.Add(javaScript);
//var jS = new JavaScripts();
//jS.text = text;
}
}
else
{
Console.WriteLine(string.Format("An error occurred reading results: {0}", ActiveJavaScriptsResults.Message));
}
}
catch (Exception ex)
{
Console.WriteLine(string.Format("An error occurred: {0}", ex.Message));
}
return(javaScriptBlocks);
}
private bool SatisfiesStat(Action action, Precondition goalCondition, GameObject targetCharacter)
{
if (goalCondition.Stat == StatName.None)
{
return(true);
}
if (action.TargetObject == targetCharacter)
{
StatName stat = goalCondition.Stat;
StatName actionStat = action.TargetEffect.Stat;
BooleanCondition condition = goalCondition.BoolCondition;
float change = action.TargetEffect.Change;
if (goalCondition.Stat != StatName.None && stat == actionStat)
{
EmotionalPersonalityModel epm = action.TargetObject.GetComponent <EmotionalPersonalityModel>();
PhysicalResourceModel prm = action.TargetObject.GetComponent <PhysicalResourceModel>();
if (condition == BooleanCondition.LessThan)
{
if (change < 0.0f)
{
return(true);
}
}
else if (condition == BooleanCondition.GreaterThan)
{
if (change > 0.0f)
{
return(true);
}
}
else if (condition == BooleanCondition.GreaterThanOrEqualTo)
{
if ((int)stat > 0 && (int)stat < Precondition.physicalIndex)
{
if (change > 0.0f || ((float)epm.GetEmotionValue(stat.ToString()) + change == goalCondition.Value))
{
return(true);
}
}
else if ((int)stat >= Precondition.physicalIndex && (int)stat < Precondition.limitIndex)
{
if (change > 0.0f || ((float)prm.GetPhysicalValue(stat.ToString()) + change == goalCondition.Value))
{
return(true);
}
}
}
else if (condition == BooleanCondition.LessThanOrEqualTo)
{
if ((int)stat > 0 && (int)stat < Precondition.physicalIndex)
{
if (change < 0.0f || ((float)epm.GetEmotionValue(stat.ToString()) + change == goalCondition.Value))
{
return(true);
}
}
else if ((int)stat >= Precondition.physicalIndex && (int)stat < Precondition.limitIndex)
{
if (change < 0.0f || ((float)prm.GetPhysicalValue(stat.ToString()) + change == goalCondition.Value))
{
return(true);
}
}
}
else if (condition == BooleanCondition.EqualTo)
{
if ((int)stat > 0 && (int)stat < Precondition.physicalIndex)
{
if ((float)epm.GetEmotionValue(stat.ToString()) + change == goalCondition.Value)
{
return(true);
}
}
else if ((int)stat >= Precondition.physicalIndex && (int)stat < Precondition.limitIndex)
{
if ((float)prm.GetPhysicalValue(stat.ToString()) + change == goalCondition.Value)
{
return(true);
}
}
}
}
}
return(false);
}
