def test_first_constraint():
# v U D
# 0 0 0
# 1 x 1
# 2 1-2
# 3 2 3
# 4 3
manager = ConstraintManager({RomVariant.USA, RomVariant.DEMO})
constraint = Constraint()
constraint.romA = RomVariant.USA
constraint.addressA = 1
constraint.romB = RomVariant.DEMO
constraint.addressB = 2
manager.add_constraint(constraint)
manager.rebuild_relations()
assert_same_address(manager, RomVariant.USA, 0)
assert_same_address(manager, RomVariant.DEMO, 0)
assert_same_address(manager, RomVariant.DEMO, 1)
assert_same_address(manager, RomVariant.DEMO, 2)
assert_same_address(manager, RomVariant.DEMO, 3)
assert_same_address(manager, RomVariant.DEMO, 0xffffff)
assert_differing_address(manager, RomVariant.USA, 1, 2)
assert_differing_address(manager, RomVariant.USA, 2, 3)
assert_differing_address(manager, RomVariant.USA, 0xffffff, 0xffffff + 1)
print('---')
assert -1 == manager.to_local(RomVariant.USA, 1)
def add_u_d_constraint(manager: ConstraintManager, usa_address: int,
demo_address: int):
constraint = Constraint()
constraint.romA = RomVariant.USA
constraint.addressA = usa_address
constraint.romB = RomVariant.DEMO
constraint.addressB = demo_address
manager.add_constraint(constraint)
def add_e_d_constraint(manager: ConstraintManager, eu_address: int,
demo_address: int):
constraint = Constraint()
constraint.romA = RomVariant.EU
constraint.addressA = eu_address
constraint.romB = RomVariant.DEMO
constraint.addressB = demo_address
manager.add_constraint(constraint)
def add_u_e_constraint(manager: ConstraintManager, usa_address: int,
eu_address: int):
constraint = Constraint()
constraint.romA = RomVariant.USA
constraint.addressA = usa_address
constraint.romB = RomVariant.EU
constraint.addressB = eu_address
manager.add_constraint(constraint)
def add_u_j_constraint(manager: ConstraintManager, usa_address: int,
jp_address: int):
constraint = Constraint()
constraint.romA = RomVariant.USA
constraint.addressA = usa_address
constraint.romB = RomVariant.JP
constraint.addressB = jp_address
manager.add_constraint(constraint)
def add_j_e_constraint(manager: ConstraintManager, jp_address: int,
eu_address: int):
constraint = Constraint()
constraint.romA = RomVariant.JP
constraint.addressA = jp_address
constraint.romB = RomVariant.EU
constraint.addressB = eu_address
manager.add_constraint(constraint)
def add_j_d_constraint(manager: ConstraintManager, jp_address: int,
demo_address: int):
constraint = Constraint()
constraint.romA = RomVariant.JP
constraint.addressA = jp_address
constraint.romB = RomVariant.DEMO
constraint.addressB = demo_address
manager.add_constraint(constraint)
def test_many_small_differences():
# v U J E D
# 0 0 0 0 0
# 1 1 x
# 2 2 x
# 3 3--1 3
# 4 4 2 x
# 5 5 3 5--4-
# 6 x x 6
# 7 x 4--7
# 8 x 5 8
# 9 6--6 x 8
# 10 x 7 x x
# 11 7--8--9--9 # constraints from J to all
# 12 8 9 x 10
# 13 9 10 10-11
# 14 x 11-11 x
# 15 10-12 12 x
# 16 11 13 13-12
manager = ConstraintManager(
{RomVariant.USA, RomVariant.JP, RomVariant.EU, RomVariant.DEMO})
add_u_d_constraint(manager, 5, 4)
add_u_j_constraint(manager, 10, 12)
add_u_j_constraint(manager, 3, 1)
manager.add_constraint(Constraint(RomVariant.JP, 8, RomVariant.DEMO, 9))
add_j_e_constraint(manager, 4, 7)
add_u_j_constraint(manager, 6, 6)
add_j_e_constraint(manager, 8, 9)
add_j_e_constraint(manager, 11, 11)
add_e_d_constraint(manager, 13, 12)
add_e_d_constraint(manager, 5, 4)
add_u_j_constraint(manager, 7, 8)
add_e_d_constraint(manager, 10, 11)
manager.rebuild_relations()
manager.print_relations()
assert_u_j_e_d_address(manager, 0, 0, 0, 0, 0)
assert_u_j_e_d_address(manager, 1, 1, -1, 1, 1)
assert_u_j_e_d_address(manager, 2, 2, -1, 2, 2)
assert_u_j_e_d_address(manager, 3, 3, 1, 3, 3)
assert_u_j_e_d_address(manager, 4, 4, 2, 4, -1)
assert_u_j_e_d_address(manager, 5, 5, 3, 5, 4)
assert_u_j_e_d_address(manager, 6, -1, -1, 6, 5)
assert_u_j_e_d_address(manager, 7, -1, 4, 7, 6)
assert_u_j_e_d_address(manager, 8, -1, 5, 8, 7)
assert_u_j_e_d_address(manager, 9, 6, 6, -1, 8)
assert_u_j_e_d_address(manager, 10, -1, 7, -1, -1)
assert_u_j_e_d_address(manager, 11, 7, 8, 9, 9)
assert_u_j_e_d_address(manager, 12, 8, 9, -1, 10)
assert_u_j_e_d_address(manager, 13, 9, 10, 10, 11)
assert_u_j_e_d_address(manager, 14, -1, 11, 11, -1)
assert_u_j_e_d_address(manager, 15, 10, 12, 12, -1)
assert_u_j_e_d_address(manager, 16, 11, 13, 13, 12)
def add_new_constraint(self, constraint: Constraint) -> None:
# Check that constraint is valid
constraint_manager = ConstraintManager({RomVariant.USA, RomVariant.DEMO, RomVariant.EU, RomVariant.JP, RomVariant.DEMO_JP, RomVariant.CUSTOM, RomVariant.CUSTOM_EU, RomVariant.CUSTOM_JP, RomVariant.CUSTOM_DEMO_USA, RomVariant.CUSTOM_DEMO_JP})
constraint_manager.add_all_constraints(
get_constraint_database().get_constraints())
try:
constraint_manager.add_constraint(constraint)
constraint_manager.rebuild_relations()
except InvalidConstraintError as e:
QMessageBox.critical(self.parent(), 'Add constraint', 'Invalid Constraint')
return
get_constraint_database().add_constraint(constraint)
def test_longer_constraint():
# v E J
# 0 0 0
# 1 x 1
# ... ... ...
# 100 1---100
# 101 2 101
manager = ConstraintManager({RomVariant.EU, RomVariant.JP})
constraint = Constraint()
constraint.romA = RomVariant.JP
constraint.addressA = 100
constraint.romB = RomVariant.EU
constraint.addressB = 1
manager.add_constraint(constraint)
manager.rebuild_relations()
assert_same_address(manager, RomVariant.EU, 0)
assert_same_address(manager, RomVariant.JP, 0)
assert_same_address(manager, RomVariant.JP, 100)
assert_same_address(manager, RomVariant.JP, 5000)
assert -1 == manager.to_local(RomVariant.EU, 1)
assert_differing_address(manager, RomVariant.EU, 1, 100)
assert_differing_address(manager, RomVariant.EU, 100, 199)
def process(self) -> None:
print('Start processing')
progress = 0
# Test using a constraint manager with all variations
manager = ConstraintManager({
RomVariant.USA, RomVariant.JP, RomVariant.EU, RomVariant.DEMO,
RomVariant.DEMO_JP
})
constraint_database = get_constraint_database()
constraints = constraint_database.get_constraints()
i = 0
count = len(constraints)
for constraint in constraints:
if not constraint.enabled:
i = i + 1
continue
# test if constraint is redundant
va_a = manager.to_virtual(constraint.romA, constraint.addressA)
va_b = manager.to_virtual(constraint.romB, constraint.addressB)
if va_a == va_b:
print(f'Disable {constraint}')
constraint.enabled = False
else:
#print(f'Keep {constraint}')
manager.add_constraint(constraint)
try:
manager.rebuild_relations()
except InvalidConstraintError as e:
print(e)
print(constraint)
self.signal_fail.emit()
return
i = i + 1
new_progress = (i * 50) // count
if new_progress != progress:
progress = new_progress
self.signal_progress.emit(new_progress)
self.signal_progress.emit(50)
i = 0
# Test that there are no disabled constraints that are still needed
for constraint in constraints:
if constraint.enabled:
i = i + 1
continue
# test if constraint is redundant
va_a = manager.to_virtual(constraint.romA, constraint.addressA)
va_b = manager.to_virtual(constraint.romB, constraint.addressB)
if va_a != va_b:
print(f'Need to reenable {constraint}')
constraint.enabled = True
manager.add_constraint(constraint)
try:
manager.rebuild_relations()
except InvalidConstraintError as e:
print(e)
print(constraint)
self.signal_fail.emit()
return
i = i + 1
new_progress = (i * 50) // count + 50
if new_progress != progress:
progress = new_progress
self.signal_progress.emit(new_progress)
constraint_database._write_constraints(
) # TODO add a public method to update changed constraints in the database?
constraint_database.constraints_changed.emit()
self.signal_done.emit()
