Saklad5
/
Bone-Market-Solver
2
0
Fork 0
Code Issues Pull Requests Activity
Bone-Market-Solver/bonemarketsolver/solve.py

1354 lines
79 KiB
Python
Raw Normal View History

Add module-level information A docstring has been added describing the module's purpose. __all__ has been added. It is limited to the declarations needed to use Solve(). The author's name has been added.
2021-06-18 20:28:56 +00:00
"""Use constraint programming to devise the optimal skeleton at the Bone Market in Fallen London."""
Add blacklist parameter to solver Enum members in this dictionary are disallowed by the solver. The types that can be blacklisted have been added to __all__ in solve.py.
2021-08-13 13:39:04 +00:00
__all__ = ['Adjustment', 'Appendage', 'Buyer', 'Declaration', 'DiplomatFascination', 'Embellishment', 'Fluctuation', 'OccasionalBuyer', 'Skull', 'Solve', 'Torso']
Add module-level information A docstring has been added describing the module's purpose. __all__ has been added. It is limited to the declarations needed to use Solve(). The author's name has been added.
2021-06-18 20:28:56 +00:00
__author__ = "Jeremy Saklad"
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
from functools import reduce
from os import cpu_count
Initial commit
2021-06-08 22:28:15 +00:00
from ortools.sat.python import cp_model
Convert project to package All scripts are now contained in a package named "bonemarketsolver". The command-line interface has been moved to __main__.py. The solver script has been moved to solve.py. Relative module imports are now used where appropriate. The invocation method of the CLI has changed: instead of running Python itself, you can now use "pipenv run bone_market_solver". The README has been updated to reflect the new usage method.
2021-08-03 19:48:42 +00:00
from .data.adjustments import Adjustment
from .data.appendages import Appendage
from .data.buyers import Buyer
from .data.costs import Cost
from .data.declarations import Declaration
from .data.diplomat_fascinations import DiplomatFascination
from .data.embellishments import Embellishment
from .data.fluctuations import Fluctuation
from .data.occasional_buyers import OccasionalBuyer
from .data.skulls import Skull
from .data.torsos import Torso
Move Cost enumeration to different file Having a single extremely large file harms readability. To solve this problem, the Cost enumeration is now in a distinct file.
2021-08-03 17:02:06 +00:00
Initial commit
2021-06-08 22:28:15 +00:00
# This multiplier is applied to the profit margin to avoid losing precision due to rounding.
PROFIT_MARGIN_MULTIPLIER = 10000000
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
ATTRIBUTE_MULTIPLIER = 10000000
Initial commit
2021-06-08 22:28:15 +00:00
# This is the highest number of attribute to calculate fractional exponents for.
MAXIMUM_ATTRIBUTE = 100
Move DIFFICULTY_SCALER to challenge_functions.py, specify char import in read_char.py
2021-08-24 12:29:48 +00:00
from .challenge_functions import DIFFICULTY_SCALER
Initial commit
2021-06-08 22:28:15 +00:00
def NewIntermediateBoolVar(self, name, expression, domain):
Use docstrings instead of comments if appropriate Unlike comments, docstrings support runtime introspection and other features. The docstrings are arguably a bit sparse, but this is sufficient for the time being.
2021-06-18 19:44:30 +00:00
"""Add a fully-reified implication using an intermediate Boolean variable."""
Initial commit
2021-06-08 22:28:15 +00:00
intermediate = self.NewBoolVar(name)
self.AddLinearExpressionInDomain(expression, domain).OnlyEnforceIf(intermediate)
self.AddLinearExpressionInDomain(expression, domain.Complement()).OnlyEnforceIf(intermediate.Not())
return intermediate
Remove unnecessary use of setattr() If an attribute is referenced using a string literal, there is no reason to use setattr().
2021-07-06 16:27:13 +00:00
cp_model.CpModel.NewIntermediateBoolVar = NewIntermediateBoolVar
Initial commit
2021-06-08 22:28:15 +00:00
del NewIntermediateBoolVar
def AddApproximateExponentiationEquality(self, target, var, exp, upto):
Use docstrings instead of comments if appropriate Unlike comments, docstrings support runtime introspection and other features. The docstrings are arguably a bit sparse, but this is sufficient for the time being.
2021-06-18 19:44:30 +00:00
"""Add an approximate exponentiation equality using a lookup table.
Set `upto` to a value that is unlikely to come into play.
"""
Initial commit
2021-06-08 22:28:15 +00:00
return self.AddAllowedAssignments([target, var], [(int(base**exp), base) for base in range(upto + 1)])
Remove unnecessary use of setattr() If an attribute is referenced using a string literal, there is no reason to use setattr().
2021-07-06 16:27:13 +00:00
cp_model.CpModel.AddApproximateExponentiationEquality = AddApproximateExponentiationEquality
Initial commit
2021-06-08 22:28:15 +00:00
del AddApproximateExponentiationEquality
def AddGeneralMultiplicationEquality(self, target, *variables):
Use docstrings instead of comments if appropriate Unlike comments, docstrings support runtime introspection and other features. The docstrings are arguably a bit sparse, but this is sufficient for the time being.
2021-06-18 19:44:30 +00:00
"""Add a multiplication equality for any number of terms using intermediate variables."""
Initial commit
2021-06-08 22:28:15 +00:00
# This is used for producing unique names for intermediate variables.
term_index = 1
def function(a, b):
nonlocal term_index
intermediate = self.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{} term {}'.format(target.Name(), term_index))
term_index += 1
self.AddMultiplicationEquality(intermediate, [a, b])
return intermediate
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
product = reduce(function, variables)
Initial commit
2021-06-08 22:28:15 +00:00
return self.Add(target == product)
Remove unnecessary use of setattr() If an attribute is referenced using a string literal, there is no reason to use setattr().
2021-07-06 16:27:13 +00:00
cp_model.CpModel.AddGeneralMultiplicationEquality = AddGeneralMultiplicationEquality
Initial commit
2021-06-08 22:28:15 +00:00
del AddGeneralMultiplicationEquality
Add blacklist parameter to solver Enum members in this dictionary are disallowed by the solver. The types that can be blacklisted have been added to __all__ in solve.py.
2021-08-13 13:39:04 +00:00
def Solve(shadowy_level, bone_market_fluctuations = None, zoological_mania = None, occasional_buyer = None, diplomat_fascination = None, desired_buyers = [], maximum_cost = cp_model.INT32_MAX, maximum_exhaustion = cp_model.INT32_MAX, time_limit = float('inf'), workers = cpu_count(), blacklist = [], stdscr = None):
Initial commit
2021-06-08 22:28:15 +00:00
model = cp_model.CpModel()
actions = {}
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
# Torso
for torso in Torso:
actions[torso] = model.NewBoolVar(torso.value.name)
# Skull
for skull in Skull:
actions[skull] = model.NewIntVar(0, cp_model.INT32_MAX, skull.value.name)
# Appendage
for appendage in Appendage:
if appendage == Appendage.SKIP_TAILS:
actions[appendage] = model.NewBoolVar(appendage.value.name)
Initial commit
2021-06-08 22:28:15 +00:00
else:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
actions[appendage] = model.NewIntVar(0, cp_model.INT32_MAX, appendage.value.name)
Add hints and assumptions The solver now starts by trying to solve without adding joints or declaring skeletons chimeras. Desired buyers are now set as an assumption rather than a linear expression.
2021-06-15 22:27:59 +00:00
# Avoid adding joints at first
model.AddHint(actions[Appendage.ADD_JOINTS], 0)
Initial commit
2021-06-08 22:28:15 +00:00
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
# Adjustment
for adjustment in Adjustment:
actions[adjustment] = model.NewIntVar(0, cp_model.INT32_MAX, adjustment.value.name)
Initial commit
2021-06-08 22:28:15 +00:00
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
# Declaration
Initial commit
2021-06-08 22:28:15 +00:00
for declaration in Declaration:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
actions[declaration] = model.NewBoolVar(declaration.value.name)
Add hints and assumptions The solver now starts by trying to solve without adding joints or declaring skeletons chimeras. Desired buyers are now set as an assumption rather than a linear expression.
2021-06-15 22:27:59 +00:00
# Try non-Chimera declarations first
model.AddHint(actions[Declaration.CHIMERA], 0)
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
Add Embellishment enumeration These actions are taken after a declaration is made, but before the skeleton is sold. Since these actions offer a way of reducing implausibility, difficulty level has been tweaked to avoid allow lowering it past zero.
2021-06-13 19:27:53 +00:00
# Embellishment
for embellishment in Embellishment:
actions[embellishment] = model.NewIntVar(0, cp_model.INT32_MAX, embellishment.value.name)
Add command-line parameter for occasional buyers Some buyers are only available based on a world quality. The solver now skips buyers if they are not available. This is specified using a new parameter, which is mutually-exclusive with specifying a specific buyer. If no buyer is specified, this world quality must be specified instead to tell the solver who is around.
2021-06-16 20:30:48 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# Buyer
for buyer in Buyer:
actions[buyer] = model.NewBoolVar(buyer.value.name)
Add command-line parameter for occasional buyers Some buyers are only available based on a world quality. The solver now skips buyers if they are not available. This is specified using a new parameter, which is mutually-exclusive with specifying a specific buyer. If no buyer is specified, this world quality must be specified instead to tell the solver who is around.
2021-06-16 20:30:48 +00:00
# Mark unavailable buyers
model.AddAssumptions([
actions[buyer].Not()
for unavailable_buyer in OccasionalBuyer if unavailable_buyer != occasional_buyer
Add ability to specify multiple buyers at once Users can now specify multiple buyers, allowing the solver to figure out the best skeleton that could be sold to any of them. This could be useful for buyers that share a payout.
2021-06-16 22:28:16 +00:00
for buyer in unavailable_buyer.value if buyer not in desired_buyers
Add command-line parameter for occasional buyers Some buyers are only available based on a world quality. The solver now skips buyers if they are not available. This is specified using a new parameter, which is mutually-exclusive with specifying a specific buyer. If no buyer is specified, this world quality must be specified instead to tell the solver who is around.
2021-06-16 20:30:48 +00:00
])
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
model.AddAssumptions([
actions[outmoded_fascination.value].Not()
for outmoded_fascination in DiplomatFascination if outmoded_fascination != diplomat_fascination and outmoded_fascination.value not in desired_buyers
])
Add command-line parameter for occasional buyers Some buyers are only available based on a world quality. The solver now skips buyers if they are not available. This is specified using a new parameter, which is mutually-exclusive with specifying a specific buyer. If no buyer is specified, this world quality must be specified instead to tell the solver who is around.
2021-06-16 20:30:48 +00:00
Add ability to specify multiple buyers at once Users can now specify multiple buyers, allowing the solver to figure out the best skeleton that could be sold to any of them. This could be useful for buyers that share a payout.
2021-06-16 22:28:16 +00:00
# Restrict to desired buyers
if desired_buyers:
model.Add(cp_model.LinearExpr.Sum([actions[desired_buyer] for desired_buyer in desired_buyers]) == 1)
Add blacklist parameter to solver Enum members in this dictionary are disallowed by the solver. The types that can be blacklisted have been added to __all__ in solve.py.
2021-08-13 13:39:04 +00:00
# Blacklist
model.Add(cp_model.LinearExpr.Sum([actions[forbidden] for forbidden in blacklist]) == 0)
Add command-line parameter for occasional buyers Some buyers are only available based on a world quality. The solver now skips buyers if they are not available. This is specified using a new parameter, which is mutually-exclusive with specifying a specific buyer. If no buyer is specified, this world quality must be specified instead to tell the solver who is around.
2021-06-16 20:30:48 +00:00
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
# One torso
model.Add(cp_model.LinearExpr.Sum([value for (key, value) in actions.items() if isinstance(key, Torso)]) == 1)
# One declaration
model.Add(cp_model.LinearExpr.Sum([value for (key, value) in actions.items() if isinstance(key, Declaration)]) == 1)
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# One buyer
model.Add(cp_model.LinearExpr.Sum([value for (key, value) in actions.items() if isinstance(key, Buyer)]) == 1)
Initial commit
2021-06-08 22:28:15 +00:00
# Value calculation
original_value = model.NewIntVar(0, cp_model.INT32_MAX, 'original value')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(original_value == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.value for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
Make world quality arguments optional In the absence of provided values, the script will use the "normal" values for everything. While this may produce suboptimal results, it could prove helpful for creating worst-case scenario designs.
2021-07-11 20:45:04 +00:00
value = model.NewIntVar(0, cp_model.INT32_MAX, 'value')
Update formula for Zoological Mania bonus Certain declarations now have their value boosted by 15% during Zoological Mania, rather than just 10%. The list of declarations is currently hardcoded, and may need to be updated in the future.
2021-06-24 13:45:59 +00:00
Make world quality arguments optional In the absence of provided values, the script will use the "normal" values for everything. While this may produce suboptimal results, it could prove helpful for creating worst-case scenario designs.
2021-07-11 20:45:04 +00:00
if zoological_mania:
multiplier = 115 if zoological_mania in [Declaration.FISH, Declaration.INSECT, Declaration.SPIDER] else 110
Initial commit
2021-06-08 22:28:15 +00:00
Make world quality arguments optional In the absence of provided values, the script will use the "normal" values for everything. While this may produce suboptimal results, it could prove helpful for creating worst-case scenario designs.
2021-07-11 20:45:04 +00:00
multiplied_value = model.NewIntVar(0, cp_model.INT32_MAX, 'multiplied value')
model.Add(multiplied_value == multiplier*original_value).OnlyEnforceIf(actions[zoological_mania])
model.Add(multiplied_value == 100*original_value).OnlyEnforceIf(actions[zoological_mania].Not())
model.AddDivisionEquality(value, multiplied_value, 100)
else:
model.Add(value == original_value)
Initial commit
2021-06-08 22:28:15 +00:00
Make world quality arguments optional In the absence of provided values, the script will use the "normal" values for everything. While this may produce suboptimal results, it could prove helpful for creating worst-case scenario designs.
2021-07-11 20:45:04 +00:00
del original_value
Initial commit
2021-06-08 22:28:15 +00:00
# Torso Style calculation
Fix identifier for torso style variable The previous identifier used an underscore instead of a space to separate the words.
2021-06-18 18:49:44 +00:00
torso_style = model.NewIntVarFromDomain(cp_model.Domain.FromValues([torso.value.torso_style for torso in Torso]), 'torso style')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
for torso, torso_variable in {key: value for (key, value) in actions.items() if isinstance(key, Torso)}.items():
model.Add(torso_style == torso.value.torso_style).OnlyEnforceIf(torso_variable)
Initial commit
2021-06-08 22:28:15 +00:00
# Skulls calculation
skulls = model.NewIntVar(0, cp_model.INT32_MAX, 'skulls')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.skulls for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Arms calculation
arms = model.NewIntVar(0, cp_model.INT32_MAX, 'arms')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(arms == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.arms for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Legs calculation
legs = model.NewIntVar(0, cp_model.INT32_MAX, 'legs')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(legs == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.legs for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Tails calculation
tails = model.NewIntVar(0, cp_model.INT32_MAX, 'tails')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(tails == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.tails for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Wings calculation
wings = model.NewIntVar(0, cp_model.INT32_MAX, 'wings')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(wings == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.wings for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Fins calculation
fins = model.NewIntVar(0, cp_model.INT32_MAX, 'fins')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(fins == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.fins for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Tentacles calculation
tentacles = model.NewIntVar(0, cp_model.INT32_MAX, 'tentacles')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(tentacles == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.tentacles for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Amalgamy calculation
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
multiplied_amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'multiplied amalgamy')
model.Add(multiplied_amalgamy == cp_model.LinearExpr.ScalProd(actions.values(), [int(action.value.amalgamy*ATTRIBUTE_MULTIPLIER) for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'amalgamy')
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
model.AddDivisionEquality(amalgamy, multiplied_amalgamy, ATTRIBUTE_MULTIPLIER)
del multiplied_amalgamy
Initial commit
2021-06-08 22:28:15 +00:00
# Antiquity calculation
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
multiplied_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'multiplied antiquity')
model.Add(multiplied_antiquity == cp_model.LinearExpr.ScalProd(actions.values(), [int(action.value.antiquity*ATTRIBUTE_MULTIPLIER) for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'antiquity')
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
model.AddDivisionEquality(antiquity, multiplied_antiquity, ATTRIBUTE_MULTIPLIER)
del multiplied_antiquity
Initial commit
2021-06-08 22:28:15 +00:00
# Menace calculation
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
multiplied_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'multiplied menace')
model.Add(multiplied_menace == cp_model.LinearExpr.ScalProd(actions.values(), [int(action.value.menace*ATTRIBUTE_MULTIPLIER) for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'menace')
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
model.AddDivisionEquality(menace, multiplied_menace, ATTRIBUTE_MULTIPLIER)
del multiplied_menace
Initial commit
2021-06-08 22:28:15 +00:00
# Implausibility calculation
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
multiplied_implausibility = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'multiplied implausibility')
model.Add(multiplied_implausibility == cp_model.LinearExpr.ScalProd(actions.values(), [int(action.value.implausibility*ATTRIBUTE_MULTIPLIER) for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
implausibility = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'implausibility')
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
model.AddDivisionEquality(implausibility, multiplied_implausibility, ATTRIBUTE_MULTIPLIER)
Initial commit
2021-06-08 22:28:15 +00:00
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
del multiplied_implausibility
Centralize exhaustion calculation Exhaustion from actions is now calculated without regard to the buyer. Exhaustion from the buyer is stored in an intermediary "Added Exhaustion" variable, which is added to produce the final exhaustion value. This change substantially reduces the complexity of buyer-specific logic, which will help future improvements.
2021-06-13 18:23:23 +00:00
Initial commit
2021-06-08 22:28:15 +00:00
# Counter-church calculation
# Calculate amount of Counter-church from Holy Relics of the Thigh of Saint Fiacre
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
holy_relic = actions[Appendage.FIACRE_THIGH]
Initial commit
2021-06-08 22:28:15 +00:00
torso_style_divided_by_ten = model.NewIntVar(0, cp_model.INT32_MAX, 'torso style divided by ten')
model.AddDivisionEquality(torso_style_divided_by_ten, torso_style, 10)
holy_relic_counter_church = model.NewIntVar(0, cp_model.INT32_MAX, 'holy relic counter-church')
model.AddMultiplicationEquality(holy_relic_counter_church, [holy_relic, torso_style_divided_by_ten])
counter_church = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'counter-church')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(counter_church == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.counter_church for action in actions.keys()]) + holy_relic_counter_church)
Initial commit
2021-06-08 22:28:15 +00:00
del holy_relic, torso_style_divided_by_ten, holy_relic_counter_church
Centralize exhaustion calculation Exhaustion from actions is now calculated without regard to the buyer. Exhaustion from the buyer is stored in an intermediary "Added Exhaustion" variable, which is added to produce the final exhaustion value. This change substantially reduces the complexity of buyer-specific logic, which will help future improvements.
2021-06-13 18:23:23 +00:00
Initial commit
2021-06-08 22:28:15 +00:00
# Exhaustion calculation
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
exhaustion = model.NewIntVar(0, maximum_exhaustion, 'exhaustion')
Initial commit
2021-06-08 22:28:15 +00:00
Centralize exhaustion calculation Exhaustion from actions is now calculated without regard to the buyer. Exhaustion from the buyer is stored in an intermediary "Added Exhaustion" variable, which is added to produce the final exhaustion value. This change substantially reduces the complexity of buyer-specific logic, which will help future improvements.
2021-06-13 18:23:23 +00:00
# Exhaustion added by certain buyers
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
added_exhaustion = model.NewIntVar(0, maximum_exhaustion, 'added exhaustion')
Centralize exhaustion calculation Exhaustion from actions is now calculated without regard to the buyer. Exhaustion from the buyer is stored in an intermediary "Added Exhaustion" variable, which is added to produce the final exhaustion value. This change substantially reduces the complexity of buyer-specific logic, which will help future improvements.
2021-06-13 18:23:23 +00:00
model.Add(exhaustion == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.exhaustion for action in actions.keys()]) + added_exhaustion)
Initial commit
2021-06-08 22:28:15 +00:00
# Profit intermediate variables
primary_revenue = model.NewIntVar(0, cp_model.INT32_MAX, 'primary revenue')
secondary_revenue = model.NewIntVar(0, cp_model.INT32_MAX, 'secondary revenue')
total_revenue = model.NewIntVar(0, cp_model.INT32_MAX*2, 'total revenue')
model.Add(total_revenue == cp_model.LinearExpr.Sum([primary_revenue, secondary_revenue]))
# Cost
# Calculate value of actions needed to sell the skeleton.
Add Embellishment enumeration These actions are taken after a declaration is made, but before the skeleton is sold. Since these actions offer a way of reducing implausibility, difficulty level has been tweaked to avoid allow lowering it past zero.
2021-06-13 19:27:53 +00:00
difficulty_level = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'difficulty level')
Initial commit
2021-06-08 22:28:15 +00:00
non_zero_difficulty_level = model.NewIntVar(1, cp_model.INT32_MAX, 'non-zero difficulty level')
model.AddMaxEquality(non_zero_difficulty_level, [difficulty_level, 1])
sale_actions_times_action_value = model.NewIntVar(0, cp_model.INT32_MAX, 'sale actions times action value')
Add command-line parameter for Shadowy level This argument determines how difficult selling to a buyer is, which influences how much Implausibility the solver produces.
2021-06-19 12:32:19 +00:00
model.AddDivisionEquality(sale_actions_times_action_value, model.NewConstant(round(DIFFICULTY_SCALER*shadowy_level*Cost.ACTION.value)), non_zero_difficulty_level)
Initial commit
2021-06-08 22:28:15 +00:00
abstract_sale_cost = model.NewIntVar(0, cp_model.INT32_MAX, 'abstract sale cost')
Rename Value enumeration to Cost This change better reflects the meaning of this enumeration: the cost of acquiring something is usually greater than the value that can be extracted from it.
2021-06-13 17:43:52 +00:00
model.AddDivisionEquality(abstract_sale_cost, Cost.ACTION.value**2, sale_actions_times_action_value)
Initial commit
2021-06-08 22:28:15 +00:00
sale_cost = model.NewIntVar(0, cp_model.INT32_MAX, 'sale cost')
Rename Value enumeration to Cost This change better reflects the meaning of this enumeration: the cost of acquiring something is usually greater than the value that can be extracted from it.
2021-06-13 17:43:52 +00:00
model.AddMaxEquality(sale_cost, [abstract_sale_cost, Cost.ACTION.value])
Initial commit
2021-06-08 22:28:15 +00:00
del non_zero_difficulty_level, sale_actions_times_action_value, abstract_sale_cost
# Calculate cost of adding joints
# This is a partial sum formula.
add_joints_amber_cost = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
add_joints = actions[Appendage.ADD_JOINTS]
Initial commit
2021-06-08 22:28:15 +00:00
base_joints = model.NewIntVar(0, cp_model.INT32_MAX, 'base joints')
Count starting limbs in cost of adding joints Some torsos, notably the Headless Skeleton, come with pre-filled limbs that must be factored into the calculation.
2021-06-17 16:26:24 +00:00
model.Add(base_joints == cp_model.LinearExpr.ScalProd([value for (key, value) in actions.items() if isinstance(key, Torso)], [torso.value.limbs_needed + torso.value.arms + torso.value.legs + torso.value.wings + torso.value.fins + torso.value.tentacles for torso in Torso]))
Initial commit
2021-06-08 22:28:15 +00:00
add_joints_amber_cost_multiple = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple')
add_joints_amber_cost_multiple_first_term = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple first term')
Move joint-adding to Appendage Adding joints is allowed at the same time adding appendages is, so it belongs in the Appendage enumeration. In addition to having its constant cost expressed in terms of Value members, adding joints now expresses the dynamic cost in terms of Warm Amber. This particular action should be kept above other actions in the enumeration, as it must be performed before the extra appendages can be added.
2021-06-11 23:04:21 +00:00
model.AddGeneralMultiplicationEquality(add_joints_amber_cost_multiple_first_term, 25, base_joints, base_joints, add_joints)
Initial commit
2021-06-08 22:28:15 +00:00
add_joints_amber_cost_multiple_second_term = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple second term')
Move joint-adding to Appendage Adding joints is allowed at the same time adding appendages is, so it belongs in the Appendage enumeration. In addition to having its constant cost expressed in terms of Value members, adding joints now expresses the dynamic cost in terms of Warm Amber. This particular action should be kept above other actions in the enumeration, as it must be performed before the extra appendages can be added.
2021-06-11 23:04:21 +00:00
model.AddGeneralMultiplicationEquality(add_joints_amber_cost_multiple_second_term, 100, base_joints, add_joints, add_joints)
Initial commit
2021-06-08 22:28:15 +00:00
add_joints_amber_cost_multiple_third_term = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple third term')
Move joint-adding to Appendage Adding joints is allowed at the same time adding appendages is, so it belongs in the Appendage enumeration. In addition to having its constant cost expressed in terms of Value members, adding joints now expresses the dynamic cost in terms of Warm Amber. This particular action should be kept above other actions in the enumeration, as it must be performed before the extra appendages can be added.
2021-06-11 23:04:21 +00:00
model.AddGeneralMultiplicationEquality(add_joints_amber_cost_multiple_third_term, 100, base_joints, add_joints)
Initial commit
2021-06-08 22:28:15 +00:00
add_joints_amber_cost_multiple_fourth_term = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple fourth term')
add_joints_amber_cost_multiple_fourth_term_numerator = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple fourth term numerator')
add_joints_amber_cost_multiple_fourth_term_numerator_first_term = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple fourth term numerator first term')
Move joint-adding to Appendage Adding joints is allowed at the same time adding appendages is, so it belongs in the Appendage enumeration. In addition to having its constant cost expressed in terms of Value members, adding joints now expresses the dynamic cost in terms of Warm Amber. This particular action should be kept above other actions in the enumeration, as it must be performed before the extra appendages can be added.
2021-06-11 23:04:21 +00:00
model.AddGeneralMultiplicationEquality(add_joints_amber_cost_multiple_fourth_term_numerator_first_term, 400, add_joints, add_joints, add_joints)
model.Add(add_joints_amber_cost_multiple_fourth_term_numerator == add_joints_amber_cost_multiple_fourth_term_numerator_first_term + 200*add_joints)
Initial commit
2021-06-08 22:28:15 +00:00
model.AddDivisionEquality(add_joints_amber_cost_multiple_fourth_term, add_joints_amber_cost_multiple_fourth_term_numerator, 3)
del add_joints_amber_cost_multiple_fourth_term_numerator, add_joints_amber_cost_multiple_fourth_term_numerator_first_term
add_joints_amber_cost_multiple_fifth_term = model.NewIntVar(0, cp_model.INT32_MAX, 'add joints amber cost multiple fifth term')
Move joint-adding to Appendage Adding joints is allowed at the same time adding appendages is, so it belongs in the Appendage enumeration. In addition to having its constant cost expressed in terms of Value members, adding joints now expresses the dynamic cost in terms of Warm Amber. This particular action should be kept above other actions in the enumeration, as it must be performed before the extra appendages can be added.
2021-06-11 23:04:21 +00:00
model.AddGeneralMultiplicationEquality(add_joints_amber_cost_multiple_fifth_term, 200, add_joints, add_joints)
Initial commit
2021-06-08 22:28:15 +00:00
model.Add(add_joints_amber_cost_multiple == add_joints_amber_cost_multiple_first_term + add_joints_amber_cost_multiple_second_term - add_joints_amber_cost_multiple_third_term + add_joints_amber_cost_multiple_fourth_term - add_joints_amber_cost_multiple_fifth_term)
del add_joints_amber_cost_multiple_first_term, add_joints_amber_cost_multiple_second_term, add_joints_amber_cost_multiple_third_term, add_joints_amber_cost_multiple_fourth_term, add_joints_amber_cost_multiple_fifth_term
Fix warm amber calculation The cost was inaccurately multiplied by the number of joint additions before. Credit to 34Witches in the FBG Discord for diagnosing the problem.
2021-08-13 02:38:07 +00:00
model.AddGeneralMultiplicationEquality(add_joints_amber_cost, add_joints_amber_cost_multiple, Cost.WARM_AMBER.value)
Initial commit
2021-06-08 22:28:15 +00:00
del add_joints, add_joints_amber_cost_multiple
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
cost = model.NewIntVar(0, maximum_cost, 'cost')
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(cost == cp_model.LinearExpr.ScalProd(actions.values(), [int(action.value.cost) for action in actions.keys()]) + add_joints_amber_cost + sale_cost)
Initial commit
2021-06-08 22:28:15 +00:00
del sale_cost, add_joints_amber_cost
# Type of skeleton
skeleton_in_progress = model.NewIntVar(0, cp_model.INT32_MAX, 'skeleton in progress')
# Chimera
model.Add(skeleton_in_progress == 100) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.CHIMERA])
Initial commit
2021-06-08 22:28:15 +00:00
# Humanoid
model.Add(skeleton_in_progress == 110) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.HUMANOID]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('humanoid antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 0])))
# Ancient Humanoid (UNCERTAIN)
model.Add(skeleton_in_progress == 111) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.HUMANOID]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('ancient humanoid antiquity', antiquity, cp_model.Domain.FromFlatIntervals([1, 5])))
# Neanderthal
model.Add(skeleton_in_progress == 112) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.HUMANOID]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('neanderthal antiquity', antiquity, cp_model.Domain.FromFlatIntervals([6, cp_model.INT_MAX])))
# Ape (UNCERTAIN)
model.Add(skeleton_in_progress == 120) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.APE]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('ape antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 1])))
# Primordial Ape (UNCERTAIN)
model.Add(skeleton_in_progress == 121) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.APE]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('primordial ape antiquity', antiquity, cp_model.Domain.FromFlatIntervals([2, cp_model.INT_MAX])))
# Monkey
model.Add(skeleton_in_progress == 125) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.MONKEY]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('monkey antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 0])))
# Catarrhine Monkey (UNCERTAIN)
model.Add(skeleton_in_progress == 126) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.MONKEY]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('catarrhine monkey 126 antiquity', antiquity, cp_model.Domain.FromFlatIntervals([1, 8])))
# Catarrhine Monkey
model.Add(skeleton_in_progress == 128) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.MONKEY]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('catarrhine monkey 128 antiquity', antiquity, cp_model.Domain.FromFlatIntervals([9, cp_model.INT_MAX])))
# Crocodile
model.Add(skeleton_in_progress == 160) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.REPTILE]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('crocodile antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 1])))
# Dinosaur
model.Add(skeleton_in_progress == 161) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.REPTILE]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('dinosaur antiquity', antiquity, cp_model.Domain.FromFlatIntervals([2, 4])))
# Mesosaur (UNCERTAIN)
model.Add(skeleton_in_progress == 162) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.REPTILE]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('mesosaur antiquity', antiquity, cp_model.Domain.FromFlatIntervals([5, cp_model.INT_MAX])))
# Toad
model.Add(skeleton_in_progress == 170) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.AMPHIBIAN]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('toad antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 1])))
# Primordial Amphibian
model.Add(skeleton_in_progress == 171) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.AMPHIBIAN]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('primordial amphibian antiquity', antiquity, cp_model.Domain.FromFlatIntervals([2, 4])))
# Temnospondyl
model.Add(skeleton_in_progress == 172) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.AMPHIBIAN]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('temnospondyl antiquity', antiquity, cp_model.Domain.FromFlatIntervals([5, cp_model.INT_MAX])))
# Owl
model.Add(skeleton_in_progress == 180) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.BIRD]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('owl antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 1])))
# Archaeopteryx
model.Add(skeleton_in_progress == 181) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.BIRD]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('archaeopteryx antiquity', antiquity, cp_model.Domain.FromFlatIntervals([2, 4])))
# Ornithomimosaur (UNCERTAIN)
model.Add(skeleton_in_progress == 182) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.BIRD]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('ornithomimosaur antiquity', antiquity, cp_model.Domain.FromFlatIntervals([5, cp_model.INT_MAX])))
# Lamprey
model.Add(skeleton_in_progress == 190) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.FISH]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('lamprey antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 0])))
# Coelacanth (UNCERTAIN)
model.Add(skeleton_in_progress == 191) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.FISH]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('coelacanth antiquity', antiquity, cp_model.Domain.FromFlatIntervals([1, cp_model.INT_MAX])))
# Spider (UNCERTAIN)
model.Add(skeleton_in_progress == 200) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.SPIDER]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('spider antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 1])))
# Primordial Orb-Weaver (UNCERTAIN)
model.Add(skeleton_in_progress == 201) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.SPIDER]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('primordial orb-weaver antiquity', antiquity, cp_model.Domain.FromFlatIntervals([2, 7])))
# Trigonotarbid
model.Add(skeleton_in_progress == 203) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.SPIDER]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('trigonotarbid antiquity', antiquity, cp_model.Domain.FromFlatIntervals([8, cp_model.INT_MAX])))
# Beetle (UNCERTAIN)
model.Add(skeleton_in_progress == 210) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.INSECT]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('beetle antiquity', antiquity, cp_model.Domain.FromFlatIntervals([cp_model.INT_MIN, 1])))
# Primordial Beetle (UNCERTAIN)
model.Add(skeleton_in_progress == 211) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.INSECT]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('primordial beetle antiquity', antiquity, cp_model.Domain.FromFlatIntervals([2, 6])))
# Rhyniognatha
model.Add(skeleton_in_progress == 212) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.INSECT]) \
Initial commit
2021-06-08 22:28:15 +00:00
.OnlyEnforceIf(model.NewIntermediateBoolVar('rhyniognatha antiquity', antiquity, cp_model.Domain.FromFlatIntervals([7, cp_model.INT_MAX])))
# Curator
model.Add(skeleton_in_progress == 300) \
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
.OnlyEnforceIf(actions[Declaration.CURATOR])
Initial commit
2021-06-08 22:28:15 +00:00
# Humanoid requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.HUMANOID])
model.Add(legs == 2).OnlyEnforceIf(actions[Declaration.HUMANOID])
model.Add(arms == 2).OnlyEnforceIf(actions[Declaration.HUMANOID])
Clean up requirements Declarations that require a specific range of torso style now use one constraint to model that, rather than two. Inconsistent whitespace has been cleaned up. Skipping tails is only possible if there are tails to skip.
2021-07-07 20:12:03 +00:00
model.AddLinearExpressionInDomain(torso_style, cp_model.Domain.FromFlatIntervals([10, 20])).OnlyEnforceIf(actions[Declaration.HUMANOID])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [tails, fins, wings]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.HUMANOID])
Initial commit
2021-06-08 22:28:15 +00:00
# Ape requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.APE])
model.Add(arms == 4).OnlyEnforceIf(actions[Declaration.APE])
Clean up requirements Declarations that require a specific range of torso style now use one constraint to model that, rather than two. Inconsistent whitespace has been cleaned up. Skipping tails is only possible if there are tails to skip.
2021-07-07 20:12:03 +00:00
model.AddLinearExpressionInDomain(torso_style, cp_model.Domain.FromFlatIntervals([10, 20])).OnlyEnforceIf(actions[Declaration.APE])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [legs, tails, fins, wings]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.APE])
Initial commit
2021-06-08 22:28:15 +00:00
# Monkey requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.MONKEY])
model.Add(arms == 4).OnlyEnforceIf(actions[Declaration.MONKEY])
model.Add(tails == 1).OnlyEnforceIf(actions[Declaration.MONKEY])
Clean up requirements Declarations that require a specific range of torso style now use one constraint to model that, rather than two. Inconsistent whitespace has been cleaned up. Skipping tails is only possible if there are tails to skip.
2021-07-07 20:12:03 +00:00
model.AddLinearExpressionInDomain(torso_style, cp_model.Domain.FromFlatIntervals([10, 20])).OnlyEnforceIf(actions[Declaration.MONKEY])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [legs, fins, wings]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.MONKEY])
Initial commit
2021-06-08 22:28:15 +00:00
# Bird requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(legs == 2).OnlyEnforceIf(actions[Declaration.BIRD])
model.Add(wings == 2).OnlyEnforceIf(actions[Declaration.BIRD])
model.Add(torso_style >= 20).OnlyEnforceIf(actions[Declaration.BIRD])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [arms, fins]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.BIRD])
model.Add(tails < 2).OnlyEnforceIf(actions[Declaration.BIRD])
Initial commit
2021-06-08 22:28:15 +00:00
# Curator requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.CURATOR])
model.Add(arms == 2).OnlyEnforceIf(actions[Declaration.CURATOR])
model.Add(legs == 2).OnlyEnforceIf(actions[Declaration.CURATOR])
model.Add(wings == 2).OnlyEnforceIf(actions[Declaration.CURATOR])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [fins, tails]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.CURATOR])
Initial commit
2021-06-08 22:28:15 +00:00
# Reptile requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(torso_style >= 20).OnlyEnforceIf(actions[Declaration.REPTILE])
model.Add(tails == 1).OnlyEnforceIf(actions[Declaration.REPTILE])
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.REPTILE])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [fins, wings, arms]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.REPTILE])
model.Add(legs < 5).OnlyEnforceIf(actions[Declaration.REPTILE])
Initial commit
2021-06-08 22:28:15 +00:00
# Amphibian requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(torso_style >= 20).OnlyEnforceIf(actions[Declaration.AMPHIBIAN])
model.Add(legs == 4).OnlyEnforceIf(actions[Declaration.AMPHIBIAN])
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.AMPHIBIAN])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [tails, fins, wings, arms]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.AMPHIBIAN])
Initial commit
2021-06-08 22:28:15 +00:00
# Fish requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.FISH])
model.Add(fins >= 2).OnlyEnforceIf(actions[Declaration.FISH])
model.Add(tails <= 1).OnlyEnforceIf(actions[Declaration.FISH])
model.Add(torso_style >= 20).OnlyEnforceIf(actions[Declaration.FISH])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [arms, legs, wings]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.FISH])
Initial commit
2021-06-08 22:28:15 +00:00
# Insect requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(skulls == 1).OnlyEnforceIf(actions[Declaration.INSECT])
model.Add(legs == 6).OnlyEnforceIf(actions[Declaration.INSECT])
model.Add(torso_style >= 20).OnlyEnforceIf(actions[Declaration.INSECT])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [arms, fins, tails]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.INSECT])
model.Add(wings < 5).OnlyEnforceIf(actions[Declaration.INSECT])
Initial commit
2021-06-08 22:28:15 +00:00
# Spider requirements
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(legs == 8).OnlyEnforceIf(actions[Declaration.SPIDER])
model.Add(tails <= 1).OnlyEnforceIf(actions[Declaration.SPIDER])
model.Add(torso_style >= 20).OnlyEnforceIf(actions[Declaration.SPIDER])
Initial commit
2021-06-08 22:28:15 +00:00
for prohibited_quality in [skulls, arms, wings, fins]:
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
model.Add(prohibited_quality == 0).OnlyEnforceIf(actions[Declaration.SPIDER])
# Skeleton must have no unfilled skulls
model.Add(cp_model.LinearExpr.ScalProd(actions.values(), [action.value.skulls_needed for action in actions.keys()]) == 0)
# Skeleton must have no unfilled limbs
model.Add(cp_model.LinearExpr.ScalProd(actions.values(), [action.value.limbs_needed for action in actions.keys()]) == 0)
Initial commit
2021-06-08 22:28:15 +00:00
Remove data model Rather than having a single action list, actions are now added to the model enumeration-by-enumeration. This allows for more flexibility and clarity when introducing exceptions to the norm. Skipping tails is now modelled correctly: it can only be done once, and doing so removes all remaining tails. As far as the model is concerned, this means that not all tails need to be filled if tails have been skipped.
2021-06-13 17:37:15 +00:00
# Skeleton must have no unfilled tails, unless they were skipped
model.Add(cp_model.LinearExpr.ScalProd(actions.values(), [action.value.tails_needed for action in actions.keys()]) == 0).OnlyEnforceIf(actions[Appendage.SKIP_TAILS].Not())
Clean up requirements Declarations that require a specific range of torso style now use one constraint to model that, rather than two. Inconsistent whitespace has been cleaned up. Skipping tails is only possible if there are tails to skip.
2021-07-07 20:12:03 +00:00
model.Add(cp_model.LinearExpr.ScalProd(actions.values(), [action.value.tails_needed for action in actions.keys()]) > 0).OnlyEnforceIf(actions[Appendage.SKIP_TAILS])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# A Palaeontologist with Hoarding Propensities
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_PALAEONTOLOGIST_WITH_HOARDING_PROPENSITIES])
model.Add(primary_revenue == value + 5).OnlyEnforceIf(actions[Buyer.A_PALAEONTOLOGIST_WITH_HOARDING_PROPENSITIES])
model.Add(secondary_revenue == 500).OnlyEnforceIf(actions[Buyer.A_PALAEONTOLOGIST_WITH_HOARDING_PROPENSITIES])
model.Add(difficulty_level == 40*implausibility).OnlyEnforceIf(actions[Buyer.A_PALAEONTOLOGIST_WITH_HOARDING_PROPENSITIES])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_PALAEONTOLOGIST_WITH_HOARDING_PROPENSITIES])
# A Naive Collector
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_NAIVE_COLLECTOR])
value_remainder = model.NewIntVar(0, 249, '{}: {}'.format(Buyer.A_NAIVE_COLLECTOR.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 250)
model.Add(primary_revenue == value - value_remainder).OnlyEnforceIf(actions[Buyer.A_NAIVE_COLLECTOR])
model.Add(secondary_revenue == 0).OnlyEnforceIf(actions[Buyer.A_NAIVE_COLLECTOR])
model.Add(difficulty_level == 25*implausibility).OnlyEnforceIf(actions[Buyer.A_NAIVE_COLLECTOR])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_NAIVE_COLLECTOR])
del value_remainder
# A Familiar Bohemian Sculptress
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS])
model.Add(antiquity <= 0).OnlyEnforceIf(actions[Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS])
value_remainder = model.NewIntVar(0, 249, '{}: {}'.format(Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 250)
model.Add(primary_revenue == value - value_remainder + 1000).OnlyEnforceIf(actions[Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS])
model.Add(secondary_revenue == 250*counter_church).OnlyEnforceIf(actions[Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS])
model.Add(difficulty_level == 50*implausibility).OnlyEnforceIf(actions[Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_FAMILIAR_BOHEMIAN_SCULPTRESS])
del value_remainder
# A Pedagogically Inclined Grandmother
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER])
model.Add(menace <= 0).OnlyEnforceIf(actions[Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER])
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 1000).OnlyEnforceIf(actions[Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER])
model.Add(secondary_revenue == 0).OnlyEnforceIf(actions[Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER])
model.Add(difficulty_level == 50*implausibility).OnlyEnforceIf(actions[Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_PEDAGOGICALLY_INCLINED_GRANDMOTHER])
del value_remainder
# A Theologian of the Old School
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL])
model.Add(amalgamy <= 0).OnlyEnforceIf(actions[Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL])
value_remainder = model.NewIntVar(0, 249, '{}: {}'.format(Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 250)
model.Add(primary_revenue == value - value_remainder + 1000).OnlyEnforceIf(actions[Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL])
model.Add(secondary_revenue == 0).OnlyEnforceIf(actions[Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL])
model.Add(difficulty_level == 50*implausibility).OnlyEnforceIf(actions[Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_THEOLOGIAN_OF_THE_OLD_SCHOOL])
del value_remainder
# An Enthusiast of the Ancient World
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD])
model.Add(antiquity > 0).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD])
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD])
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
model.Add(secondary_revenue == 250*antiquity + (250 if bone_market_fluctuations == Fluctuation.ANTIQUITY else 0)).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD])
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 45*implausibility).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD])
del value_remainder
# Mrs Plenty
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.MRS_PLENTY])
model.Add(menace > 0).OnlyEnforceIf(actions[Buyer.MRS_PLENTY])
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.MRS_PLENTY.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder).OnlyEnforceIf(actions[Buyer.MRS_PLENTY])
model.Add(secondary_revenue == 250*menace).OnlyEnforceIf(actions[Buyer.MRS_PLENTY])
model.Add(difficulty_level == 45*implausibility).OnlyEnforceIf(actions[Buyer.MRS_PLENTY])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.MRS_PLENTY])
del value_remainder
# A Tentacled Servant
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_TENTACLED_SERVANT])
model.Add(amalgamy > 0).OnlyEnforceIf(actions[Buyer.A_TENTACLED_SERVANT])
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_TENTACLED_SERVANT.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(primary_revenue == value - value_remainder + 250).OnlyEnforceIf(actions[Buyer.A_TENTACLED_SERVANT])
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
model.Add(secondary_revenue == 250*amalgamy + (250 if bone_market_fluctuations == Fluctuation.AMALGAMY else 0)).OnlyEnforceIf(actions[Buyer.A_TENTACLED_SERVANT])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 45*implausibility).OnlyEnforceIf(actions[Buyer.A_TENTACLED_SERVANT])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_TENTACLED_SERVANT])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
del value_remainder
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# An Investment-Minded Ambassador
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
model.Add(antiquity > 0).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
antiquity_squared = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_INVESTMENT_MINDED_AMBASSADOR.name, 'antiquity squared'))
model.AddMultiplicationEquality(antiquity_squared, [antiquity, antiquity])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
tailfeathers = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_INVESTMENT_MINDED_AMBASSADOR.name, 'tailfeathers'))
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
if bone_market_fluctuations == Fluctuation.ANTIQUITY:
Update exponent of quadratic buyers with boost Quadratic buyers now use a power of 2.1 rather than 2.2 when affected by Bone Market Fluctuations.
2021-06-22 10:45:33 +00:00
model.AddApproximateExponentiationEquality(tailfeathers, antiquity, 2.1, MAXIMUM_ATTRIBUTE)
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
else:
model.Add(tailfeathers == antiquity_squared).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.AN_INVESTMENT_MINDED_AMBASSADOR.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
extra_value = model.NewIntermediateBoolVar('{}: {}'.format(Buyer.AN_INVESTMENT_MINDED_AMBASSADOR.name, 'extra value'), value_remainder, cp_model.Domain.FromFlatIntervals([0, cp_model.INT_MAX]))
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(primary_revenue == value + 50*extra_value + 250).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
model.Add(secondary_revenue == 250*tailfeathers).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 75*implausibility).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_INVESTMENT_MINDED_AMBASSADOR.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, antiquity_squared, 20)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.AN_INVESTMENT_MINDED_AMBASSADOR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
del antiquity_squared, tailfeathers, value_remainder, extra_value, derived_exhaustion
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# A Teller of Terrors
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
model.Add(menace > 0).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
menace_squared = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_TELLER_OF_TERRORS.name, 'menace squared'))
model.AddMultiplicationEquality(menace_squared, [menace, menace])
Initial commit
2021-06-08 22:28:15 +00:00
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
feathers = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_TELLER_OF_TERRORS.name, 'feathers'))
if bone_market_fluctuations == Fluctuation.MENACE:
model.AddApproximateExponentiationEquality(feathers, menace, 2.1, MAXIMUM_ATTRIBUTE)
else:
model.Add(feathers == menace_squared).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
value_remainder = model.NewIntVar(0, 9, '{}: {}'.format(Buyer.A_TELLER_OF_TERRORS.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 10)
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
model.Add(secondary_revenue == 50*feathers).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 75*implausibility).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_TELLER_OF_TERRORS.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, menace_squared, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_TELLER_OF_TERRORS])
Initial commit
2021-06-08 22:28:15 +00:00
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
del menace_squared, feathers, value_remainder, derived_exhaustion
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# A Tentacled Entrepreneur
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
model.Add(amalgamy > 0).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
amalgamy_squared = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_TENTACLED_ENTREPRENEUR.name, 'amalgamy squared'))
model.AddMultiplicationEquality(amalgamy_squared, [amalgamy, amalgamy])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
final_breaths = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_TENTACLED_ENTREPRENEUR.name, 'final breaths'))
Add CLI Instead of using hardcoded parameters, this script now uses argparse to offer a command-line interface. This includes help text, short and long option specifiers, and control over everything from verbosity to the current world qualities. Occasional Buyer hasn't been implemented yet, but will eventually be a required parameter.
2021-06-14 00:40:11 +00:00
if bone_market_fluctuations == Fluctuation.AMALGAMY:
Update exponent of quadratic buyers with boost Quadratic buyers now use a power of 2.1 rather than 2.2 when affected by Bone Market Fluctuations.
2021-06-22 10:45:33 +00:00
model.AddApproximateExponentiationEquality(final_breaths, amalgamy, 2.1, MAXIMUM_ATTRIBUTE)
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
else:
model.Add(final_breaths == amalgamy_squared).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_TENTACLED_ENTREPRENEUR.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
Centralize value remainder declaration Many buyers use a value remainder to round revenue down. Declaring it outside of buyer-specific logic simplifies almost all of them.
2021-06-13 18:46:45 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(primary_revenue == value - value_remainder + 250).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
model.Add(secondary_revenue == 50*final_breaths).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 75*implausibility).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_TENTACLED_ENTREPRENEUR.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, amalgamy_squared, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_TENTACLED_ENTREPRENEUR])
Initial commit
2021-06-08 22:28:15 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
del amalgamy_squared, final_breaths, value_remainder, derived_exhaustion
# An Author of Gothic Tales
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
model.Add(antiquity > 0).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
model.Add(menace > 0).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
antiquity_times_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_AUTHOR_OF_GOTHIC_TALES.name, 'antiquity times menace'))
model.AddMultiplicationEquality(antiquity_times_menace, [antiquity, menace])
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
antiquity_fluctuation_bonus = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_AUTHOR_OF_GOTHIC_TALES.name, 'antiquity fluctuation bonus'))
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
model.AddDivisionEquality(antiquity_fluctuation_bonus, antiquity, 2)
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
menace_fluctuation_bonus = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_AUTHOR_OF_GOTHIC_TALES.name, 'menace fluctuation bonus'))
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
model.AddDivisionEquality(menace_fluctuation_bonus, menace, 2)
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.AN_AUTHOR_OF_GOTHIC_TALES.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 250).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
model.Add(secondary_revenue == 250*antiquity_times_menace + 250*(antiquity_fluctuation_bonus if bone_market_fluctuations == Fluctuation.ANTIQUITY else menace_fluctuation_bonus if bone_market_fluctuations == Fluctuation.MENACE else 0)).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 75*implausibility).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_AUTHOR_OF_GOTHIC_TALES.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, antiquity_times_menace, 20)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.AN_AUTHOR_OF_GOTHIC_TALES])
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
del antiquity_times_menace, antiquity_fluctuation_bonus, menace_fluctuation_bonus, value_remainder, derived_exhaustion
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# A Zailor with Particular Interests
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
model.Add(antiquity > 0).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
model.Add(amalgamy > 0).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
amalgamy_times_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS.name, 'amalgamy times antiquity'))
model.AddMultiplicationEquality(amalgamy_times_antiquity, [amalgamy, antiquity])
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
amalgamy_fluctuation_bonus = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS.name, 'amalgamy fluctuation bonus'))
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
model.AddDivisionEquality(amalgamy_fluctuation_bonus, amalgamy, 2)
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
antiquity_fluctuation_bonus = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS.name, 'antiquity fluctuation bonus'))
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
model.AddDivisionEquality(antiquity_fluctuation_bonus, antiquity, 2)
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
value_remainder = model.NewIntVar(0, 9, '{}: {}'.format(Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 10)
model.Add(primary_revenue == value - value_remainder + 250).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
model.Add(secondary_revenue == 250*amalgamy_times_antiquity + 250*(amalgamy_fluctuation_bonus if bone_market_fluctuations == Fluctuation.AMALGAMY else antiquity_fluctuation_bonus if bone_market_fluctuations == Fluctuation.ANTIQUITY else 0)).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 75*implausibility).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, amalgamy_times_antiquity, 20)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_ZAILOR_WITH_PARTICULAR_INTERESTS])
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
del amalgamy_times_antiquity, amalgamy_fluctuation_bonus, antiquity_fluctuation_bonus, value_remainder, derived_exhaustion
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# A Rubbery Collector
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
model.Add(amalgamy > 0).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
model.Add(menace > 0).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
amalgamy_times_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_RUBBERY_COLLECTOR.name, 'amalgamy times menace'))
model.AddMultiplicationEquality(amalgamy_times_menace, [amalgamy, menace])
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
amalgamy_fluctuation_bonus = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_RUBBERY_COLLECTOR.name, 'amalgamy fluctuation bonus'))
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
model.AddDivisionEquality(amalgamy_fluctuation_bonus, amalgamy, 2)
Update fluctuation effects on hybrid buyers The formula for hybrid buyers has been changed to make the fluctuation bonus scale with the corresponding attribute.
2021-06-22 14:04:41 +00:00
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
menace_fluctuation_bonus = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_RUBBERY_COLLECTOR.name, 'menace fluctuation bonus'))
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
model.AddDivisionEquality(menace_fluctuation_bonus, menace, 2)
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_RUBBERY_COLLECTOR.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 250).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
Add Menace fluctuation This fluctuation affects buyers similarly to the existing fluctuations, and uses a similar implementation as a result.
2021-07-06 18:19:29 +00:00
model.Add(secondary_revenue == 250*amalgamy_times_menace + 250*(amalgamy_fluctuation_bonus if bone_market_fluctuations == Fluctuation.AMALGAMY else menace_fluctuation_bonus if bone_market_fluctuations == Fluctuation.MENACE else 0)).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
model.Add(difficulty_level == 75*implausibility).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_RUBBERY_COLLECTOR.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, amalgamy_times_menace, 20)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_RUBBERY_COLLECTOR])
Update fluctuation bonuses for hybrid buyers The multiplier is now 1/2 instead of 4/5. This means that is no longer necessary to multiply before dividing.
2021-07-07 19:17:55 +00:00
del amalgamy_times_menace, amalgamy_fluctuation_bonus, menace_fluctuation_bonus, value_remainder, derived_exhaustion
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# A Constable
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([110, 119])).OnlyEnforceIf(actions[Buyer.A_CONSTABLE])
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_CONSTABLE.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 1000).OnlyEnforceIf(actions[Buyer.A_CONSTABLE])
model.Add(secondary_revenue == 0).OnlyEnforceIf(actions[Buyer.A_CONSTABLE])
model.Add(difficulty_level == 50*implausibility).OnlyEnforceIf(actions[Buyer.A_CONSTABLE])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_CONSTABLE])
del value_remainder
# An Enthusiast in Skulls
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
model.Add(skulls >= 2).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
extra_skulls = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_ENTHUSIAST_IN_SKULLS.name, 'extra skulls'))
model.Add(extra_skulls == skulls - 1).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
vital_intelligence = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_ENTHUSIAST_IN_SKULLS.name, 'vital intelligence'))
model.AddApproximateExponentiationEquality(vital_intelligence, extra_skulls, 1.8, MAXIMUM_ATTRIBUTE)
model.Add(primary_revenue == value).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
model.Add(secondary_revenue == 1250*vital_intelligence).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
model.Add(difficulty_level == 60*implausibility).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_ENTHUSIAST_IN_SKULLS.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, vital_intelligence, 4)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.AN_ENTHUSIAST_IN_SKULLS])
del extra_skulls, vital_intelligence, derived_exhaustion
# A Dreary Midnighter
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([110, 299])).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
model.Add(amalgamy <= 0).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
model.Add(counter_church <= 0).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
value_remainder = model.NewIntVar(0, 2, '{}: {}'.format(Buyer.A_DREARY_MIDNIGHTER.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 3)
model.Add(primary_revenue == value - value_remainder + 300).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
model.Add(secondary_revenue == 250).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
model.Add(difficulty_level == 100*implausibility).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.A_DREARY_MIDNIGHTER])
del value_remainder
Add Bazaarine option of Colourful Phantasist This buyer scales with the product of implausibility and amalgamy.
2021-06-15 11:56:05 +00:00
# A Colourful Phantasist - Bazaarine
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
model.Add(implausibility >= 2).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
model.Add(amalgamy >= 4).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
amalgamy_times_implausibility = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE.name, 'amalgamy times implausibility'))
model.AddMultiplicationEquality(amalgamy_times_implausibility, [amalgamy, implausibility])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
bazaarine_poetry = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE.name, 'bazaarine poetry'))
model.Add(bazaarine_poetry == amalgamy_times_implausibility + 1)
Add Bazaarine option of Colourful Phantasist This buyer scales with the product of implausibility and amalgamy.
2021-06-15 11:56:05 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 100).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
model.Add(secondary_revenue == 250*bazaarine_poetry).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
Add Bazaarine option of Colourful Phantasist This buyer scales with the product of implausibility and amalgamy.
2021-06-15 11:56:05 +00:00
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
# The indirection is necessary for applying an enforcement literal
Change minimum of Phantasist's derived exhaustion If the minimum is 0, then that value will never be allowed to be negative. Since it is calculated even when that is not the selected buyer, that prevents overcorrections that should be permitted.
2021-06-15 22:48:41 +00:00
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE.name, 'derived exhaustion'))
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
model.AddDivisionEquality(derived_exhaustion, bazaarine_poetry, 20)
Add Bazaarine option of Colourful Phantasist This buyer scales with the product of implausibility and amalgamy.
2021-06-15 11:56:05 +00:00
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
del amalgamy_times_implausibility, bazaarine_poetry, value_remainder, derived_exhaustion
Add Bazaarine option of Colourful Phantasist This buyer scales with the product of implausibility and amalgamy.
2021-06-15 11:56:05 +00:00
Add Nocturnal option of Colourful Phantasist This buyer scales with the product of implausibility and menace.
2021-06-15 12:02:49 +00:00
# A Colourful Phantasist - Nocturnal
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
model.Add(implausibility >= 2).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
model.Add(menace >= 4).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
menace_times_implausibility = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL.name, 'menace times implausibility'))
model.AddMultiplicationEquality(menace_times_implausibility, [menace, implausibility])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
stygian_ivory = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL.name, 'stygian ivory'))
model.Add(stygian_ivory == menace_times_implausibility + 1)
Add Nocturnal option of Colourful Phantasist This buyer scales with the product of implausibility and menace.
2021-06-15 12:02:49 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 100).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
model.Add(secondary_revenue == 250*stygian_ivory).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
Add Nocturnal option of Colourful Phantasist This buyer scales with the product of implausibility and menace.
2021-06-15 12:02:49 +00:00
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
# The indirection is necessary for applying an enforcement literal
Change minimum of Phantasist's derived exhaustion If the minimum is 0, then that value will never be allowed to be negative. Since it is calculated even when that is not the selected buyer, that prevents overcorrections that should be permitted.
2021-06-15 22:48:41 +00:00
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL.name, 'derived exhaustion'))
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
model.AddDivisionEquality(derived_exhaustion, stygian_ivory, 20)
Add Nocturnal option of Colourful Phantasist This buyer scales with the product of implausibility and menace.
2021-06-15 12:02:49 +00:00
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
del menace_times_implausibility, stygian_ivory, value_remainder, derived_exhaustion
Add Nocturnal option of Colourful Phantasist This buyer scales with the product of implausibility and menace.
2021-06-15 12:02:49 +00:00
Add Celestial option of Colourful Phantasist This buyer scales with the product of implausibility and antiquity.
2021-06-15 12:10:20 +00:00
# A Colourful Phantasist - Celestial
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
model.Add(implausibility >= 2).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
model.Add(antiquity >= 4).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
antiquity_times_implausibility = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL.name, 'antiquity times implausibility'))
model.AddMultiplicationEquality(antiquity_times_implausibility, [antiquity, implausibility])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
knob_of_scintillack = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL.name, 'knob of scintillack'))
model.Add(knob_of_scintillack == antiquity_times_implausibility + 1)
Add Celestial option of Colourful Phantasist This buyer scales with the product of implausibility and antiquity.
2021-06-15 12:10:20 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 100).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
model.Add(secondary_revenue == 250*knob_of_scintillack).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
Add Celestial option of Colourful Phantasist This buyer scales with the product of implausibility and antiquity.
2021-06-15 12:10:20 +00:00
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
# The indirection is necessary for applying an enforcement literal
Change minimum of Phantasist's derived exhaustion If the minimum is 0, then that value will never be allowed to be negative. Since it is calculated even when that is not the selected buyer, that prevents overcorrections that should be permitted.
2021-06-15 22:48:41 +00:00
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL.name, 'derived exhaustion'))
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
model.AddDivisionEquality(derived_exhaustion, knob_of_scintillack, 20)
Add Celestial option of Colourful Phantasist This buyer scales with the product of implausibility and antiquity.
2021-06-15 12:10:20 +00:00
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL])
Fix Exhaustion of Colourful Phantasist The Colourful Phantasist includes the minimum secondary reward in the exhaustion formula.
2021-06-16 20:53:10 +00:00
del antiquity_times_implausibility, knob_of_scintillack, value_remainder, derived_exhaustion
Add Celestial option of Colourful Phantasist This buyer scales with the product of implausibility and antiquity.
2021-06-15 12:10:20 +00:00
Add the Ingenuous Malacologist This buyer scales with the number of tentacles on the skeleton.
2021-06-22 13:25:12 +00:00
# An Ingenuous Malacologist
model.Add(tentacles >= 4).OnlyEnforceIf(actions[Buyer.AN_INGENUOUS_MALACOLOGIST])
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.AN_INGENUOUS_MALACOLOGIST])
exponentiated_tentacles = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_INGENUOUS_MALACOLOGIST.name, 'exponentiated tentacles'))
model.AddApproximateExponentiationEquality(exponentiated_tentacles, tentacles, 2.2, MAXIMUM_ATTRIBUTE)
collated_research = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_INGENUOUS_MALACOLOGIST.name, 'collated research'))
model.AddDivisionEquality(collated_research, exponentiated_tentacles, 5)
value_remainder = model.NewIntVar(0, 249, '{}: {}'.format(Buyer.AN_INGENUOUS_MALACOLOGIST.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 250)
model.Add(primary_revenue == value - value_remainder + 250).OnlyEnforceIf(actions[Buyer.AN_INGENUOUS_MALACOLOGIST])
model.Add(secondary_revenue == 250*collated_research).OnlyEnforceIf(actions[Buyer.AN_INGENUOUS_MALACOLOGIST])
model.Add(difficulty_level == 60*implausibility).OnlyEnforceIf(actions[Buyer.AN_INGENUOUS_MALACOLOGIST])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_INGENUOUS_MALACOLOGIST.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, exponentiated_tentacles, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.AN_INGENUOUS_MALACOLOGIST])
del exponentiated_tentacles, collated_research, value_remainder, derived_exhaustion
Add the Enterprising Boot Salesman This buyer scales with the number of legs on the skeleton.
2021-07-06 19:18:07 +00:00
# An Enterprising Boot Salesman
model.Add(menace <= 0).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
model.Add(amalgamy <= 0).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
model.Add(legs >= 4).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
diamonds = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_ENTERPRISING_BOOT_SALESMAN.name, 'diamonds'))
model.AddApproximateExponentiationEquality(diamonds, legs, 2.2, MAXIMUM_ATTRIBUTE)
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.AN_ENTERPRISING_BOOT_SALESMAN.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
model.Add(secondary_revenue == 50*diamonds).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.AN_ENTERPRISING_BOOT_SALESMAN.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, diamonds, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.AN_ENTERPRISING_BOOT_SALESMAN])
del diamonds, value_remainder, derived_exhaustion
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
# The Dumbwaiter of Balmoral
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([180, 189])).OnlyEnforceIf(actions[Buyer.THE_DUMBWAITER_OF_BALMORAL])
model.Add(value >= 250).OnlyEnforceIf(actions[Buyer.THE_DUMBWAITER_OF_BALMORAL])
value_remainder = model.NewIntVar(0, 249, '{}: {}'.format(Buyer.THE_DUMBWAITER_OF_BALMORAL.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 250)
model.Add(primary_revenue == value - value_remainder).OnlyEnforceIf(actions[Buyer.THE_DUMBWAITER_OF_BALMORAL])
model.Add(secondary_revenue == 0).OnlyEnforceIf(actions[Buyer.THE_DUMBWAITER_OF_BALMORAL])
model.Add(difficulty_level == 200).OnlyEnforceIf(actions[Buyer.THE_DUMBWAITER_OF_BALMORAL])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.THE_DUMBWAITER_OF_BALMORAL])
del value_remainder
Initial commit
2021-06-08 22:28:15 +00:00
Add The Carpenter's Granddaughter This buyer produces a Leviathan Frame, and is rather unlikely to ever be profitable. However, the solver can reduce costs as much as possible.
2021-06-14 03:00:34 +00:00
# The Carpenter's Granddaughter
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.THE_CARPENTERS_GRANDDAUGHTER])
model.Add(value >= 30000).OnlyEnforceIf(actions[Buyer.THE_CARPENTERS_GRANDDAUGHTER])
model.Add(primary_revenue == 31250).OnlyEnforceIf(actions[Buyer.THE_CARPENTERS_GRANDDAUGHTER])
model.Add(secondary_revenue == 0).OnlyEnforceIf(actions[Buyer.THE_CARPENTERS_GRANDDAUGHTER])
model.Add(difficulty_level == 100*implausibility).OnlyEnforceIf(actions[Buyer.THE_CARPENTERS_GRANDDAUGHTER])
model.Add(added_exhaustion == 0).OnlyEnforceIf(actions[Buyer.THE_CARPENTERS_GRANDDAUGHTER])
Add amalgamy fascination for Diplomat This fascination scales with the amount of amalgamy on the skeleton.
2021-08-03 20:34:37 +00:00
# The Trifling Diplomat - Amalgamy
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY])
model.Add(amalgamy >= 5).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY])
amalgamy_squared = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY.name, 'amalgamy squared'))
model.AddMultiplicationEquality(amalgamy_squared, [amalgamy, amalgamy])
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY])
model.Add(secondary_revenue == 50*amalgamy_squared).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY])
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, amalgamy_squared, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_AMALGAMY])
del amalgamy_squared, value_remainder, derived_exhaustion
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
# The Trifling Diplomat - Antiquity
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY])
model.Add(antiquity >= 5).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY])
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
antiquity_squared = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY.name, 'antiquity squared'))
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
model.AddMultiplicationEquality(antiquity_squared, [antiquity, antiquity])
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY.name, 'value remainder'))
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
model.AddModuloEquality(value_remainder, value, 50)
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY])
model.Add(secondary_revenue == 50*antiquity_squared).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY])
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY])
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
# The indirection is necessary for applying an enforcement literal
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY.name, 'derived exhaustion'))
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
model.AddDivisionEquality(derived_exhaustion, antiquity_squared, 100)
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_ANTIQUITY])
Add the Trifling Diplomat This buyer actually changes based on a world quality. As such, it has been implemented in a similar fashion to Occasional Buyer. The scaling for this buyer's difficulty level has not been established at the time of this writing, so it is being treated as 0.
2021-06-25 23:37:41 +00:00
del antiquity_squared, value_remainder, derived_exhaustion
Add bird fascination for Diplomat This fascination effectively requires a Bird declaration, and scales with all three skeleton attributes multiplied together.
2021-07-06 17:33:03 +00:00
# The Trifling Diplomat - Bird
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([180, 189])).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_BIRD])
non_negative_amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_BIRD.name, 'non-negative amalgamy'))
model.AddMaxEquality(non_negative_amalgamy, [amalgamy, 0])
non_negative_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_BIRD.name, 'non-negative menace'))
model.AddMaxEquality(non_negative_menace, [menace, 0])
non_negative_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_BIRD.name, 'non-negative antiquity'))
model.AddMaxEquality(non_negative_antiquity, [antiquity, 0])
compromising_documents = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_BIRD.name, 'compromising documents'))
model.AddGeneralMultiplicationEquality(compromising_documents, non_negative_amalgamy, non_negative_menace, non_negative_antiquity)
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_BIRD.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_BIRD])
model.Add(secondary_revenue == 50*compromising_documents).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_BIRD])
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_BIRD])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_BIRD.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, compromising_documents, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_BIRD])
del non_negative_amalgamy, non_negative_menace, non_negative_antiquity, compromising_documents, value_remainder, derived_exhaustion
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
# The Trifling Diplomat - Fish
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([190, 199])).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_FISH])
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
non_negative_amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_FISH.name, 'non-negative amalgamy'))
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
model.AddMaxEquality(non_negative_amalgamy, [amalgamy, 0])
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
non_negative_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_FISH.name, 'non-negative menace'))
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
model.AddMaxEquality(non_negative_menace, [menace, 0])
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
non_negative_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_FISH.name, 'non-negative antiquity'))
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
model.AddMaxEquality(non_negative_antiquity, [antiquity, 0])
Fix missing variable name
2021-07-06 16:42:20 +00:00
compromising_documents = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_FISH.name, 'compromising documents'))
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
model.AddGeneralMultiplicationEquality(compromising_documents, non_negative_amalgamy, non_negative_menace, non_negative_antiquity)
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_FISH.name, 'value remainder'))
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
model.AddModuloEquality(value_remainder, value, 50)
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_FISH])
model.Add(secondary_revenue == 50*compromising_documents).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_FISH])
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_FISH])
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
# The indirection is necessary for applying an enforcement literal
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_FISH.name, 'derived exhaustion'))
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
model.AddDivisionEquality(derived_exhaustion, compromising_documents, 100)
Change names of DiplomatFascination members The new names are more consistent with other enumerations, namely Declaration and Fluctuation.
2021-07-06 16:25:15 +00:00
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_FISH])
Add fossilised fish fascination for Diplomat This fascination effectively requires a Fish declaration, and scales with all three skeleton attributes multiplied together.
2021-06-29 20:56:42 +00:00
del non_negative_amalgamy, non_negative_menace, non_negative_antiquity, compromising_documents, value_remainder, derived_exhaustion
Add insect fascination for Diplomat This fascination effectively requires an Insect declaration, and scales with all three skeleton attributes multiplied together.
2021-07-14 15:39:20 +00:00
# The Trifling Diplomat - Insect
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([210, 219])).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_INSECT])
non_negative_amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_INSECT.name, 'non-negative amalgamy'))
model.AddMaxEquality(non_negative_amalgamy, [amalgamy, 0])
non_negative_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_INSECT.name, 'non-negative menace'))
model.AddMaxEquality(non_negative_menace, [menace, 0])
non_negative_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_INSECT.name, 'non-negative antiquity'))
model.AddMaxEquality(non_negative_antiquity, [antiquity, 0])
compromising_documents = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_INSECT.name, 'compromising documents'))
model.AddGeneralMultiplicationEquality(compromising_documents, non_negative_amalgamy, non_negative_menace, non_negative_antiquity)
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_INSECT.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_INSECT])
model.Add(secondary_revenue == 50*compromising_documents).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_INSECT])
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_INSECT])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_INSECT.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, compromising_documents, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_INSECT])
del non_negative_amalgamy, non_negative_menace, non_negative_antiquity, compromising_documents, value_remainder, derived_exhaustion
Add reptile fascination for Diplomat This fascination effectively requires a Reptile declaration, and scales with all three skeleton attributes multiplied together.
2021-08-24 12:22:37 +00:00
# The Trifling Diplomat - Reptile
model.AddLinearExpressionInDomain(skeleton_in_progress, cp_model.Domain.FromFlatIntervals([160, 169])).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_REPTILE])
non_negative_amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_REPTILE.name, 'non-negative amalgamy'))
model.AddMaxEquality(non_negative_amalgamy, [amalgamy, 0])
non_negative_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_REPTILE.name, 'non-negative menace'))
model.AddMaxEquality(non_negative_menace, [menace, 0])
non_negative_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_REPTILE.name, 'non-negative antiquity'))
model.AddMaxEquality(non_negative_antiquity, [antiquity, 0])
compromising_documents = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_REPTILE.name, 'compromising documents'))
model.AddGeneralMultiplicationEquality(compromising_documents, non_negative_amalgamy, non_negative_menace, non_negative_antiquity)
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_REPTILE.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_REPTILE])
model.Add(secondary_revenue == 50*compromising_documents).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_REPTILE])
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_REPTILE])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_REPTILE.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, compromising_documents, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_REPTILE])
del non_negative_amalgamy, non_negative_menace, non_negative_antiquity, compromising_documents, value_remainder, derived_exhaustion
Add skulls fascination for Diplomat This fascination scales with all three skeleton attributes multiplied together.
2021-08-11 23:35:15 +00:00
# The Trifling Diplomat - Skulls
model.Add(skeleton_in_progress >= 100).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_SKULLS])
model.Add(skulls >= 5).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_SKULLS])
non_negative_amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_SKULLS.name, 'non-negative amalgamy'))
model.AddMaxEquality(non_negative_amalgamy, [amalgamy, 0])
non_negative_menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_SKULLS.name, 'non-negative menace'))
model.AddMaxEquality(non_negative_menace, [menace, 0])
non_negative_antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_SKULLS.name, 'non-negative antiquity'))
model.AddMaxEquality(non_negative_antiquity, [antiquity, 0])
compromising_documents = model.NewIntVar(0, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_SKULLS.name, 'compromising documents'))
model.AddGeneralMultiplicationEquality(compromising_documents, non_negative_amalgamy, non_negative_menace, non_negative_antiquity)
value_remainder = model.NewIntVar(0, 49, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_SKULLS.name, 'value remainder'))
model.AddModuloEquality(value_remainder, value, 50)
model.Add(primary_revenue == value - value_remainder + 50).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_SKULLS])
model.Add(secondary_revenue == 50*compromising_documents).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_SKULLS])
model.Add(difficulty_level == 0).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_SKULLS])
# The indirection is necessary for applying an enforcement literal
derived_exhaustion = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, '{}: {}'.format(Buyer.THE_TRIFLING_DIPLOMAT_SKULLS.name, 'derived exhaustion'))
model.AddDivisionEquality(derived_exhaustion, compromising_documents, 100)
model.Add(added_exhaustion == derived_exhaustion).OnlyEnforceIf(actions[Buyer.THE_TRIFLING_DIPLOMAT_SKULLS])
del non_negative_amalgamy, non_negative_menace, non_negative_antiquity, compromising_documents, value_remainder, derived_exhaustion
Initial commit
2021-06-08 22:28:15 +00:00
# Maximize profit margin
net_profit = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'net profit')
model.Add(net_profit == total_revenue - cost)
# This is necessary to preserve some degree of precision after dividing
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
multiplied_net_profit = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'multiplied net profit')
Initial commit
2021-06-08 22:28:15 +00:00
model.AddMultiplicationEquality(multiplied_net_profit, [net_profit, PROFIT_MARGIN_MULTIPLIER])
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
absolute_multiplied_net_profit = model.NewIntVar(0, cp_model.INT32_MAX, 'absolute multiplied net profit')
Initial commit
2021-06-08 22:28:15 +00:00
model.AddAbsEquality(absolute_multiplied_net_profit, multiplied_net_profit)
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
absolute_profit_margin = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'absolute profit margin')
Initial commit
2021-06-08 22:28:15 +00:00
model.AddDivisionEquality(absolute_profit_margin, absolute_multiplied_net_profit, total_revenue)
Add support for fractions of skeleton attributes
2021-08-24 11:10:39 +00:00
profit_margin = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'profit margin')
Initial commit
2021-06-08 22:28:15 +00:00
positive_net_profit = model.NewIntermediateBoolVar('positive net profit', net_profit, cp_model.Domain.FromFlatIntervals([0, cp_model.INT_MAX]))
model.Add(profit_margin == absolute_profit_margin).OnlyEnforceIf(positive_net_profit)
model.Add(profit_margin == absolute_profit_margin*-1).OnlyEnforceIf(positive_net_profit.Not())
del multiplied_net_profit, absolute_multiplied_net_profit, absolute_profit_margin, positive_net_profit
Make buyers part of model Buyers are now part of the model, rather than being fixed. This means that the model can choose from among all buyers and determine the most profitable option. Accomplishing this meant replacing the if-else control flow with a large quantity of half-reified constraints.
2021-06-13 22:37:39 +00:00
Initial commit
2021-06-08 22:28:15 +00:00
model.Maximize(profit_margin)
Move solution printing to special class This class has the advantage of being usable as a solution printer, which can print each solution as they are generated. This tends to be extremely verbose, but may prove useful for debugging.
2021-06-15 19:13:07 +00:00
class SkeletonPrinter(cp_model.CpSolverSolutionCallback):
Use docstrings instead of comments if appropriate Unlike comments, docstrings support runtime introspection and other features. The docstrings are arguably a bit sparse, but this is sufficient for the time being.
2021-06-18 19:44:30 +00:00
"""A class that prints the steps that comprise a skeleton as well as relevant attributes."""
Move solution printing to special class This class has the advantage of being usable as a solution printer, which can print each solution as they are generated. This tends to be extremely verbose, but may prove useful for debugging.
2021-06-15 19:13:07 +00:00
def __init__(self):
cp_model.CpSolverSolutionCallback.__init__(self)
self.__solution_count = 0
def PrintableSolution(self, solver = None):
Use docstrings instead of comments if appropriate Unlike comments, docstrings support runtime introspection and other features. The docstrings are arguably a bit sparse, but this is sufficient for the time being.
2021-06-18 19:44:30 +00:00
"""Print the latest solution of a provided solver."""
Move solution printing to special class This class has the advantage of being usable as a solution printer, which can print each solution as they are generated. This tends to be extremely verbose, but may prove useful for debugging.
2021-06-15 19:13:07 +00:00
output = ""
# Allows use as a callback
if solver is None:
solver = self
for action in actions.keys():
for _ in range(int(solver.Value(actions[action]))):
output += str(action) + "\n"
output += "\nProfit: £{:,.2f}\n".format(solver.Value(net_profit)/100)
output += "Profit Margin: {:+,.2%}\n".format(solver.Value(profit_margin)/PROFIT_MARGIN_MULTIPLIER)
output += "\nTotal Revenue: £{:,.2f}\n".format(solver.Value(total_revenue)/100)
output += "Primary Revenue: £{:,.2f}\n".format(solver.Value(primary_revenue)/100)
output += "Secondary Revenue: £{:,.2f}\n".format(solver.Value(secondary_revenue)/100)
output += "\nCost: £{:,.2f}\n".format(solver.Value(cost)/100)
output += "\nValue: £{:,.2f}\n".format(solver.Value(value)/100)
output += "Amalgamy: {:n}\n".format(solver.Value(amalgamy))
output += "Antiquity: {:n}\n".format(solver.Value(antiquity))
output += "Menace: {:n}\n".format(solver.Value(menace))
output += "Counter-Church: {:n}\n".format(solver.Value(counter_church))
output += "Implausibility: {:n}\n".format(solver.Value(implausibility))
output += "\nExhaustion: {:n}".format(solver.Value(exhaustion))
return output
def OnSolutionCallback(self):
self.__solution_count += 1
Show current best skeleton while calculating So long as verbose mode is not active, the script will now display the current skeleton as it tries to search for more solutions. This feature uses the curses module to create an alternate screen, so intermediate solutions are not sent to standard output.
2021-06-15 21:50:28 +00:00
# Prints current solution to window
stdscr.clear()
stdscr.addstr(self.PrintableSolution())
stdscr.addstr(stdscr.getmaxyx()[0] - 1, 0, "Skeleton #{:n}".format(self.__solution_count))
stdscr.refresh()
Move solution printing to special class This class has the advantage of being usable as a solution printer, which can print each solution as they are generated. This tends to be extremely verbose, but may prove useful for debugging.
2021-06-15 19:13:07 +00:00
def SolutionCount(self):
return self.__solution_count
printer = SkeletonPrinter()
Initial commit
2021-06-08 22:28:15 +00:00
solver = cp_model.CpSolver()
Add command-line parameter for workers This allows users to adjust the number of CPU threads that the solver uses, which may be useful if you want to leave it running while you use it.
2021-06-18 21:18:40 +00:00
solver.parameters.num_search_workers = workers
Add command-line parameter for time limit You can now pass an optional time limit to the script, which causes the solver to return the best solution it has once the duration has elapsed.
2021-06-16 16:32:05 +00:00
solver.parameters.max_time_in_seconds = time_limit
Initial commit
2021-06-08 22:28:15 +00:00
Show current best skeleton while calculating So long as verbose mode is not active, the script will now display the current skeleton as it tries to search for more solutions. This feature uses the curses module to create an alternate screen, so intermediate solutions are not sent to standard output.
2021-06-15 21:50:28 +00:00
# There's no window in verbose mode
if stdscr is None:
solver.parameters.log_search_progress = True
solver.Solve(model)
else:
solver.SolveWithSolutionCallback(model, printer)
status = solver.StatusName()
Standardize quotes across script Single quotes are used for identifiers. Double quotes are used for strings that are meant to be read by users.
2021-06-18 18:48:20 +00:00
if status == 'INFEASIBLE':
Initial commit
2021-06-08 22:28:15 +00:00
raise RuntimeError("There is no satisfactory skeleton.")
Standardize quotes across script Single quotes are used for identifiers. Double quotes are used for strings that are meant to be read by users.
2021-06-18 18:48:20 +00:00
elif status == 'FEASIBLE':
Initial commit
2021-06-08 22:28:15 +00:00
print("WARNING: skeleton may be suboptimal.")
Standardize quotes across script Single quotes are used for identifiers. Double quotes are used for strings that are meant to be read by users.
2021-06-18 18:48:20 +00:00
elif status != 'OPTIMAL':
Initial commit
2021-06-08 22:28:15 +00:00
raise RuntimeError("Unknown status returned: {}.".format(status))
Show current best skeleton while calculating So long as verbose mode is not active, the script will now display the current skeleton as it tries to search for more solutions. This feature uses the curses module to create an alternate screen, so intermediate solutions are not sent to standard output.
2021-06-15 21:50:28 +00:00
return printer.PrintableSolution(solver)