Skip to content

Description

Control Panel is used as an entry point to ECS storages and runner.

API

Meta

Source code in encosy/storage/meta.py 
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
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
65
66
67
68
69
70
71
72
73
class EntityStorageMeta(metaclass=ABCMeta):
    @abstractmethod
    def query(self, *args, **kwargs):
        """
        Query entities by any of given arguments

        Args:
            *args: positional
            **kwargs: keywords

        Returns:
            entities
        """
        pass

    @abstractmethod
    def add(self, entity):
        """
        Add entity by any condition

        Args:
            entity: any

        Returns:
            self

        """
        pass

    @abstractmethod
    def remove(self, entity):
        """
        Remove entity by any condition

        Args:
            entity: any

        Returns:
            self

        """
        pass

    @abstractmethod
    def get(self, *types):
        """
        Get entity by types of components

        Args:
            *types: components

        Returns:
            entities

        """
        pass

    @abstractmethod
    def query_expression(self, expression):
        """
        Query entities by expression

        Args:
            expression: any callable

        Returns:
            self

        """
        pass

add(entity) abstractmethod

Add entity by any condition

Parameters:

Name Type Description Default
entity

any

 required

Returns:

Type Description

self
Source code in encosy/storage/meta.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
@abstractmethod
def add(self, entity):
    """
    Add entity by any condition

    Args:
        entity: any

    Returns:
        self

    """
    pass

get(*types) abstractmethod

Get entity by types of components

Parameters:

Name Type Description Default
*types

components

 ()

Returns:

Type Description

entities
Source code in encosy/storage/meta.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
@abstractmethod
def get(self, *types):
    """
    Get entity by types of components

    Args:
        *types: components

    Returns:
        entities

    """
    pass

query(*args, **kwargs) abstractmethod

Query entities by any of given arguments

Parameters:

Name Type Description Default
*args

positional

 ()
**kwargs

keywords

 {}

Returns:

Type Description

entities
Source code in encosy/storage/meta.py 
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
@abstractmethod
def query(self, *args, **kwargs):
    """
    Query entities by any of given arguments

    Args:
        *args: positional
        **kwargs: keywords

    Returns:
        entities
    """
    pass

query_expression(expression) abstractmethod

Query entities by expression

Parameters:

Name Type Description Default
expression

any callable

 required

Returns:

Type Description

self
Source code in encosy/storage/meta.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
@abstractmethod
def query_expression(self, expression):
    """
    Query entities by expression

    Args:
        expression: any callable

    Returns:
        self

    """
    pass

remove(entity) abstractmethod

Remove entity by any condition

Parameters:

Name Type Description Default
entity

any

 required

Returns:

Type Description

self
Source code in encosy/storage/meta.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
@abstractmethod
def remove(self, entity):
    """
    Remove entity by any condition

    Args:
        entity: any

    Returns:
        self

    """
    pass

EntityStorage

SimpleEntityStorage

Bases: EntityStorageMeta

Source code in encosy/storage/entity_storage.py 
 7
 8
 9
10
11
12
13
14
15
16
17
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
class SimpleEntityStorage(EntityStorageMeta):
    def __init__(self):
        self.idx = 0
        self.entities: dict[int, Entity] = {}

    def add(self, entity: Entity) -> 'SimpleEntityStorage':
        """
        Add entity to storage
        Args:
            entity: Any Entity with Any component

        Returns:
            self

        """
        self.idx += 1
        self.entities[self.idx] = entity
        return self

    def remove(self, entity: Entity) -> 'SimpleEntityStorage':
        """
        Remove entity from storage works iteratively

        Args:
            entity: works by comparison of existing entity and new

        Returns:
            self

        """
        key_to_del = 0
        for key, entity_to_del in self.entities.items():
            if entity_to_del == entity:
                key_to_del = key
                break
        if key_to_del:
            self.entities.pop(key_to_del)
        return self

    def query(self, *args, **kwargs):
        pass

    def get(self, *types: type) -> Entities[Any]:
        """
        Query entities by component types

        Args:
            *types: types of components

        Returns:
            entities with given components

        """
        entities: Entities[Any] = Entities()
        components = set(types)
        for entity in self.entities.values():
            if components <= entity.keys():
                entities.append(entity)
        return entities

    def query_expression(self, expression: Callable[[Entity], Any]) -> Entities[Any]:
        """
        Query entities by expression

        Args:
            expression: expression of type (Entity) -> True or False

        Returns:
            entities
        """
        entities: Entities[Any] = Entities()
        for entity in self.entities.values():
            try:
                if expression(entity):
                    entities.append(entity)
            except KeyError:
                continue
        return entities

    def __len__(self):
        return len(self.entities)

add(entity)

Add entity to storage

Parameters:

Name Type Description Default
entity Entity

Any Entity with Any component

 required

Returns:

Type Description
SimpleEntityStorage

self
Source code in encosy/storage/entity_storage.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
def add(self, entity: Entity) -> 'SimpleEntityStorage':
    """
    Add entity to storage
    Args:
        entity: Any Entity with Any component

    Returns:
        self

    """
    self.idx += 1
    self.entities[self.idx] = entity
    return self

get(*types)

Query entities by component types

Parameters:

Name Type Description Default
*types type

types of components

 ()

Returns:

Type Description
Entities[Any]

entities with given components
Source code in encosy/storage/entity_storage.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def get(self, *types: type) -> Entities[Any]:
    """
    Query entities by component types

    Args:
        *types: types of components

    Returns:
        entities with given components

    """
    entities: Entities[Any] = Entities()
    components = set(types)
    for entity in self.entities.values():
        if components <= entity.keys():
            entities.append(entity)
    return entities

query_expression(expression)

Query entities by expression

Parameters:

Name Type Description Default
expression Callable[[Entity], Any]

expression of type (Entity) -> True or False

 required

Returns:

Type Description
Entities[Any]

entities
Source code in encosy/storage/entity_storage.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
def query_expression(self, expression: Callable[[Entity], Any]) -> Entities[Any]:
    """
    Query entities by expression

    Args:
        expression: expression of type (Entity) -> True or False

    Returns:
        entities
    """
    entities: Entities[Any] = Entities()
    for entity in self.entities.values():
        try:
            if expression(entity):
                entities.append(entity)
        except KeyError:
            continue
    return entities

remove(entity)

Remove entity from storage works iteratively

Parameters:

Name Type Description Default
entity Entity

works by comparison of existing entity and new

 required

Returns:

Type Description
SimpleEntityStorage

self
Source code in encosy/storage/entity_storage.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def remove(self, entity: Entity) -> 'SimpleEntityStorage':
    """
    Remove entity from storage works iteratively

    Args:
        entity: works by comparison of existing entity and new

    Returns:
        self

    """
    key_to_del = 0
    for key, entity_to_del in self.entities.items():
        if entity_to_del == entity:
            key_to_del = key
            break
    if key_to_del:
        self.entities.pop(key_to_del)
    return self