/// <summary>
/// Remove a decision from the list of decisions that the human needs to make. It can always be added later
/// </summary>
public void RemoveDecision(Decision decision)
{
if (Decisions.RemoveAll(match => match == decision) > 0) // I have to use a predicate because I overrode `Decision.Equals` //TODO: wtf is this kid on about
{
RefreshBannedSubjectsList();
}
}
protected bool isNotSplitted = true; // Is player hand not splited. We can split the hand only one time.
public Player(byte dealersFirst, uint money, Decks playingDecks, uint wager = 0)
{
Money = money;
FirstWager = wager;
Money -= FirstWager;
PlayersDecisions = new Decisions[21];
PlayingDecks = new Decks();
PlayingDecks = playingDecks;
for (int i = 0; i < 21; i++)
{
PlayersDecisions[i] = 0;
}
dealerCard = dealersFirst;
FirstHand = new byte[21];
for (int i = 2; i < 21; i++)
{
FirstHand[i] = 0;
}
SecondHand = new byte[21];
for (int i = 0; i < 21; i++)
{
SecondHand[i] = 0;
}
FirstHand[0] = PlayingDecks.GetCard();
FirstHand[1] = PlayingDecks.GetCard();
FirstSum = 0;
SecondSum = 0;
}
internal void Add(Decision decision)
{
if (decision != null)
{
Decisions.Add(decision);
}
}
private static ScaleSetVirtualMachineStripped[] GetInstanceIds(IEnumerable <ScaleSetVirtualMachineStripped> vmScaleSetData, int poolId = TestsConstants.TestPoolId, string jsonData = TestsConstants.Json1JobIsRunning)
{
var dataRetriever = RetrieveTests.CreateRetriever(jsonData);
return(Decisions.CollectInstanceIdsToDeallocate(vmScaleSetData.Where(vm => vm.VmInstanceState.Equals(PowerState.Running)),
dataRetriever.GetRuningJobs(poolId)));
}
private void SaveDecisions()
{
foreach (var decision in Decisions.Where(decision => decision.Changed))
{
decision.SaveChanges();
}
}
public void WhenCodeIsDifferent_SeedDifferent_DecisionsDontMatch()
{
Random seedGenerator = new Random();
Random random1;
Random random2;
Decisions decisions1 = CreateDecision(seedGenerator.Next(), out random1);
Decisions decisions2 = CreateDecision(seedGenerator.Next(), out random2);
bool match = true;
for (int j = 0; j < 10000; j++)
{
int rnd1 = random1.Next();
int rnd2 = random2.Next();
Decisions.Outcome outcome1 = decisions1.GetDecision(rnd1);
Decisions.Outcome outcome2 = decisions2.GetDecision(rnd2);
match = match & outcome1 == outcome2;
}
Assert.IsFalse(match);
}
void ShowHideTasks(bool showAddDetergent, bool showHotColdWash, bool showWashLength, bool showWetClothes, bool showFeedback)
{
// Canvas elements don't have a SetActive method, but they have an 'enabled' property
if (showAddDetergent)
{
firstDetergent.GetComponent <MeshRenderer>().material = badDetergent;
secondDetergent.GetComponent <MeshRenderer>().material = avgDetergent;
thirdDetergent.GetComponent <MeshRenderer>().material = goodDetergent;
}
else
{
firstDetergent.GetComponent <MeshRenderer>().material = defaultDetergent;
secondDetergent.GetComponent <MeshRenderer>().material = defaultDetergent;
thirdDetergent.GetComponent <MeshRenderer>().material = defaultDetergent;
}
wetClothes.SetActive(showWetClothes);
hotColdWash.enabled = showHotColdWash;
longShortWash.enabled = showWashLength;
if (showFeedback)
{
feedbackText.text = Decisions.GetFeedback();
}
feedback.enabled = showFeedback;
}
public void WhenCodeIsSame_SeedSame_DecisionsMatch()
{
Random seedGenerator = new Random();
int seed = seedGenerator.Next();
Random random1;
Random random2;
Decisions decisions1 = CreateDecision(seed, out random1);
Decisions decisions2 = CreateDecision(seed, out random2);
Dictionary <Decisions.Outcome, int> outcomeCount = new Dictionary <Decisions.Outcome, int> {
{ Decisions.Outcome.True, 0 },
{ Decisions.Outcome.False, 0 },
{ Decisions.Outcome.Die, 0 }
};
for (int j = 0; j < 10000; j++)
{
int rnd1 = random1.Next();
int rnd2 = random2.Next();
Assert.AreEqual(rnd1, rnd2);
Decisions.Outcome outcome1 = decisions1.GetDecision(rnd1);
Decisions.Outcome outcome2 = decisions2.GetDecision(rnd2);
outcomeCount [outcome1]++;
Assert.AreEqual(outcome1, outcome2);
}
}
private static void DeallocateVms(IEnumerable <ScaleSetVirtualMachineStripped> vmInstances, IVirtualMachineScaleSet scaleSet, int agentsCountToDeallocate)
{
var virtualMachinesCounter = 0;
foreach (var vmInstance in vmInstances)
{
if (virtualMachinesCounter >= agentsCountToDeallocate)
{
break;
}
Console.WriteLine($"Deallocating VM with instance ID {vmInstance}");
virtualMachinesCounter++;
if (Properties.IsDryRun)
{
continue;
}
if (Decisions.IsVmExecutingJob(vmInstance.VmName))
{
//this VM just got job assigned, so we should not deallocate it
continue;
}
scaleSet.VirtualMachines.Inner.BeginDeallocateWithHttpMessagesAsync(Properties.VmScaleSetResourceGroupName, Properties.VmScaleSetName,
vmInstance.VmInstanceId);
}
}
// The relationship between literal and installed map:
//
// |----------------------------------------------|
// | | installed | un-installed |
// |==============================================|
// | + | keep | install |
// |----------------------------------------------|
// | - | uninstall | don't install |
// |----------------------------------------------|
/// <summary>
/// Initializes a new instance of the <see cref="Transaction"/> class.
/// </summary>
public Transaction(IPolicy policy, Pool pool, IDictionary <int, IPackage> installedMap, Decisions decisions)
{
this.policy = policy;
this.pool = pool;
this.installedMap = installedMap;
this.decisions = decisions;
transaction = new LinkedList <IOperation>();
}
private void LoadStakeholders()
{
Stakeholders.Clear();
foreach (var stakeholder in Decisions.SelectMany(decision => decision.Stakeholders).Distinct())
{
Stakeholders.Add(stakeholder.Stakeholder);
}
}
void LoadEatDecision(Creature creature)
{
Decisions decisions = creature.DecisionsLookup [Creature.DecisionTypes.Eat];
decisions.ClearTransientValues();
decisions.LoadTransientValue(new Value(creature.Energy, "Current Energy"));
_eatDecisionText.Buffer.Text = decisions.GetDecisionProvider(creature.DecisionPredicateIndex_Eat).Describe();
}
public override void Resolve()
{
Target.Card().ReturnToHand();
if (Discard > 0)
{
Decisions.EnqueueDiscardCards(Target.Card().Controller, Discard);
}
}
public static void AmountOfAgentsWithBusinessTimesSet(int jobsCount, int agentsCount, int maxAgentsCount, string testDateTime, int expectedAmount)
{
TestInitilizers.InitAppSettingsForBusinessTimesTests();
Clock.TestApi.Now = () => TestInitilizers.ParseDateTimeForTest(testDateTime);
var amount = Decisions.HowMuchAgents(jobsCount, agentsCount, maxAgentsCount);
Assert.AreEqual(expectedAmount, amount);
Clock.TestApi.Reset();
}
public StepDecision(Decision decision, WorkflowState wfState = null)
: this()
{
if (decision != null)
{
Decisions.Add(decision);
}
WfState = wfState;
}
/// <summary>
/// Propagates a decision on a literal to all rules watching the literal.
/// </summary>
/// <remarks>
/// If a decision, e.g. +A has been made, then all rules containing -A, e.g.
/// (-A|+B|+C) now need to satisfy at least one of the other literals, so
/// that the rule as a whole becomes true, since with +A applied the rule
/// is now (false|+B|+C) so essentially (+B|+C).
/// This means that all rules watching the literal -A need to be updated to
/// watch 2 other literals which can still be satisfied instead. So literals
/// that conflict with previously made decisions are not an option.
/// Alternatively it can occur that a unit clause results: e.g. if in the
/// above example the rule was (-A|+B), then A turning true means that
/// B must now be decided true as well.
/// </remarks>
/// <param name="decidedLiteral">The literal which was decided.</param>
/// <param name="level">The level at which the decision took place and at which all resulting decisions should be made.</param>
/// <param name="decisions">Used to check previous decisions and to register decisions resulting from propagation.</param>
/// <returns>If a conflict is found the conflicting rule is returned.</returns>
public Rule PropagateLiteral(int decidedLiteral, int level, Decisions decisions)
{
// we invert the decided literal here, example:
// A was decided => (-A|B) now requires B to be true, so we look for
// rules which are fulfilled by -A, rather than A.
// This means finding out the conflicts or requires.
var literal = -decidedLiteral;
if (!watchChains.TryGetValue(literal, out LinkedList <RuleWatchNode> chain))
{
return(null);
}
foreach (var node in chain.ToArray())
{
var otherWatch = node.GetOtherWatch(literal);
if (!node.GetRule().Enable || decisions.IsSatisfy(otherWatch))
{
continue;
}
var ruleLiterals = node.GetRule().GetLiterals();
var alternativeLiterals = Arr.Filter(ruleLiterals, (ruleLiteral) =>
{
// Guaranteed selection decision is not at the same time
// as Watch1 and Watch2, guaranteeing no conflict.
return(literal != ruleLiteral && otherWatch != ruleLiteral && !decisions.IsConflict(ruleLiteral));
});
if (alternativeLiterals.Length > 0)
{
var toLiteral = alternativeLiterals[0];
if (!watchChains.TryGetValue(toLiteral, out LinkedList <RuleWatchNode> toChain))
{
watchChains[toLiteral] = toChain = new LinkedList <RuleWatchNode>();
}
node.MoveWatch(literal, toLiteral);
chain.Remove(node);
toChain.AddFirst(node);
continue;
}
if (decisions.IsConflict(otherWatch))
{
return(node.GetRule());
}
decisions.Decide(otherWatch, level, node.GetRule());
}
return(null);
}
// Use this for initialization
void Start()
{
InMove = false;
InPause = false;
decisions = transform.GetComponent <Decisions>();
CurrentSel = Camera.main.GetComponent <selection>();
CurrentRC = Camera.main.GetComponent <RoundCounter>();
playerBList = new List <Transform>();
firstPhaseList = new List <Transform>();
secondPhaseList = new List <Transform>();
thirdPhaseList = new List <Transform>();
}
public void DecisionsRunWithoutException()
{
Random seedGenerator = new Random();
Random random;
Decisions decisions = CreateDecision(seedGenerator.Next(), out random);
for (int i = 0; i < 1000; i++)
{
decisions.GetDecision(random.Next());
}
}
public DmnDefinitionBuilderEx WithLogicalAndDecision(
string name,
Action <LogicalAndDecision> builder,
out Decision.Ref decisionRef)
{
var decision = new LogicalAndDecision(Variables, Decisions, name);
decisionRef = decision.Reference;
Decisions.AddDecision(decision);
builder?.Invoke(decision);
return(this);
}
public Game()
{
AddParameter(new Parameter(ParameterIds.HappinessSensitivity, "Happiness Sensitivity", 0.25, 0, 1)); // How quickly happiness follows Satisfaction, 0: never, 1: immediately
Date = new Date(2013, 1, 1);
ProductTypes.Add(new ProductType("Food", 0.5, 1));
ProductTypes.Add(new ProductType("Clothes", 1, 1));
Country = new Polity.Country(StartPopulation);
Event e = new Event("Discovery");
e.Condition = new ChanceCondition(0.01);
e.Effect = new MultipleEffects();
e.AddEffect(new MessageEffect("New technologies increase productivity!"));
e.AddEffect(new ChangeParameterEffect(Country, ParameterIds.Productivity, 1, 0.05));
e = new Event("MPs Propose to Lower Taxes");
e.Condition = new ChanceCondition(0.3);
e.HappensOnce = true;
Issues iss = new Issues();
iss.AddIssue(IssueIds.Populism, 1);
iss.AddIssue(IssueIds.BigGovernment, -1);
e.Effect = new SubmitBillEffect(new Bill(iss, new ChangeParameterEffect(Country, ParameterIds.IncomeTaxRate, 1, -0.05)), Country.Parliament);
Events.Add(e);
Decision d = new Decision("Celebrate");
d.DisplayCondition = new HasMoneyCondition(Country.Budget, 5);
d.Effect = new MessageEffect("We have lots of money! Hurray!");
Decisions.Add(d);
d = new Decision("Decrease Income Tax");
iss = new Issues();
iss.AddIssue(IssueIds.Populism, 0.5);
iss.AddIssue(IssueIds.BigGovernment, -0.5);
d.Effect = new SubmitBillEffect(new Bill(iss, new ChangeParameterEffect(Country, ParameterIds.IncomeTaxRate, 1, -0.02)), Country.Parliament);
Decisions.Add(d);
d = new Decision("Increase Income Tax");
iss = new Issues();
iss.AddIssue(IssueIds.Populism, -0.5);
iss.AddIssue(IssueIds.BigGovernment, 0.5);
d.Effect = new SubmitBillEffect(new Bill(iss, new ChangeParameterEffect(Country, ParameterIds.IncomeTaxRate, 1, 0.02)), Country.Parliament);
Decisions.Add(d);
d = new Decision("See Invisible Pink Unicorn");
d.DisplayCondition = new ConstCondition(false);
d.Effect = new MessageEffect("Wow! Here it is: the invisible pink unicorn");
Decisions.Add(d);
}
void HandleWetClothes()
{
string destination = DestinationObject.GetWetClothesDestination();
if (destination == "Dryer")
{
Decisions.AddChoice("Dryer");
}
else if (destination == "Clothesline")
{
Decisions.AddChoice("Clothesline");
}
}
private void LoadDecisions()
{
Decisions.Clear();
foreach (var decision in GetDecisionsForTopic())
{
Decisions.Add(Decision.Load(decision, false));
}
var temp = Utils.SortDecisionsByState(Decisions.ToList());
Decisions = new BindingList <IDecision>(temp);
Decisions.RaiseListChangedEvents = true;
Decisions.ListChanged += ListMemberChanged;
}
public static Decisions AfficheErreurs(CPileErreur pile)
{
CFormErreurValidation form = new CFormErreurValidation();
form.m_erreurs = pile;
Decisions decision = Decisions.Corriger;
if (form.ShowDialog() == DialogResult.OK)
{
decision = form.m_decision;
}
form.Dispose();
return(decision);
}
/// <summary>
/// Resolve the requires of the requested.
/// </summary>
/// <param name="request">The request instance.</param>
/// <param name="ignorePlantform">Whether is ignore plantform check.</param>
/// <returns>An array of operation.</returns>
public IOperation[] Solve(Request request, bool ignorePlantform = false)
{
jobs = request.GetJobs();
SetupInstalledMap();
rules = ruleSetGenerator.GetRulesFor(jobs, installedMap, ignorePlantform);
CheckForRootRequiresProblems(ignorePlantform);
decisions = new Decisions(pool);
watchGraph = new RuleWatchGraph();
learnedWhy.Clear();
learnedPool.Clear();
branches.Clear();
foreach (var rule in rules)
{
watchGraph.Add(rule);
}
SetupAssertionRuleDecisions();
io.WriteError("Resolving requires through SAT", true, Verbosities.Debug);
stopwatch.Restart();
stopwatch.Start();
RunSAT();
io.WriteError(string.Empty, true, Verbosities.Debug);
io.WriteError($"Dependency resolution completed in {stopwatch.Elapsed.TotalSeconds.ToString("0.00")} seconds", true, Verbosities.Debug);
// If we don't make a decision about the packages we have
// installed, then we think these packages will be uninstall.
foreach (var item in installedMap)
{
var packageId = item.Key;
if (decisions.IsUndecided(packageId))
{
decisions.Decide(-packageId, 1, null);
}
}
if (problems.Count > 0)
{
throw new SolverProblemsException(problems, installedMap);
}
var transaction = new Transaction(policy, pool, installedMap, decisions);
return(transaction.GetOperations());
}
/// <summary>
/// Here we will proceed working with VMSS ((de)provision additional agents, keep current agents count)
/// </summary>
/// <param name="onlineAgents"></param>
/// <param name="maxAgentsInPool"></param>
/// <param name="areWeCheckingToStartVmInVmss">Describes, which functions calls out - provisioning or deprovisioning</param>
public static void WorkWithVmss(int onlineAgents, int maxAgentsInPool, bool areWeCheckingToStartVmInVmss)
{
//working with VMSS
var vmss = GetVirtualMachinesScaleSet(Properties.VmScaleSetResourceGroupName, Properties.VmScaleSetName);
var virtualMachines = vmss.VirtualMachines.List()
//there could be failed VMs during provisioning
.Where(vm => !vm.Inner.ProvisioningState.Equals("Failed", StringComparison.OrdinalIgnoreCase))
.Select(vmssVm => new ScaleSetVirtualMachineStripped
{
VmInstanceId = vmssVm.InstanceId,
VmName = vmssVm.ComputerName,
VmInstanceState = vmssVm.PowerState
}).ToArray();
//get jobs again to check, if we could deallocate a VM in VMSS
//(if it is running a job - it is not wise to deallocate it)
//since getting VMMS is potentially lengthy operation - we could need this)
var currentJobs = Checker.DataRetriever.GetRuningJobs(Properties.AgentsPoolId);
var amountOfAgents = Decisions.HowMuchAgents(currentJobs.Length, onlineAgents, maxAgentsInPool);
var addMoreAgents = amountOfAgents > 0;
if (amountOfAgents == 0)
{
//nevertheless - should we (de)provision agents: we are at boundaries
Console.WriteLine("Should not add/remove more agents...");
return;
}
//further I need to work with positive numbers only
amountOfAgents = Math.Abs(amountOfAgents);
if (addMoreAgents != areWeCheckingToStartVmInVmss)
{
//target event is not the same as source one
return;
}
//I wish this record to be processed on it's own; it is just tracking
RecordDataInTable(addMoreAgents, amountOfAgents);
if (addMoreAgents)
{
AllocateVms(virtualMachines, amountOfAgents, vmss);
}
else
{
DeallocationWorkWithScaleSet(virtualMachines, currentJobs, vmss, amountOfAgents);
}
}
public Decision AddDecision(SoftwareSystem softwareSystem, string id, DateTime date, string title, DecisionStatus status, Format format, string content)
{
CheckIdIsSpecified(id);
CheckTitleIsSpecified(title);
CheckContentIsSpecified(content);
CheckDecisionStatusIsSpecified(status);
CheckFormatIsSpecified(format);
CheckDecisionIsUnique(softwareSystem, id);
Decision decision = new Decision(softwareSystem, id, date, title, status, format, content);
Decisions.Add(decision);
return(decision);
}
/// <summary>
/// Executes (evaluates) decision with given <paramref name="decisionName"/>
/// </summary>
/// <param name="decisionName">Name of the decision to execute</param>
/// <returns>Decision result</returns>
/// <exception cref="ArgumentException"><paramref name="decisionName"/> is null or empty</exception>
/// <exception cref="DmnExecutorException">Decision with <paramref name="decisionName"/> not found</exception>
public DmnDecisionResult ExecuteDecision(string decisionName)
{
if (string.IsNullOrWhiteSpace(decisionName))
{
throw Logger.Fatal <ArgumentException>($"{nameof(decisionName)} is null or empty");
}
if (!Decisions.ContainsKey(decisionName))
{
throw Logger.Fatal <DmnExecutorException>($"ExecuteDecision: - decision {decisionName} not found");
}
var decision = Decisions[decisionName];
return(ExecuteDecision(decision));
}
public Plan(Plan other)
{
AssignedTimes = new Dictionary <Subject, Time>(other.AssignedTimes);
Decisions.AddRange(other.Decisions);
SelectedSubjects = new List <Subject>(other.SelectedSubjects);
SelectedCourses = new List <Course>(other.SelectedCourses);
foreach (var BannedContent in other.BannedContents)
{
BannedContents.Add(BannedContent.Key, new List <Content>(BannedContent.Value));
}
EarliestCompletionTimes = new Dictionary <Subject, Time>(other.EarliestCompletionTimes);
SubjectsWithForcedTimes = new HashSet <Subject>(other.SubjectsWithForcedTimes);
MaxCreditPoints = new Dictionary <Time, int>(other.MaxCreditPoints);
ContentRelations = new HashSet <Edge>(other.ContentRelations);
}
public IDecision MakeDecision()
{
IDecision decision = new NoDecision();
if (LowHealth < Health && HighHealth > Health)
{
if (!StatusEffect.Contains(Code.StatusEffect.Dia))
{
if (Decisions.Contains(typeof(RestDecision)))
{
decision = new RestDecision();
}
}
}
return(decision);
}
private void MergeDecisions()
{
var allData = new List <Decisions>();
var dataInProper = new List <Decisions>();
for (int i = 0; i < databases.Length; i++)
{
var l = Decisions.Read(this.databases[i]);
if (i == 0)
{
dataInProper = l;
}
allData.AddRange(l);
}
var toWrite = this.SubtractHashSet(new HashSet <Decisions>(allData), new HashSet <Decisions>(dataInProper));
Decisions.Insert(this.proper, toWrite);
}
// Use this for initialization
void Start()
{
InMove = false;
InPause = false;
decisions = transform.GetComponent<Decisions>();
CurrentSel = Camera.main.GetComponent<selection>();
CurrentRC = Camera.main.GetComponent<RoundCounter>();
playerBList = new List<Transform>();
firstPhaseList = new List<Transform>();
secondPhaseList = new List<Transform>();
thirdPhaseList = new List<Transform>();
}
