public void RemoveStartingCondition(Condition cond)
{
StartingConditions = StartingConditions.Remove(cond);
}
public float VolitionValue(Name step, Name targ, Name mode, KB m_Kb)
{
if (m_Kb.Perspective == targ)
{
return(-1);
}
var targetSub = new Substitution(Target, new ComplexValue(targ));
var constraints = new SubstitutionSet();
constraints.AddSubstitution(targetSub);
float total = Single.NegativeInfinity;
// List<SubstitutionSet> resultingConstraints = new List<SubstitutionSet>();
if (step == this.Steps.FirstOrDefault())
{
var resultingConstraints = StartingConditions.FirstOrDefault()?.Unify(m_Kb, m_Kb.Perspective, new[] { constraints }).ToList();
if (StartingConditions.Count() > 1)
{
int counter = 0;
resultingConstraints = StartingConditions.Unify(m_Kb, m_Kb.Perspective, new[] { constraints }).ToList();
/* foreach (var c in StartingConditions) // For instance SI([x]) >= 40
* {
* counter++;
* if(counter == 1) continue;
*
* resultingConstraints = c.Unify(m_Kb, m_Kb.Perspective, resultingConstraints ).ToList(); // Whats the sub here [x]/John
* }*/
}
if (!resultingConstraints.Any())
{
return(total);
}
foreach (var res in resultingConstraints)
{
if (resultingConstraints.Any()) // Assuming all Starting COnditions match lets go into the Influence Rules
{
foreach (var constraint in resultingConstraints) // var condition = c.ToString();
{
var contraintVolitionValue = .0f;
// var certainty = res.FindMinimumCertainty(); // How do I ask SI(John) >= 40 and get its certainty
//total += certainty;
List <InfluenceRule> influenceRuleList;
if (mode.IsUniversal)
{
influenceRuleList = this.InfluenceRules;
}
else
{
influenceRuleList = this.InfluenceRules.FindAll(x => x.Mode == mode);
}
foreach (var inf in influenceRuleList)
{
var toSum = inf.EvaluateInfluenceRule(m_Kb, constraint);
contraintVolitionValue += toSum;
}
if (contraintVolitionValue > total)
{
total = contraintVolitionValue;
}
}
}
}
//What if the step is beyond the first one, we should not consider Starting Conditions, or any conditions at all, only the influence rules
}
else
{
var volVal = .0f;
List <InfluenceRule> influenceRuleList;
if (mode.IsUniversal)
{
influenceRuleList = this.InfluenceRules;
}
else
{
influenceRuleList = this.InfluenceRules.FindAll(x => x.Mode == mode);
}
foreach (var inf in influenceRuleList)
{
var toSum = inf.EvaluateInfluenceRule(m_Kb, constraints);
volVal += toSum;
}
if (volVal > total)
{
total = volVal;
}
}
return(total);
}
public void AddStartingCondition(Condition cond)
{
StartingConditions = StartingConditions.Add(cond);
}
private static ColonyCollection createColonies(Player[] players, IList <StarSystemBuilder> starSystems,
IList <int> homeSystemIndices, StartingConditions startingConditions, StaticsDB statics)
{
var colonies = new ColonyCollection();
for (int playerI = 0; playerI < players.Length; playerI++)
{
var planets = new HashSet <Planet>(starSystems[homeSystemIndices[playerI]].Planets);
var fitness = planets.
ToDictionary(x => x, x => ColonyProcessor.DesirabilityOf(x, statics));
while (planets.Count > startingConditions.Colonies)
{
planets.Remove(Methods.FindWorst(planets, x => fitness[x]));
}
foreach (var planet in planets)
{
colonies.Add(new Colony(0, planet, players[playerI]));
}
}
return(colonies);
}
private static TemporaryDB createDerivates(Player[] players, Player organellePlayer, StartingConditions startingConditions, StaticsDB statics, StatesDB states)
{
var derivates = new TemporaryDB(players, organellePlayer, statics.DevelopmentTopics);
initColonies(players, states.Colonies, startingConditions, derivates, statics);
initStellarises(derivates, states.Stellarises);
derivates.Natives.Initialize(states, statics, derivates);
return(derivates);
}
private static void initColonies(Player[] players, ColonyCollection colonies, StartingConditions startingConditions,
TemporaryDB derivates, StaticsDB statics)
{
foreach (Colony colony in colonies)
{
var colonyProc = new ColonyProcessor(colony);
colonyProc.CalculateBaseEffects(statics, derivates.Players.Of[colony.Owner]);
derivates.Colonies.Add(colonyProc);
}
foreach (Player player in players)
{
var weights = new ChoiceWeights <Colony>();
foreach (Colony colony in colonies.OwnedBy[player])
{
weights.Add(colony, derivates.Colonies.Of[colony].Desirability);
}
var maxPopulation = colonies.OwnedBy[player].Sum(x => derivates.Colonies.Of[x].MaxPopulation);
double totalPopulation = Math.Min(startingConditions.Population, maxPopulation);
double totalInfrastructure = Math.Min(startingConditions.Infrastructure, maxPopulation);
foreach (var colony in colonies.OwnedBy[player])
{
colony.Population = weights.Relative(colony) * totalPopulation;
derivates.Colonies.Of[colony].CalculateBaseEffects(statics, derivates.Players.Of[player]);
}
}
}
private static ColonyCollection createColonies(Player[] players, IList <StarSystemBuilder> starSystems,
IList <int> homeSystemIndices, StartingConditions startingConditions, StaticsDB statics)
{
var colonies = new ColonyCollection();
for (int playerI = 0; playerI < players.Length; playerI++)
{
var planets = starSystems[homeSystemIndices[playerI]].Planets;
var fitness = planets.
ToDictionary(x => x, x => ColonyProcessor.DesirabilityOf(x, statics));
for (int i = 0; i < Math.Min(startingConditions.Colonies, planets.Count); i++)
{
var planet = Methods.FindBest(planets, x => fitness[x]);
colonies.Add(new Colony(
0,
planet,
players[playerI]
));
fitness[planet] = double.NegativeInfinity;
}
}
return(colonies);
}
