API Documentation

 21class RandomHcraftEnv(HcraftEnv):
 22    """Random HierarchyCraft Environment"""
 23
 24    def __init__(
 25        self,
 26        n_items_per_n_inputs: Optional[Dict[int, int]] = None,
 27        seed: int = None,
 28        **kwargs,
 29    ):
 30        """Random HierarchyCraft Environment.
 31
 32        Args:
 33            n_items_per_n_inputs: Mapping from the number of inputs to the number of items
 34                with this number of inputs.
 35            max_step: The maximum number of steps until done.
 36        """
 37        if n_items_per_n_inputs is None:
 38            n_items_per_n_inputs = {0: 5, 1: 5, 2: 10, 3: 5}
 39
 40        self.seed = seed
 41        self.np_random = np.random.RandomState(seed)
 42        self.n_items = sum(n_items_per_n_inputs.values())
 43        env_characteristics = "".join(
 44            [
 45                f"{n_inputs}I{n_items}"
 46                for n_inputs, n_items in n_items_per_n_inputs.items()
 47            ]
 48        )
 49        name = f"RandomCrafing-{env_characteristics}-S{seed}"
 50        self.items: List[Item] = []
 51        transformations = self._transformations(n_items_per_n_inputs)
 52        world = world_from_transformations(transformations)
 53        if "purpose" not in kwargs:
 54            purpose = Purpose()
 55            for item in self.items:
 56                purpose.add_task(GetItemTask(item))
 57            kwargs["purpose"] = purpose
 58        super().__init__(world, name=name, **kwargs)
 59
 60    def _transformations(
 61        self,
 62        n_items_per_n_inputs: Dict[int, int],
 63    ) -> List[Transformation]:
 64        """Build transformations for a RandomHcraft environement.
 65
 66        Args:
 67            n_items_per_n_inputs: Mapping from the number of inputs to the number of items
 68                with this number of inputs.
 69        Returns:
 70            A list of random (but accessible) transformations.
 71
 72        """
 73
 74        for n_inputs, n_items in n_items_per_n_inputs.items():
 75            self.items += [Item(f"{n_inputs}_{i}") for i in range(n_items)]
 76
 77        transformations = []
 78
 79        # Items with 0 inputs are accessible from the start
 80        accessible_items = []
 81        for item in self.items:
 82            if item.name.startswith("0"):
 83                search_item = Transformation(inventory_changes=[Yield(PLAYER, item)])
 84                transformations.append(search_item)
 85                accessible_items.append(item)
 86
 87        # Other items are built with inputs
 88        unaccessible_items = [
 89            item for item in self.items if item not in accessible_items
 90        ]
 91        self.np_random.shuffle(unaccessible_items)
 92
 93        while len(accessible_items) < len(self.items):
 94            new_accessible_item = unaccessible_items.pop()
 95            inventory_changes = [Yield(PLAYER, new_accessible_item)]
 96
 97            n_inputs = int(new_accessible_item.name.split("_")[0])
 98            n_inputs = min(n_inputs, len(accessible_items))
 99
100            # Chooses randomly accessible items
101            input_items = list(
102                self.np_random.choice(accessible_items, size=n_inputs, replace=False)
103            )
104            inventory_changes += [Use(PLAYER, item, consume=1) for item in input_items]
105
106            # Build recipe
107            new_recipe = Transformation(inventory_changes=inventory_changes)
108            transformations.append(new_recipe)
109            accessible_items.append(new_accessible_item)
110
111        return transformations