mxbiflow 0.1.1__tar.gz

mxbiflow-0.1.1/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.3
+Name: mxbiflow
+Version: 0.1.1
+Summary: mxbiflow is a toolkit based on pygame and pymxbi
+Author: HuYang
+Author-email: HuYang <huyangcommit@gmail.com>
+Requires-Dist: gpiozero>=2.0.1
+Requires-Dist: inflection>=0.5.1
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: matplotlib>=3.10.6
+Requires-Dist: mss>=10.1.0
+Requires-Dist: numpy>=2.3.3
+Requires-Dist: pandas>=2.3.2
+Requires-Dist: pillow>=11.3.0
+Requires-Dist: pyaudio>=0.2.14
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pygame-ce>=2.5.6
+Requires-Dist: pymotego>=0.1.3
+Requires-Dist: pymxbi>=0.1.2
+Requires-Dist: pyserial>=3.5
+Requires-Dist: pyside6>=6.10.1
+Requires-Dist: qtawesome>=1.4.1
+Requires-Dist: rich>=14.1.0
+Requires-Dist: typer>=0.20.0
+Requires-Dist: varname>=0.15.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+## TODO
+
+- [ ] session should be managed automatically
+
+## Table of Contents
+- [Task](https://github.com/Ccccraz/mxbi/blob/main/docs/task.md)
+
+## Get Started 🚀
+
+I typically use `uv` to manage a Python project, and I **highly recommend** you use `uv` to start the mxbi code as well.
+
+```shell
+cd # Go back to home
+
+cd /path/your_favorite # Choose your favorite directory
+
+git clone https://github.com/Ccccraz/mxbi.git # Clone the mxbi repository
+
+cd mxbi # Enter the mxbi directory
+
+uv sync # Install required dependencies
+
+uv run mxbi # Start mxbi
+```
+
+## Current architecture
+
+Currently, the entire code structure is divided into five main parts:
+
+
+- **User GUI**: used for manually adjusting experiment settings
+- **Task scheduler**: used for adjusting task difficulty and switching between tasks
+- **Task**: used for executing specific tasks
+- **Theater**: serves as the environment for task execution
+- **Detector**: Detector, used to detect RFID tags
+
+```mermaid
+flowchart LR
+    user_gui -->|create theater| theater
+    theater -->|create scheduler| scheduler
+    scheduler -->|create task| task
+    task -->|adjust level| scheduler
+    scheduler -->|check rfid| detector
+    detector -->|control| scheduler
+```
+
+## Task Scheduler
+
+There were too many different **states** in the original code, which made the code branch paths overly complex. Therefore, I decided to separate the task `scheduler`, ensuring that the tasks themselves are stateless and that their inputs and outputs are deterministic. The task scheduler will ensure that its initial state is correct.
+
+Moreover, the `Protocol` is used to define the interface of Task, which enables the scheduler not only to adjust the difficulty but also to switch between tasks.
+
+## Detector
+
+### Overview
+
+The RFID module should run in an independent thread, performing detection every **100 ms** and triggering corresponding callbacks based on the detection results.
+
+### Detector States
+
+- **NO_ANIMAL**: No animal detected
+- **ANIMAL_PRESENT**: One animal detected
+- **MORE_THAN_ONE_ANIMAL**: Multiple animals detected (defined as error behavior)
+
+### Data Maintenance
+
+- **current_animal**: Currently detected animal
+- **history_animal**: Historical animal record
+
+### State Transition Events
+
+- **NO_ANIMAL → ANIMAL_PRESENT** and current_animal != history_animal: New animal appears
+- **NO_ANIMAL → ANIMAL_PRESENT** and current_animal == history_animal: Animal returns
+- **ANIMAL_PRESENT → NO_ANIMAL**: Animal leaves
+- **ANIMAL_PRESENT → ANIMAL_PRESENT** and current_animal != history_animal: New animal appears
+- **ANIMAL_PRESENT → MORE_THAN_ONE_ANIMAL**: Multiple animals detected (error behavior)
+- **MORE_THAN_ONE_ANIMAL → ANIMAL_PRESENT**: Recovery
+- **MORE_THAN_ONE_ANIMAL → NO_ANIMAL**: Recovery
+
+### Scheduler State Regulation
+
+- **ANIMAL_ENTERED** → Scheduler in SCHEDULE
+- **ANIMAL_RETURNED** → Scheduler in SCHEDULE
+- **ANIMAL_CHANGED** → Scheduler in SCHEDULE
+- **ANIMAL_LEFT** → Scheduler in IDLE
+- **ERROR_DETECTED** → Scheduler in ERROR
+
+```mermaid
+sequenceDiagram
+    participant RFID_Thread
+    participant Detector
+    participant Scheduler
+
+    loop Every 100 ms
+        RFID_Thread->>Detector: Perform detection
+        activate Detector
+
+        alt NO_ANIMAL → ANIMAL_PRESENT (current ≠ history)
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_ENTERED
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else NO_ANIMAL → ANIMAL_PRESENT (current = history)
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_RETURNED
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else ANIMAL_PRESENT → NO_ANIMAL
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_LEFT
+            Scheduler->>Scheduler: Set to IDLE
+        else ANIMAL_PRESENT → ANIMAL_PRESENT (current ≠ history)
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_CHANGED
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else ANIMAL_PRESENT → MORE_THAN_ONE_ANIMAL
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ERROR_DETECTED
+            Scheduler->>Scheduler: Set to ERROR
+        else MORE_THAN_ONE_ANIMAL → ANIMAL_PRESENT
+            Detector->>Detector: State transition
+            Detector->>Scheduler: Recovery event
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else MORE_THAN_ONE_ANIMAL → NO_ANIMAL
+            Detector->>Detector: State transition
+            Detector->>Scheduler: Recovery event
+            Scheduler->>Scheduler: Set to IDLE
+        end
+
+        deactivate Detector
+    end
+```
+
+## Extract data model
+
+The states in the original code were scattered across a large number of variables, so I tried to extract all the data models for unified management. You can find most of the data models under `src/mxbi/models`.
+
+## TODO:
+
+- More tasks
+- More detailed instruction documents

mxbiflow-0.1.1/README.md

@@ -0,0 +1,139 @@
+## TODO
+
+- [ ] session should be managed automatically
+
+## Table of Contents
+- [Task](https://github.com/Ccccraz/mxbi/blob/main/docs/task.md)
+
+## Get Started 🚀
+
+I typically use `uv` to manage a Python project, and I **highly recommend** you use `uv` to start the mxbi code as well.
+
+```shell
+cd # Go back to home
+
+cd /path/your_favorite # Choose your favorite directory
+
+git clone https://github.com/Ccccraz/mxbi.git # Clone the mxbi repository
+
+cd mxbi # Enter the mxbi directory
+
+uv sync # Install required dependencies
+
+uv run mxbi # Start mxbi
+```
+
+## Current architecture
+
+Currently, the entire code structure is divided into five main parts:
+
+
+- **User GUI**: used for manually adjusting experiment settings
+- **Task scheduler**: used for adjusting task difficulty and switching between tasks
+- **Task**: used for executing specific tasks
+- **Theater**: serves as the environment for task execution
+- **Detector**: Detector, used to detect RFID tags
+
+```mermaid
+flowchart LR
+    user_gui -->|create theater| theater
+    theater -->|create scheduler| scheduler
+    scheduler -->|create task| task
+    task -->|adjust level| scheduler
+    scheduler -->|check rfid| detector
+    detector -->|control| scheduler
+```
+
+## Task Scheduler
+
+There were too many different **states** in the original code, which made the code branch paths overly complex. Therefore, I decided to separate the task `scheduler`, ensuring that the tasks themselves are stateless and that their inputs and outputs are deterministic. The task scheduler will ensure that its initial state is correct.
+
+Moreover, the `Protocol` is used to define the interface of Task, which enables the scheduler not only to adjust the difficulty but also to switch between tasks.
+
+## Detector
+
+### Overview
+
+The RFID module should run in an independent thread, performing detection every **100 ms** and triggering corresponding callbacks based on the detection results.
+
+### Detector States
+
+- **NO_ANIMAL**: No animal detected
+- **ANIMAL_PRESENT**: One animal detected
+- **MORE_THAN_ONE_ANIMAL**: Multiple animals detected (defined as error behavior)
+
+### Data Maintenance
+
+- **current_animal**: Currently detected animal
+- **history_animal**: Historical animal record
+
+### State Transition Events
+
+- **NO_ANIMAL → ANIMAL_PRESENT** and current_animal != history_animal: New animal appears
+- **NO_ANIMAL → ANIMAL_PRESENT** and current_animal == history_animal: Animal returns
+- **ANIMAL_PRESENT → NO_ANIMAL**: Animal leaves
+- **ANIMAL_PRESENT → ANIMAL_PRESENT** and current_animal != history_animal: New animal appears
+- **ANIMAL_PRESENT → MORE_THAN_ONE_ANIMAL**: Multiple animals detected (error behavior)
+- **MORE_THAN_ONE_ANIMAL → ANIMAL_PRESENT**: Recovery
+- **MORE_THAN_ONE_ANIMAL → NO_ANIMAL**: Recovery
+
+### Scheduler State Regulation
+
+- **ANIMAL_ENTERED** → Scheduler in SCHEDULE
+- **ANIMAL_RETURNED** → Scheduler in SCHEDULE
+- **ANIMAL_CHANGED** → Scheduler in SCHEDULE
+- **ANIMAL_LEFT** → Scheduler in IDLE
+- **ERROR_DETECTED** → Scheduler in ERROR
+
+```mermaid
+sequenceDiagram
+    participant RFID_Thread
+    participant Detector
+    participant Scheduler
+
+    loop Every 100 ms
+        RFID_Thread->>Detector: Perform detection
+        activate Detector
+
+        alt NO_ANIMAL → ANIMAL_PRESENT (current ≠ history)
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_ENTERED
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else NO_ANIMAL → ANIMAL_PRESENT (current = history)
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_RETURNED
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else ANIMAL_PRESENT → NO_ANIMAL
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_LEFT
+            Scheduler->>Scheduler: Set to IDLE
+        else ANIMAL_PRESENT → ANIMAL_PRESENT (current ≠ history)
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ANIMAL_CHANGED
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else ANIMAL_PRESENT → MORE_THAN_ONE_ANIMAL
+            Detector->>Detector: State transition
+            Detector->>Scheduler: ERROR_DETECTED
+            Scheduler->>Scheduler: Set to ERROR
+        else MORE_THAN_ONE_ANIMAL → ANIMAL_PRESENT
+            Detector->>Detector: State transition
+            Detector->>Scheduler: Recovery event
+            Scheduler->>Scheduler: Set to SCHEDULE
+        else MORE_THAN_ONE_ANIMAL → NO_ANIMAL
+            Detector->>Detector: State transition
+            Detector->>Scheduler: Recovery event
+            Scheduler->>Scheduler: Set to IDLE
+        end
+
+        deactivate Detector
+    end
+```
+
+## Extract data model
+
+The states in the original code were scattered across a large number of variables, so I tried to extract all the data models for unified management. You can find most of the data models under `src/mxbi/models`.
+
+## TODO:
+
+- More tasks
+- More detailed instruction documents

mxbiflow-0.1.1/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "mxbiflow"
+version = "0.1.1"
+description = "mxbiflow is a toolkit based on pygame and pymxbi"
+readme = "README.md"
+authors = [{ name = "HuYang", email = "huyangcommit@gmail.com" }]
+requires-python = ">=3.14"
+dependencies = [
+    "gpiozero>=2.0.1",
+    "inflection>=0.5.1",
+    "keyring>=25.6.0",
+    "loguru>=0.7.3",
+    "matplotlib>=3.10.6",
+    "mss>=10.1.0",
+    "numpy>=2.3.3",
+    "pandas>=2.3.2",
+    "pillow>=11.3.0",
+    "pyaudio>=0.2.14",
+    "pydantic>=2.11.7",
+    "pygame-ce>=2.5.6",
+    "pymotego>=0.1.3",
+    "pymxbi>=0.1.2",
+    "pyserial>=3.5",
+    "pyside6>=6.10.1",
+    "qtawesome>=1.4.1",
+    "rich>=14.1.0",
+    "typer>=0.20.0",
+    "varname>=0.15.0",
+]
+
+[project.scripts]
+mxbi = "mxbi:main"
+main = "mxbiflow.main:main"
+
+[build-system]
+requires = ["uv_build>=0.8.17,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.uv.sources]
+pymxbi = { path = "../pymxbi/pymxbi", editable = true }

mxbiflow-0.1.1/src/mxbiflow/__init__.py

@@ -0,0 +1,3 @@
+from .mxbiflow import MXBIFlow, get_mxbiflow
+
+__all__ = ["MXBIFlow", "get_mxbiflow"]

mxbiflow-0.1.1/src/mxbiflow/assets/__init__.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+ROOT = Path(__file__).parent
+
+ASSET_CLICKER_PATH = ROOT / "clicker.wav"

mxbiflow-0.1.1/src/mxbiflow/config_store.py

@@ -0,0 +1,68 @@
+import os
+from pathlib import Path
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class ConfigStore(Generic[T]):
+    def __init__(
+        self,
+        config_path: Path,
+        config_class: type[T],
+        *,
+        create_default: bool = True,
+    ) -> None:
+        self._config_path = config_path
+        self._config_class = config_class
+        self._create_default = create_default
+        self._config = self._load_config()
+
+    @property
+    def value(self) -> T:
+        return self._config
+
+    def _ensure_config_readable(self) -> None:
+        if not self._config_path.exists():
+            raise FileNotFoundError(f"Config file {self._config_path} not found")
+
+        if not os.access(self._config_path, os.R_OK):
+            raise PermissionError(f"Config file {self._config_path} is not readable")
+
+    def _create_default_config(self) -> T:
+        config = self._config_class()
+        self._config_path.parent.mkdir(parents=True, exist_ok=True)
+        self._config_path.write_text(
+            config.model_dump_json(indent=4),
+            encoding="utf-8",
+        )
+        return config
+
+    def _load_config(self) -> T:
+        try:
+            self._ensure_config_readable()
+            text = self._config_path.read_text(encoding="utf-8")
+            return self._config_class.model_validate_json(text)
+        except Exception as e:
+            if self._create_default:
+                return self._create_default_config()
+            raise RuntimeError(
+                f"Failed to load config file {self._config_path}: {e}"
+            ) from e
+
+    def save(self, data: T | None = None) -> None:
+        if data is not None:
+            self._config = data
+
+        self._config_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            self._config_path.write_text(
+                self._config.model_dump_json(indent=4),
+                encoding="utf-8",
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to save config file {self._config_path}: {e}"
+            ) from e

mxbiflow-0.1.1/src/mxbiflow/data_logger.py

@@ -0,0 +1,114 @@
+import csv
+import json
+import sys
+from datetime import datetime
+from enum import StrEnum
+from pathlib import Path
+
+from .utils.logger import logger
+
+now = datetime.now()
+
+
+class DataLoggerType(StrEnum):
+    JSONL = "jsonl"
+    JSON = "json"
+    CSV = "csv"
+
+
+class DataLogger:
+    def __init__(
+        self,
+        path: Path,
+        session_id: int,
+        monkey: str,
+        filename: str,
+        type: DataLoggerType = DataLoggerType.JSONL,
+    ) -> None:
+        self._path = path
+        self._session_id = session_id
+        self._monkey = monkey
+        self._filename = filename
+        self._type = type
+
+        self._data_dir = self._ensure_data_dir()
+        self._data_path = self._get_path(f".{self._type.value}")
+
+    @property
+    def path(self) -> Path:
+        return self._data_path
+
+    def _ensure_data_dir(self) -> Path:
+        date_path = Path(f"{now.year}{now.month:02d}{now.day:02d}")
+        session_path = Path(f"{self._session_id}")
+        monkey_path = Path(f"{self._monkey}")
+
+        base_dir = self._path / date_path / session_path / monkey_path
+
+        try:
+            base_dir.mkdir(parents=True, exist_ok=True)
+            return base_dir
+        except Exception as e:
+            logger.error(f"failed to create {base_dir}: {e}")
+            sys.exit(1)
+
+    def _get_path(self, suffix: str) -> Path:
+        return self._data_dir / f"{self._filename}{suffix}"
+
+    def save(self, data: dict) -> None:
+        match self._type:
+            case DataLoggerType.JSONL:
+                self._save_jsonl(data)
+            case DataLoggerType.JSON:
+                self._save_json(data)
+            case DataLoggerType.CSV:
+                self.save_csv_row(data)
+
+    def _save_jsonl(self, data: dict) -> None:
+        try:
+            json_line = json.dumps(data, ensure_ascii=False)
+
+            with open(self._data_path, "a", encoding="utf-8") as f:
+                f.write(json_line + "\n")
+
+        except TypeError as e:
+            logger.error(f"Data is not JSON serializable: {e}")
+            raise
+        except IOError as e:
+            logger.error(f"Failed to write to file {self._data_path}: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error while writing data: {e}")
+            raise
+
+    def _save_json(self, data: dict) -> None:
+        try:
+            self._data_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(self._data_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except TypeError as e:
+            logger.error(f"Data is not JSON serializable: {e}")
+            raise
+        except IOError as e:
+            logger.error(f"Failed to write to file {self._data_path}: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error while writing JSON data: {e}")
+            raise
+
+    def save_csv_row(self, data: dict) -> None:
+        csv_path = self._get_path(".csv")
+        try:
+            csv_path.parent.mkdir(parents=True, exist_ok=True)
+            file_exists = csv_path.exists() and csv_path.stat().st_size > 0
+
+            fieldnames = sorted(data.keys())
+
+            with csv_path.open("a", newline="", encoding="utf-8") as f:
+                writer = csv.DictWriter(f, fieldnames=fieldnames)
+                if not file_exists:
+                    writer.writeheader()
+                writer.writerow({k: data.get(k, "") for k in fieldnames})
+        except Exception as e:
+            logger.error(f"Failed to write CSV row to {csv_path}: {e}")
+            raise

mxbiflow-0.1.1/src/mxbiflow/default/__init__.py

@@ -0,0 +1,4 @@
+from .habituation.habituarion import Habituarion
+from .idle.idle import IDLE
+
+__all__ = ["Habituarion", "IDLE"]

mxbiflow-0.1.1/src/mxbiflow/default/idle/idle.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from pathlib import Path
+from random import choice
+
+from pygame import Event, Rect, Surface, image, transform
+
+from mxbiflow import get_mxbiflow
+from mxbiflow.scene.scene_protocol import SceneProtocol
+
+ASSETS_PATH = Path(__file__).parent / "assets"
+
+
+@dataclass
+class Asset:
+    image: Surface
+    rect: Rect
+
+
+class IDLE:
+    _running: bool
+
+    def __init__(self) -> None:
+        self._mxbiflow = get_mxbiflow()
+
+        self._screen_size = self._mxbiflow.mxbi.screen_size
+        self._pos = ((self._screen_size.width // 4) * 3, self._screen_size.height // 2)
+        self._vstimulus_size = self._screen_size.width // 2 * 0.75
+
+        self._assets = [
+            Asset(
+                asset_image := transform.scale(
+                    image.load(path).convert_alpha(),
+                    (self._vstimulus_size, self._vstimulus_size),
+                ),
+                asset_image.get_rect(center=self._pos),
+            )
+            for path in ASSETS_PATH.glob("*.png")
+        ]
+
+        self._asset = choice(self._assets)
+
+    def start(self) -> None:
+        self._running = True
+
+    def quit(self) -> None:
+        self._running = False
+
+    @property
+    def running(self) -> bool:
+        return self._running
+
+    def handle_event(self, event: Event) -> None: ...
+
+    def update(self, dt_s: float) -> None: ...
+
+    def draw(self, screen: Surface) -> None:
+        screen.blit(self._asset.image, self._asset.rect)

mxbiflow-0.1.1/src/mxbiflow/detector_bridge.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+from queue import Empty, SimpleQueue
+
+import pygame
+from pygame import Event, event
+from pymxbi.detector import MockDetector
+from pymxbi.detector.detector import DetectionResult, Detector, DetectorEvent
+
+EVT_DETECTOR = pygame.USEREVENT + 1
+
+
+@dataclass(frozen=True)
+class DetectorMsg:
+    kind: DetectorEvent
+    animal: str | None
+
+
+class DetectorBridge:
+    def __init__(self, detector: Detector) -> None:
+        self._detector = detector
+        self._q = SimpleQueue()
+        self._started = False
+
+    def start(self) -> None:
+        if self._started:
+            return
+        self._started = True
+
+        self._detector.begin()
+        self._detector.register_event(DetectorEvent.ANIMAL_ENTERED, self._emit_entered)
+        self._detector.register_event(DetectorEvent.ANIMAL_LEFT, self._emit_left)
+        self._detector.register_event(DetectorEvent.FAULT_DETECTED, self._emit_fault)
+
+    def _emit(self, kind: DetectorEvent, animal: str | None) -> None:
+        self._q.put(DetectorMsg(kind=kind, animal=animal))
+
+    def _emit_entered(self, detection_result: DetectionResult) -> None:
+        self._emit(
+            DetectorEvent.ANIMAL_ENTERED,
+            detection_result.animal_id or detection_result.animal_name,
+        )
+
+    def _emit_left(self, detection_result: DetectionResult) -> None:
+        self._emit(
+            DetectorEvent.ANIMAL_LEFT,
+            detection_result.animal_id or detection_result.animal_name,
+        )
+
+    def _emit_fault(self, detection_result: DetectionResult) -> None:
+        self._emit(
+            DetectorEvent.FAULT_DETECTED,
+            detection_result.animal_id or detection_result.animal_name,
+        )
+
+    def emit_pygame_event(self) -> None:
+        while True:
+            try:
+                msg = self._q.get_nowait()
+            except Empty:
+                break
+
+            event.post(event.Event(EVT_DETECTOR, msg=msg))
+
+    def manaul_emit(self, animal_idx: int | None = None) -> None:
+        if isinstance(self._detector, MockDetector):
+            if animal_idx is None:
+                self._detector.animal_left()
+            else:
+                self._detector.animal_present(animal_idx)
+
+    def handle_event(self, event: Event) -> None:
+        if event.type == pygame.KEYDOWN:
+            match event.key:
+                case pygame.K_0:
+                    self.manaul_emit(0)
+                case pygame.K_1:
+                    self.manaul_emit(1)
+                case pygame.K_2:
+                    self.manaul_emit(2)
+                case pygame.K_3:
+                    self.manaul_emit(3)
+                case pygame.K_4:
+                    self.manaul_emit(4)
+                case pygame.K_5:
+                    self.manaul_emit(5)
+                case pygame.K_l:
+                    self.manaul_emit()