예제 #1
0
    def test_to_items(self) -> None:
        inv = inventory.Inventory()
        inv.store(
            defs.Hand.LEFT,
            id=1,
            essence=craft.Essence.ROCKS,
            current_quantity=1,
            item_volume=1,
            codename='',
        )
        inv.store(
            defs.Hand.RIGHT,
            id=2,
            essence=craft.Essence.LOGS,
            current_quantity=2,
            item_volume=1,
            codename='',
        )

        expected = {
            craft.Item(actor_id=1, essence=craft.Essence.ROCKS, quantity=1),
            craft.Item(actor_id=2, essence=craft.Essence.LOGS, quantity=2),
        }

        result = inv.to_items()
        self.assertEqual(result, expected)
예제 #2
0
    def test_assembly_filter_items(self) -> None:
        """Checks if filtering works correctly. Quantities of items in the filtered list should be
        reduced by quantities of corresponding items/entities in the assembly. If the new quantity
        is zero, the item should be removed."""

        assembly = craft.Assembly(
            recipe_codename='test_recipe',
            sources=[
                [craft.Item(0, craft.Essence.ROCKS, 2), craft.Item(4, craft.Essence.ROCKS, 3)],
                [craft.Item(3, craft.Essence.STICKS, 3), craft.Item(1, craft.Essence.LOGS, 2)],
            ],
        )

        input_items = {
            craft.Item(0, craft.Essence.ROCKS, 3),
            craft.Item(1, craft.Essence.LOGS, 2),
            craft.Item(2, craft.Essence.GOLD, 2),
        }

        expected_items = {
            craft.Item(0, craft.Essence.ROCKS, 1),
            craft.Item(2, craft.Essence.GOLD, 2),
        }

        result_items = assembly.filter_items(input_items)
        self.assertEqual(result_items, expected_items)
예제 #3
0
    def test_craft(self) -> None:
        """
        Checks if crafting a item (axe) works correctly:
         * items used fully should be removed
         * not used items should not be touched
         * inventory should be updated
        """

        NUM_ROCK, NUM_GOLD, NUM_LOGS = 2, 2, 1

        elevation_function = geometry.ElevationFunction(1000)
        rock = entities.Rocks(1, None)
        gold = entities.Gold(2, None)
        logs = entities.Log(3, None)
        assert rock.features.stackable is not None
        assert gold.features.stackable is not None
        rock.features.stackable.set_size(NUM_ROCK)
        gold.features.stackable.set_size(NUM_GOLD)
        entity_list: List[essentials.Entity] = [rock, gold, logs]

        inv = inventory.Inventory()
        inv.insert_entry(1, rock.as_info())
        inv.insert_entry(2, gold.as_info())
        inv.insert_entry(3, logs.as_info())

        st = state.State(elevation_function, entity_list)

        assembly = craft.Assembly(
            recipe_codename='axe',
            sources=[[rock.as_craft_item()], [logs.as_craft_item()]],
        )

        result = st.craft_entity(assembly, inv)

        self.assertEqual(len(result.created), 1)
        self.assertEqual(set(result.deleted), {logs.id, rock.id})
        ents = list(st.get_entities())
        self.assertEqual(len(ents), 2)
        self.assertEqual(ents[0], gold)
        self.assertEqual(ents[1].get_name(), 'axe')

        axe = ents[1]

        result_items = inv.to_items()
        expected_items = {
            craft.Item(actor_id=gold.id,
                       essence=gold.ESSENCE,
                       quantity=NUM_GOLD),
            craft.Item(actor_id=axe.id, essence=axe.ESSENCE, quantity=1),
        }
        self.assertEqual(result_items, expected_items)
예제 #4
0
    def test_assembly_find_item(self) -> None:
        """Checks if items lookup in `Assembly` works correctly."""

        rocks1 = craft.Item(0, craft.Essence.ROCKS, 2)
        rocks2 = craft.Item(4, craft.Essence.ROCKS, 3)
        sticks = craft.Item(3, craft.Essence.STICKS, 3)
        logs = craft.Item(1, craft.Essence.LOGS, 2)

        assembly = craft.Assembly(
            recipe_codename='test_recipe',
            sources=[[rocks1, rocks2], [sticks, logs]],
        )

        self.assertEqual(assembly.find_item(3, None), sticks)
        self.assertEqual(assembly.find_item(3, 0), None)
        self.assertEqual(assembly.find_item(5, None), None)
예제 #5
0
    def test_ingredient_filter_items(self) -> None:
        """Checks if filtering works correctly. Filtered list should contain only items compatible
        with the given ingredient/material."""

        ingredient = craft.Ingredient(craft.Material.WOOD, 1)

        input_items = {
            craft.Item(0, craft.Essence.ROCKS, 1),
            craft.Item(1, craft.Essence.LOGS, 1),
        }

        expected_items = {
            craft.Item(1, craft.Essence.LOGS, 1),
        }

        result_items = ingredient.filter_items(input_items)
        self.assertEqual(result_items, expected_items)
예제 #6
0
    def test_assembly_update_item(self) -> None:
        """Updating the assembly items should work correctly."""

        assembly = craft.Assembly(
            recipe_codename='test_recipe',
            sources=[[
                craft.Item(1, craft.Essence.GOLD, 3),
                craft.Item(2, craft.Essence.LOGS, 3),
                craft.Item(3, craft.Essence.STICKS, 3),
            ], []],
        )

        expected = craft.Assembly(
            recipe_codename='test_recipe',
            sources=[[
                craft.Item(1, craft.Essence.GOLD, 2),
                craft.Item(2, craft.Essence.LOGS, 5),
                craft.Item(3, craft.Essence.STICKS, 3),
                craft.Item(4, craft.Essence.ROCKS, 2),
            ], []],
        )

        # Negative change on not existing item is a noop
        self.assertFalse(assembly.update_item(1, craft.Item(3, craft.Essence.STICKS, 0), -1))

        # Removing too many existing items is a noop
        self.assertFalse(assembly.update_item(0, craft.Item(3, craft.Essence.STICKS, 0), -5))

        # Increasing quantity of not existing items should create them
        self.assertTrue(assembly.update_item(0, craft.Item(4, craft.Essence.ROCKS, 0), 2))

        # Increasing quantity of existing items should work correctly
        self.assertTrue(assembly.update_item(0, craft.Item(2, craft.Essence.LOGS, 0), 2))

        # Increasing quantity of existing items should work correctly
        self.assertTrue(assembly.update_item(0, craft.Item(1, craft.Essence.GOLD, 0), -1))

        self.assertEqual(assembly, expected)