Skip to content

color

Generates Features for things that aren't like their neighbors

Color

Bases: FeatureExtractor[Point]

A component for simulating the color of features based on the character value.

Source code in roc/feature_extractors/color.py 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
@register_component("color", "perception")
class Color(FeatureExtractor[Point]):
    """A component for simulating the color of features based on the character
    value.
    """

    def __init__(self) -> None:
        super().__init__()
        self.queue: list[SingleFeature] = list()
        self.vd: VisionData | None = None
        self.single_settled = False

    def event_filter(self, e: PerceptionEvent) -> bool:
        """Filters out non-SingleFeatures and non-VisionData

        Args:
            e (PerceptionEvent): Any event on the perception bus

        Returns:
            bool: Returns True if the event is a SingleFeature or VisionData to
            keep processing it, False otherwise.
        """
        return isinstance(e.data, VisionData) or e.src_id.name == "single"

    def get_feature(self, e: PerceptionEvent) -> None:
        """Emits the color features.

        Args:
            e (PerceptionEvent): The VisionData or SingleFeature

        Returns:
            Feature | None: None
        """
        if isinstance(e.data, SingleFeature):
            self.queue.append(e.data)
            return None

        if isinstance(e.data, Settled):
            self.single_settled = True

        if isinstance(e.data, VisionData):
            self.vd = e.data

        if self.single_settled and self.vd is not None:
            for s in self.queue:
                x, y = s.point
                self.pb_conn.send(
                    ColorFeature(
                        origin_id=self.id,
                        point=(x, y),
                        type=self.vd.colors[y, x],
                    )
                )

            self.settled()
            self.queue.clear()
            self.single_settled = False
            self.vd = None

        return None

queue = list() instance-attribute

single_settled = False instance-attribute

vd = None instance-attribute

__init__()

Source code in roc/feature_extractors/color.py 
105
106
107
108
109
def __init__(self) -> None:
    super().__init__()
    self.queue: list[SingleFeature] = list()
    self.vd: VisionData | None = None
    self.single_settled = False

event_filter(e)

Filters out non-SingleFeatures and non-VisionData

Parameters:

Name Type Description Default
e PerceptionEvent

Any event on the perception bus

 required

Returns:

Name Type Description
bool bool

Returns True if the event is a SingleFeature or VisionData to
bool

keep processing it, False otherwise.
Source code in roc/feature_extractors/color.py 
111
112
113
114
115
116
117
118
119
120
121
def event_filter(self, e: PerceptionEvent) -> bool:
    """Filters out non-SingleFeatures and non-VisionData

    Args:
        e (PerceptionEvent): Any event on the perception bus

    Returns:
        bool: Returns True if the event is a SingleFeature or VisionData to
        keep processing it, False otherwise.
    """
    return isinstance(e.data, VisionData) or e.src_id.name == "single"

get_feature(e)

Emits the color features.

Parameters:

Name Type Description Default
e PerceptionEvent

The VisionData or SingleFeature

 required

Returns:

Type Description
None

Feature | None: None
Source code in roc/feature_extractors/color.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
def get_feature(self, e: PerceptionEvent) -> None:
    """Emits the color features.

    Args:
        e (PerceptionEvent): The VisionData or SingleFeature

    Returns:
        Feature | None: None
    """
    if isinstance(e.data, SingleFeature):
        self.queue.append(e.data)
        return None

    if isinstance(e.data, Settled):
        self.single_settled = True

    if isinstance(e.data, VisionData):
        self.vd = e.data

    if self.single_settled and self.vd is not None:
        for s in self.queue:
            x, y = s.point
            self.pb_conn.send(
                ColorFeature(
                    origin_id=self.id,
                    point=(x, y),
                    type=self.vd.colors[y, x],
                )
            )

        self.settled()
        self.queue.clear()
        self.single_settled = False
        self.vd = None

    return None

ColorFeature dataclass

Bases: PointFeature[ColorNode]

The color of a single feature.

Source code in roc/feature_extractors/color.py 
86
87
88
89
90
91
92
93
94
95
96
@dataclass(kw_only=True)
class ColorFeature(PointFeature[ColorNode]):
    """The color of a single feature."""

    feature_name: str = "Color"

    def _create_nodes(self) -> ColorNode:
        return ColorNode(type=self.type)

    def _dbfetch_nodes(self) -> ColorNode | None:
        return ColorNode.find_one("src.type = $type", params={"type": self.type})

feature_name = 'Color' class-attribute instance-attribute

__init__(*, feature_name='Color')

ColorNode

Bases: FeatureNode

Source code in roc/feature_extractors/color.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
class ColorNode(FeatureNode):
    type: int

    @property
    def attr_strs(self) -> list[str]:
        color: str

        # https://github.com/NetHack/NetHack/blob/8bb764e624aa228ce2a5374739408ed81b77d40e/include/color.h#L14
        match self.type:
            case 0:
                color = "BLACK"
            case 1:
                color = "RED"
            case 2:
                color = "GREEN"
            case 3:
                color = "BROWN"
            case 4:
                color = "BLUE"
            case 5:
                color = "MAGENTA"
            case 6:
                color = "CYAN"
            case 7:
                color = "GREY"
            case 8:
                color = "NO COLOR"
            case 9:
                color = "ORANGE"
            case 10:
                color = "BRIGHT GREEN"
            case 11:
                color = "YELLOW"
            case 12:
                color = "BRIGHT BLUE"
            case 13:
                color = "BRIGHT MAGENTA"
            case 14:
                color = "BRIGHT CYAN"
            case 15:
                color = "WHITE"
            case 16:
                color = "MAX"
            case _:
                raise Exception("impossible color")

        return [color]

attr_strs property

type instance-attribute