def test_assign_pickup_to_starting_items(empty_patches, state_game_data):
# Setup
starting = state.State({}, (), 99, None, empty_patches, None,
state_game_data)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry(
"A",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=((resource_a, 5), ),
extra_resources=((state_game_data.resource_database.item_percentage,
1), ),
unlocks_resource=True,
resource_lock=ResourceLock(resource_a, resource_a, resource_b),
)
# Run
final = starting.assign_pickup_to_starting_items(p)
# Assert
assert final.patches.starting_items == {resource_a: 5, resource_b: 0}
assert final.resources == {resource_a: 5, resource_b: 0}
def test_add_pickup_to_state(state_game_data, empty_patches,
generic_item_category):
# Starting State
s = state.State({}, (), 99, None, empty_patches, None, state_game_data)
resource_a = ItemResourceInfo("A", "A", 10)
resource_b = ItemResourceInfo("B", "B", 10)
p = PickupEntry("B",
2,
generic_item_category,
generic_item_category,
progression=(
(resource_a, 1),
(resource_b, 1),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
def test_collected_pickup_indices(state_game_data, empty_patches):
# Setup
db = state_game_data.resource_database
starting = state_game_data.world_list.resolve_teleporter_connection(
empty_patches.game.starting_location)
pickup_nodes = [
node for node in empty_patches.game.world_list.all_nodes
if isinstance(node, PickupNode)
]
context = NodeContext(
empty_patches,
ResourceCollection(),
empty_patches.game.resource_database,
empty_patches.game.world_list,
)
resources = ResourceCollection.from_dict(
db, {
db.item[0]: 5,
pickup_nodes[0].resource(context): 1,
pickup_nodes[1].resource(context): 1
})
s = state.State(resources, (), 99, starting, empty_patches, None,
state_game_data)
# Run
indices = list(s.collected_pickup_indices)
# Assert
assert indices == [
pickup_nodes[0].pickup_index, pickup_nodes[1].pickup_index
]
def test_add_pickup_to_state(state_game_data, empty_patches,
generic_item_category):
# Starting State
db = state_game_data.resource_database
starting_node = state_game_data.world_list.resolve_teleporter_connection(
empty_patches.game.starting_location)
s = state.State(ResourceCollection(), (), 99, starting_node, empty_patches,
None, state_game_data)
resource_a = db.item[0]
resource_b = db.item[1]
p = PickupEntry("B",
2,
generic_item_category,
generic_item_category,
progression=(
(resource_a, 1),
(resource_b, 1),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == ResourceCollection.from_dict(db, {
resource_a: 1,
resource_b: 1,
})
def test_collected_pickup_indices(database, patches):
# Setup
resources = {
ItemResourceInfo(1, "A", "A", 50, None): 5,
PickupIndex(1): 1,
PickupIndex(15): 1
}
s = state.State(resources, (), 99, None, patches, None, database, None)
# Run
indices = list(s.collected_pickup_indices)
# Assert
assert indices == [PickupIndex(1), PickupIndex(15)]
def test_state_with_pickup(database, patches):
# Setup
starting = state.State({}, (), 99, None, patches, None, database, None)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
p = PickupEntry("A", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT,
(ConditionalResources(None, None, ((resource_a, 1), )), ))
# Run
final = state.state_with_pickup(starting, p)
# Assert
assert final.previous_state is starting
assert final.resources == {resource_a: 1}
def test_collected_pickup_indices(database):
# Setup
resources = {
SimpleResourceInfo(1, "A", "A", ResourceType.ITEM): 5,
PickupIndex(1): 1,
PickupIndex(15): 1
}
s = state.State(resources, (), 99, None, None, None, database)
# Run
indices = list(s.collected_pickup_indices)
# Assert
assert indices == [PickupIndex(1), PickupIndex(15)]
def test_state_with_pickup(database):
# Setup
starting = state.State({}, (), 99, None, None, None, database)
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
p = PickupEntry("A", 2, ItemCategory.SUIT,
(ConditionalResources(None, None, ((resource_a, 1), )), ))
# Run
final = state.state_with_pickup(starting, p)
# Assert
assert final.previous_state is starting
assert final.resources == {resource_a: 1}
def test_collected_pickup_indices(state_game_data, empty_patches):
# Setup
resources = {
ItemResourceInfo("A", "A", 50, None): 5,
PickupIndex(1): 1,
PickupIndex(15): 1
}
s = state.State(resources, (), 99, None, empty_patches, None,
state_game_data)
# Run
indices = list(s.collected_pickup_indices)
# Assert
assert indices == [PickupIndex(1), PickupIndex(15)]
def test_state_with_pickup(state_game_data, empty_patches):
# Setup
starting = state.State({}, (), 99, None, empty_patches, None,
state_game_data)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
p = PickupEntry("A",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=((resource_a, 1), ))
# Run
final = state.state_with_pickup(starting, p)
# Assert
assert final.previous_state is starting
assert final.resources == {resource_a: 1}
def test_add_pickup_to_state(database):
# Starting State
s = state.State({}, (), 99, None, None, None, database)
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
resource_b = SimpleResourceInfo(2, "B", "B", ResourceType.ITEM)
p = PickupEntry("B", 2, ItemCategory.SUIT, (
ConditionalResources(None, None, ((resource_a, 1), )),
ConditionalResources(None, resource_a, ((resource_b, 1), )),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
def test_add_pickup_to_state(database, patches):
# Starting State
s = state.State({}, (), 99, None, patches, None, database, None)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry("B", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT, (
ConditionalResources(None, None, ((resource_a, 1), )),
ConditionalResources(None, resource_a, ((resource_b, 1), )),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
def test_state_with_pickup(state_game_data, empty_patches,
generic_item_category):
# Setup
db = state_game_data.resource_database
starting = state.State(ResourceCollection(), (), 99, None, empty_patches,
None, state_game_data)
resource_a = db.item[0]
p = PickupEntry("A",
2,
generic_item_category,
generic_item_category,
progression=((resource_a, 1), ))
# Run
final = state.state_with_pickup(starting, p)
# Assert
assert final.previous_state is starting
assert final.resources == ResourceCollection.from_dict(db, {resource_a: 1})
def test_assign_pickup_to_index(collected: bool, empty_patches, database):
# Setup
starting_resources = {}
index = PickupIndex(1)
if collected:
starting_resources[index] = 1
starting = state.State(starting_resources, (), 99, None, empty_patches,
None, database)
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
p = PickupEntry("A", 2, ItemCategory.SUIT,
(ConditionalResources(None, None, ((resource_a, 1), )), ))
# Run
final = starting.assign_pickup_to_index(p, index)
# Assert
assert final.patches.pickup_assignment == {index: p}
if collected:
assert final.resources == {index: 1, resource_a: 1}
else:
assert final.resources == {}
def test_assign_pickup_to_starting_items(empty_patches, database):
# Setup
starting = state.State({}, (), 99, None, empty_patches, None, database)
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
resource_b = SimpleResourceInfo(2, "B", "B", ResourceType.ITEM)
p = PickupEntry("A",
2,
ItemCategory.SUIT,
resources=(ConditionalResources(None, None, (
(resource_a, 5),
(database.item_percentage, 1),
)), ),
convert_resources=(ResourceConversion(
resource_b, resource_a), ))
# Run
final = starting.assign_pickup_to_starting_items(p)
# Assert
assert final.patches.starting_items == {resource_a: 5, resource_b: 0}
assert final.resources == {resource_a: 5, resource_b: 0}
def test_assign_pickup_to_starting_items(empty_patches, state_game_data,
generic_item_category):
# Setup
db = state_game_data.resource_database
starting_node = state_game_data.world_list.resolve_teleporter_connection(
empty_patches.game.starting_location)
starting = state.State(ResourceCollection(), (), 99, starting_node,
empty_patches, None, state_game_data)
resource_a = db.get_item("Ammo")
resource_b = db.item[0]
p = PickupEntry(
"A",
2,
generic_item_category,
generic_item_category,
progression=((resource_a, 5), ),
extra_resources=(),
unlocks_resource=True,
resource_lock=ResourceLock(resource_a, resource_a, resource_b),
)
# Run
final = starting.assign_pickup_to_starting_items(p)
# Assert
assert final.patches.starting_items == ResourceCollection.from_dict(
db, {
resource_a: 5,
resource_b: 0
})
assert final.resources == ResourceCollection.from_dict(
db, {
resource_a: 5,
resource_b: 0
})
def test_add_pickup_to_state(state_game_data, empty_patches):
# Starting State
s = state.State({}, (), 99, None, empty_patches, None, state_game_data)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry("B",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=(
(resource_a, 1),
(resource_b, 1),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
