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

1606 lines
82 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 DiplomatFascination to public interface Its prior exclusion was a mistake: this is necessary to use Solve.
2021-07-06 17:05:10 +00:00
__all__ = ['Declaration', 'DiplomatFascination', 'Fluctuation', 'OccasionalBuyer', 'Solve']
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"
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
import argparse
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
import curses
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
from enum import Enum
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
Move Adjustment to different file
2021-08-03 17:24:53 +00:00
from data.adjustments import Adjustment
Move Appendage to different file
2021-08-03 17:22:00 +00:00
from data.appendages import Appendage
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
from data.costs import Cost
Move Declaration to different file
2021-08-03 17:31:20 +00:00
from data.declarations import Declaration
Move Skull to different file
2021-08-03 17:19:21 +00:00
from data.skulls import Skull
Move Torso to different file
2021-08-03 17:16:16 +00:00
from data.torsos import Torso
Move Action to different file In order to move remaining enumerations into other files, dependencies in this file need to be moved as well. The folder is named "objects" because "types" is taken as a name.
2021-08-03 17:12:11 +00:00
from objects.action import Action
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
# This is the highest number of attribute to calculate fractional exponents for.
MAXIMUM_ATTRIBUTE = 100
# This is a constant used to calculate difficulty checks. You almost certainly do not need to change this.
DIFFICULTY_SCALER = 0.6
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
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
class Embellishment(Enum):
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
"""An action is taken after a declaration has been made for a 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
MORE_PLAUSIBLE = Action(
"Make it seem just a bit more plausible",
cost = Cost.ACTION.value + Cost.REVISIONIST_NARRATIVE.value,
implausibility = -1
)
CONVINCING_HISTORY = Action(
"Invest great time and skill in coming up with a convincing history",
cost = Cost.ACTION.value + 3*Cost.REVISIONIST_NARRATIVE.value,
implausibility = -5
)
def __str__(self):
return str(self.value)
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
class Buyer(Enum):
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
"""An action that converts a skeleton into revenue."""
Add Action values for buyers This will allow buyers to be variable rather than fixed, and increase the orthogonality of the code.
2021-06-13 19:58:51 +00:00
A_PALAEONTOLOGIST_WITH_HOARDING_PROPENSITIES = Action(
"Sell a complete skeleton to the Bone Hoarder",
cost = Cost.ACTION.value
)
A_NAIVE_COLLECTOR = Action(
"Sell your Skeleton to a Naive Collector",
cost = Cost.ACTION.value
)
A_FAMILIAR_BOHEMIAN_SCULPTRESS = Action(
"Sell your Skeleton to the Sculptress",
cost = Cost.ACTION.value
)
A_PEDAGOGICALLY_INCLINED_GRANDMOTHER = Action(
"Sell your skeleton to a Pedagogically Inclined Grandmother",
cost = Cost.ACTION.value
)
A_THEOLOGIAN_OF_THE_OLD_SCHOOL = Action(
"Sell your Skeleton to the Theologian of the Old School",
cost = Cost.ACTION.value
)
AN_ENTHUSIAST_OF_THE_ANCIENT_WORLD = Action(
"Sell your skeleton to an Enthusiast of the Ancient World",
cost = Cost.ACTION.value
)
MRS_PLENTY = Action(
"Sell a complete skeleton to Mrs Plenty",
cost = Cost.ACTION.value
)
A_TENTACLED_SERVANT = Action(
"Sell him your amalgamous skeleton",
cost = Cost.ACTION.value
)
AN_INVESTMENT_MINDED_AMBASSADOR = Action(
"Sell your skeleton to the Ambassador",
cost = Cost.ACTION.value
)
A_TELLER_OF_TERRORS = Action(
"Sell your skeleton to the Teller of Terrors",
cost = Cost.ACTION.value
)
A_TENTACLED_ENTREPRENEUR = Action(
"Sell to the Tentacled Entrepreneur",
cost = Cost.ACTION.value
)
AN_AUTHOR_OF_GOTHIC_TALES = Action(
"Sell to an Author of Gothic Tales",
cost = Cost.ACTION.value
)
A_ZAILOR_WITH_PARTICULAR_INTERESTS = Action(
"Sell your skeleton to a Zailor",
cost = Cost.ACTION.value
)
A_RUBBERY_COLLECTOR = Action(
"Sell to an Enthusiast of a Rubbery Menace",
cost = Cost.ACTION.value
)
A_CONSTABLE = Action(
"Sell to a Constable",
cost = Cost.ACTION.value
)
AN_ENTHUSIAST_IN_SKULLS = Action(
"Sell to the Cranial Enthusiast",
cost = Cost.ACTION.value
)
A_DREARY_MIDNIGHTER = Action(
"Sell to the Dreary Midnighter",
cost = Cost.ACTION.value
)
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 = Action(
"Sell an amalgamous skeleton as a work of Bazaarine art",
cost = Cost.ACTION.value
)
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 = Action(
"Sell a menacing skeleton as a work of Nocturnal art",
cost = Cost.ACTION.value
)
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 = Action(
"Sell an antique skeleton as a work of Celestial art",
cost = Cost.ACTION.value
)
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 = Action(
"Sell him a tentacle-laden skeleton",
cost = Cost.ACTION.value
)
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 = Action(
"Sell to the Enterprising Boot Salesman",
cost = Cost.ACTION.value
)
Add Action values for buyers This will allow buyers to be variable rather than fixed, and increase the orthogonality of the code.
2021-06-13 19:58:51 +00:00
THE_DUMBWAITER_OF_BALMORAL = Action(
"Export the Skeleton of a Neathy Bird",
cost = Cost.ACTION.value
)
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_CARPENTERS_GRANDDAUGHTER = Action(
"Impress her with your own constructions",
cost = Cost.ACTION.value
)
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 = Action(
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
"Sell the Diplomat an antique skeleton",
cost = Cost.ACTION.value
)
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 = Action(
"Sell the Diplomat a fossil bird",
cost = Cost.ACTION.value
)
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 = Action(
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
"Sell the Diplomat a fossil fish",
cost = Cost.ACTION.value
)
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 = Action(
"Sell the Diplomat a fossil insect",
cost = Cost.ACTION.value
)
Add Action values for buyers This will allow buyers to be variable rather than fixed, and increase the orthogonality of the code.
2021-06-13 19:58:51 +00:00
def __str__(self):
return str(self.value)
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
class Fluctuation(Enum):
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
"""Which skeleton attribute is currently boosted."""
Initial commit
2021-06-08 22:28:15 +00:00
ANTIQUITY = 1
AMALGAMY = 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
MENACE = 3
Initial commit
2021-06-08 22:28:15 +00:00
Clean up imports Imports are now sorted lexicographically, and import specific declarations when appropriate.
2021-06-18 20:08:28 +00:00
class OccasionalBuyer(Enum):
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
"""Which of several unusual buyers are available."""
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
AN_ENTHUSIAST_IN_SKULLS = [Buyer.AN_ENTHUSIAST_IN_SKULLS]
Move constants out of data model The data model serves no clear purpose, and will be removed shortly.
2021-06-13 16:01:17 +00:00
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
A_DREARY_MIDNIGHTER = [Buyer.A_DREARY_MIDNIGHTER]
A_COLOURFUL_PHANTASIST = [
Buyer.A_COLOURFUL_PHANTASIST_BAZAARINE,
Buyer.A_COLOURFUL_PHANTASIST_NOCTURNAL,
Buyer.A_COLOURFUL_PHANTASIST_CELESTIAL,
]
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 = [Buyer.AN_INGENUOUS_MALACOLOGIST]
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 = [Buyer.AN_ENTERPRISING_BOOT_SALESMAN]
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
Define DiplomatFascination functionally Rather than laboriously replicating every fascination the Trifling Diplomat has, the script now exploits the consistent member names to generate the list automatically. This should not have any effect on usage, but will ease future maintainance.
2021-07-06 17:18:49 +00:00
DiplomatFascination = Enum(
'DiplomatFascination',
( (diplomat.name[22:], diplomat) for diplomat in Buyer
if diplomat.name.startswith('THE_TRIFLING_DIPLOMAT_') ),
module = __name__
)
DiplomatFascination.__doc__ = "The current fascination of the Trifling Diplomat."
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
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
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
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(), 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 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
amalgamy = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'amalgamy')
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(amalgamy == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.amalgamy for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Antiquity calculation
antiquity = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'antiquity')
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(antiquity == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.antiquity for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Menace calculation
menace = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'menace')
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(menace == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.menace for action in actions.keys()]))
Initial commit
2021-06-08 22:28:15 +00:00
# Implausibility calculation
implausibility = model.NewIntVar(cp_model.INT32_MIN, cp_model.INT32_MAX, 'implausibility')
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(implausibility == cp_model.LinearExpr.ScalProd(actions.values(), [action.value.implausibility for action in actions.keys()]))
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
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
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.AddGeneralMultiplicationEquality(add_joints_amber_cost, add_joints, 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])
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
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
multiplied_net_profit = model.NewIntVar(cp_model.INT32_MIN*PROFIT_MARGIN_MULTIPLIER, cp_model.INT32_MAX*PROFIT_MARGIN_MULTIPLIER, 'multiplied net profit')
model.AddMultiplicationEquality(multiplied_net_profit, [net_profit, PROFIT_MARGIN_MULTIPLIER])
absolute_multiplied_net_profit = model.NewIntVar(0, cp_model.INT32_MAX*PROFIT_MARGIN_MULTIPLIER, 'absolute multiplied net profit')
model.AddAbsEquality(absolute_multiplied_net_profit, multiplied_net_profit)
absolute_profit_margin = model.NewIntVar(cp_model.INT32_MIN*PROFIT_MARGIN_MULTIPLIER, cp_model.INT32_MAX*PROFIT_MARGIN_MULTIPLIER, 'absolute profit margin')
model.AddDivisionEquality(absolute_profit_margin, absolute_multiplied_net_profit, total_revenue)
profit_margin = model.NewIntVar(cp_model.INT32_MIN*PROFIT_MARGIN_MULTIPLIER, cp_model.INT32_MAX*PROFIT_MARGIN_MULTIPLIER, 'profit margin')
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)
Initial commit
2021-06-08 22:28:15 +00:00
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
class EnumAction(argparse.Action):
def __init__(self, **kwargs):
# Pop off the type value
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
enum = kwargs.pop('type', None)
nargs = kwargs.pop('nargs', None)
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
# Generate choices from the Enum
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
kwargs.setdefault('choices', tuple(member.name.lower() for member in enum))
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
super(EnumAction, self).__init__(**kwargs)
self._enum = enum
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
self._nargs = nargs
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
def __call__(self, parser, namespace, values, option_string=None):
# Convert value back into an Enum
enum = self._enum[values.upper()]
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
if self._nargs is None or self._nargs == '?':
setattr(namespace, self.dest, enum)
else:
items = getattr(namespace, self.dest, list())
items.append(enum)
setattr(namespace, self.dest, items)
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
def main():
Simplify and normalize argument parsing The script now uses dictionary unpacking to pass arguments, rather than explicitly listing each one. The parser now suppresses missing parameters by default. This means that the default values of the Solve function can be taken advantage, rather than having to repeat them for the parser's sake.
2021-06-25 22:11:43 +00:00
parser = argparse.ArgumentParser(
prog='Bone Market Solver',
description="Devise the optimal skeleton at the Bone Market in Fallen London.",
argument_default=argparse.SUPPRESS,
)
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
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
world_qualities = parser.add_argument_group(
"world qualities",
"Parameters shared across Fallen London, often changing on a routine basis"
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
)
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
world_qualities.add_argument(
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
"-f", "--bone-market-fluctuations",
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
action=EnumAction,
type=Fluctuation,
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
help="current value of Bone Market Fluctuations, which grants various bonuses to 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
dest='bone_market_fluctuations'
)
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
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
world_qualities.add_argument(
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
"-m", "--zoological-mania",
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
action=EnumAction,
type=Declaration,
Fix description of Zoological Mania option Not all declarations have a 10% bonus associated with them.
2021-06-25 23:40:39 +00:00
help="current value of Zoological Mania, which grants a percentage bonus to value for a certain declaration",
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
dest='zoological_mania'
)
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
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
world_qualities.add_argument(
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
"-o", "--occasional-buyer",
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
action=EnumAction,
type=OccasionalBuyer,
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
help="current value of Occasional Buyer, which allows access to a buyer that is not otherwise available",
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
dest='occasional_buyer'
)
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
world_qualities.add_argument(
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
"-d", "--diplomat-fascination",
action=EnumAction,
type=DiplomatFascination,
help="current value of The Diplomat's Current Fascination, which determines what the Trifling Diplomat is interested in",
dest='diplomat_fascination'
)
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
skeleton_parameters = parser.add_argument_group(
"skeleton parameters",
"Parameters that determine what you want the solver to produce"
)
skeleton_parameters.add_argument(
"-s", "--shadowy",
type=int,
required=True,
help="the effective level of Shadowy used for selling to buyers",
dest='shadowy_level'
)
skeleton_parameters.add_argument(
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
"-b", "--buyer", "--desired-buyer",
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
action=EnumAction,
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
nargs='+',
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
type=Buyer,
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
help="specific buyer that skeleton should be designed for (if declared repeatedly, will choose from among those provided)",
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
dest='desired_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
)
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
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
skeleton_parameters.add_argument(
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
"-c", "--cost", "--maximum-cost",
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
type=int,
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
help="maximum number of pennies that should be invested in skeleton",
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
dest='maximum_cost'
)
Fix whitespace
2021-06-19 12:33:46 +00:00
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
skeleton_parameters.add_argument(
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
"-e", "--exhaustion", "--maximum_exhaustion",
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
type=int,
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
help="maximum exhaustion that skeleton should generate",
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
dest='maximum_exhaustion'
)
Fix whitespace
2021-06-19 12:33:46 +00:00
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
solver_options = parser.add_argument_group(
"solver options",
"Options that affect how the solver behaves"
)
solver_options.add_argument(
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
"-v", "--verbose",
Remove arguments from verbosity flag '-v' and '--verbose' no longer accept an argument, optional or otherwise. Instead, they simply act as a flag. This dramatically simplifies the help text and implementation of the flags.
2021-07-11 18:07:27 +00:00
action='store_true',
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
default=False,
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
help="whether the solver should output search progress rather than showing intermediate solutions",
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
dest='verbose'
)
Fix whitespace
2021-06-19 12:33:46 +00:00
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
solver_options.add_argument(
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
"-t", "--time-limit",
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
type=float,
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
help="maximum number of seconds that the solver runs for",
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
dest='time_limit'
)
Fix whitespace
2021-06-19 12:33:46 +00:00
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
solver_options.add_argument(
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
"-w", "--workers",
type=int,
help="number of search worker threads to run in parallel (default: one worker per available CPU thread)",
dest='workers'
)
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
Reorganize command-line arguments All arguments are now enclosed in a single argument group to improve the generated help text. Due to how argparse works, this means that the script now allows redundant command-line arguments like specifying the occasional buyer and explicit buyers. The grammar of the help text has been made slightly more consistent.
2021-07-11 18:11:12 +00:00
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
args = parser.parse_args()
Simplify and normalize argument parsing The script now uses dictionary unpacking to pass arguments, rather than explicitly listing each one. The parser now suppresses missing parameters by default. This means that the default values of the Solve function can be taken advantage, rather than having to repeat them for the parser's sake.
2021-06-25 22:11:43 +00:00
arguments = vars(args)
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
Simplify and normalize argument parsing The script now uses dictionary unpacking to pass arguments, rather than explicitly listing each one. The parser now suppresses missing parameters by default. This means that the default values of the Solve function can be taken advantage, rather than having to repeat them for the parser's sake.
2021-06-25 22:11:43 +00:00
if not arguments.pop('verbose'):
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
def WrappedSolve(stdscr, arguments):
Fix crash due to terminal overflow The program will now scroll the screen when outputting intermediate solutions without sufficient space, rather than crashing.
2021-06-19 13:02:07 +00:00
# Prevents crash if window is too small to fit text
stdscr.scrollok(True)
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
# Move stdscr to last position
Simplify and normalize argument parsing The script now uses dictionary unpacking to pass arguments, rather than explicitly listing each one. The parser now suppresses missing parameters by default. This means that the default values of the Solve function can be taken advantage, rather than having to repeat them for the parser's sake.
2021-06-25 22:11:43 +00:00
arguments['stdscr'] = stdscr
return Solve(**arguments)
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
print(curses.wrapper(WrappedSolve, arguments))
else:
Simplify and normalize argument parsing The script now uses dictionary unpacking to pass arguments, rather than explicitly listing each one. The parser now suppresses missing parameters by default. This means that the default values of the Solve function can be taken advantage, rather than having to repeat them for the parser's sake.
2021-06-25 22:11:43 +00:00
print(Solve(**arguments))
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
Only run main() if program is run directly Checking that __name__ is "__main__" prevents main() from being run if this script is imported as a module.
2021-06-18 20:13:03 +00:00
if __name__ == '__main__':
main()