npcore 0.1.0__tar.gz

npcore-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: npcore
+Version: 0.1.0
+Summary: A Python library for simple NPC simulation with probabilistic decision-making.
+Author-email: Jose <jgmalfavaun@gmail.com>
+License: MIT
+Keywords: npc,simulation,probability,game-ai,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# NPCore
+
+NPCore es una librería en Python para la simulación de agentes (NPCs) con toma de decisiones basada en reglas, contexto, emociones, objetivos y estructuras sociales. El proyecto está diseñado como una base modular y extensible para sistemas de inteligencia artificial en simulaciones o videojuegos.
+
+---
+
+## Descripción
+
+NPCore implementa un sistema de agentes donde cada NPC toma decisiones en función de su estado, su contexto y múltiples factores internos como prioridades, emociones y objetivos. Además, los NPCs interactúan entre sí dentro de un entorno que soporta eventos y proximidad.
+
+El sistema sigue una arquitectura clara y escalable que permite evolucionar hacia modelos más avanzados como Utility AI, aprendizaje dinámico o simulaciones complejas multi-agente.
+
+---
+
+## Características principales
+
+- Motor de decisiones modular (`Brain`)
+- Soporte para reglas en dos formatos:
+  - rule(context)
+  - rule(npc, context)
+- NPCs con:
+  - estado y contexto dinámico
+  - memoria (recordar, recuperar y olvidar información)
+  - objetivos (goals)
+  - prioridades
+  - emociones (como miedo y agresión)
+  - grupo y jerarquía social (rango)
+- Sistema de entorno (`Environment`):
+  - ejecución por pasos (simulation loop)
+  - eventos globales
+  - detección de proximidad
+  - interacción entre NPCs
+- Influencia social entre agentes
+- Integración de emociones y objetivos en la toma de decisiones
+- Normalización de probabilidades en decisiones
+- Tests automatizados con pytest
+
+---
+
+## Arquitectura
+
+El flujo principal del sistema es el siguiente:
+
+NPC -> Brain -> Rules -> Probabilities -> Decision
+
+Dentro del Brain, las probabilidades son modificadas por:
+
+- prioridades del NPC
+- emociones
+- objetivos
+
+Esto permite una toma de decisiones flexible y extensible.
+
+---
+
+## Instalación
+
+Clonar el repositorio:
+
+```bash
+git clone https://github.com/Hotzh3/npcore.git
+cd npcore
+
+## Instalación
+
+  pip install -e .
+
+## Uso básico
+  from npcore.brain import Brain
+  from npcore.npc import NPC
+  from npcore.environment import Environment
+
+  brain = Brain()
+
+  def idle_rule(context):
+      return {"walk": 0.5, "rest": 0.5}
+
+  brain.add_rule("idle", idle_rule)
+
+  npc = NPC("Guard", brain)
+  npc.set_state("idle")
+
+  env = Environment()
+  env.add_npc(npc)
+
+  results = env.step()
+  print(results)
+
+## Ejemplo con interacción entre NPCs
+  npc1 = NPC("Guard", brain)
+  npc2 = NPC("Villager", brain)
+
+  npc1.set_state("idle")
+  npc2.set_state("idle")
+
+  npc1.set_position(0, 0)
+  npc2.set_position(1, 0)
+
+  env = Environment()
+  env.add_npc(npc1)
+  env.add_npc(npc2)
+
+  results = env.step()
+
+## Para ejecutar todos los test
+  pytest --cache-clear
+
+## Estructura del proyecto
+  src/npcore/
+      brain.py
+      npc.py
+      environment.py
+
+      probability.py
+
+  tests/
+      test_npc.py
+      test_environment.py
+      test_probability.py
+
+## Ejecución
+
+### Demo simple
+![Demo simple](assets/demo_simple.png)
+
+### Demo interacción
+![Demo interacción](assets/demo_interaction.png)
+
+### Tests
+![Tests](assets/tests.png)
+
+### Demo simulación completa
+![Demo simulación](assets/demo_simulation.png)

npcore-0.1.0/README.md

@@ -0,0 +1,133 @@
+# NPCore
+
+NPCore es una librería en Python para la simulación de agentes (NPCs) con toma de decisiones basada en reglas, contexto, emociones, objetivos y estructuras sociales. El proyecto está diseñado como una base modular y extensible para sistemas de inteligencia artificial en simulaciones o videojuegos.
+
+---
+
+## Descripción
+
+NPCore implementa un sistema de agentes donde cada NPC toma decisiones en función de su estado, su contexto y múltiples factores internos como prioridades, emociones y objetivos. Además, los NPCs interactúan entre sí dentro de un entorno que soporta eventos y proximidad.
+
+El sistema sigue una arquitectura clara y escalable que permite evolucionar hacia modelos más avanzados como Utility AI, aprendizaje dinámico o simulaciones complejas multi-agente.
+
+---
+
+## Características principales
+
+- Motor de decisiones modular (`Brain`)
+- Soporte para reglas en dos formatos:
+  - rule(context)
+  - rule(npc, context)
+- NPCs con:
+  - estado y contexto dinámico
+  - memoria (recordar, recuperar y olvidar información)
+  - objetivos (goals)
+  - prioridades
+  - emociones (como miedo y agresión)
+  - grupo y jerarquía social (rango)
+- Sistema de entorno (`Environment`):
+  - ejecución por pasos (simulation loop)
+  - eventos globales
+  - detección de proximidad
+  - interacción entre NPCs
+- Influencia social entre agentes
+- Integración de emociones y objetivos en la toma de decisiones
+- Normalización de probabilidades en decisiones
+- Tests automatizados con pytest
+
+---
+
+## Arquitectura
+
+El flujo principal del sistema es el siguiente:
+
+NPC -> Brain -> Rules -> Probabilities -> Decision
+
+Dentro del Brain, las probabilidades son modificadas por:
+
+- prioridades del NPC
+- emociones
+- objetivos
+
+Esto permite una toma de decisiones flexible y extensible.
+
+---
+
+## Instalación
+
+Clonar el repositorio:
+
+```bash
+git clone https://github.com/Hotzh3/npcore.git
+cd npcore
+
+## Instalación
+
+  pip install -e .
+
+## Uso básico
+  from npcore.brain import Brain
+  from npcore.npc import NPC
+  from npcore.environment import Environment
+
+  brain = Brain()
+
+  def idle_rule(context):
+      return {"walk": 0.5, "rest": 0.5}
+
+  brain.add_rule("idle", idle_rule)
+
+  npc = NPC("Guard", brain)
+  npc.set_state("idle")
+
+  env = Environment()
+  env.add_npc(npc)
+
+  results = env.step()
+  print(results)
+
+## Ejemplo con interacción entre NPCs
+  npc1 = NPC("Guard", brain)
+  npc2 = NPC("Villager", brain)
+
+  npc1.set_state("idle")
+  npc2.set_state("idle")
+
+  npc1.set_position(0, 0)
+  npc2.set_position(1, 0)
+
+  env = Environment()
+  env.add_npc(npc1)
+  env.add_npc(npc2)
+
+  results = env.step()
+
+## Para ejecutar todos los test
+  pytest --cache-clear
+
+## Estructura del proyecto
+  src/npcore/
+      brain.py
+      npc.py
+      environment.py
+
+      probability.py
+
+  tests/
+      test_npc.py
+      test_environment.py
+      test_probability.py
+
+## Ejecución
+
+### Demo simple
+![Demo simple](assets/demo_simple.png)
+
+### Demo interacción
+![Demo interacción](assets/demo_interaction.png)
+
+### Tests
+![Tests](assets/tests.png)
+
+### Demo simulación completa
+![Demo simulación](assets/demo_simulation.png)

npcore-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "npcore"
+version = "0.1.0"
+description = "A Python library for simple NPC simulation with probabilistic decision-making."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+  { name = "Jose", email = "jgmalfavaun@gmail.com" }
+]
+license = { text = "MIT" }
+keywords = ["npc", "simulation", "probability", "game-ai", "agents"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

npcore-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

npcore-0.1.0/src/npcore/__init__.py

@@ -0,0 +1,5 @@
+from .brain import Brain
+from .npc import NPC
+from .environment import Environment
+
+__all__ = ["Brain", "NPC", "Environment"]

npcore-0.1.0/src/npcore/brain.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+from npcore.probability import weighted_choice
+from npcore.utility import normalize_utilities
+
+
+class Brain:
+    """
+    Decision engine for NPCs.
+
+    Each state is associated with a rule function that returns
+    action scores/utilities.
+
+    Rules can work in two ways:
+    1. Legacy style: rule(context)
+    2. Extended style: rule(npc, context)
+    """
+
+    def __init__(self) -> None:
+        self.rules: Dict[str, Callable[..., dict[str, float]]] = {}
+
+    def add_rule(self, state: str, func: Callable[..., dict[str, float]]) -> None:
+        """
+        Register a rule for a given state.
+        """
+        self.rules[state] = func
+
+    def _resolve_utilities(self, state: str, context: dict, npc=None) -> dict[str, float]:
+        """
+        Resolve raw action utilities returned by a rule.
+        """
+        if state not in self.rules:
+            raise ValueError(f"No rule defined for state '{state}'")
+
+        rule = self.rules[state]
+
+        if npc is None:
+            return rule(context)
+
+        try:
+            return rule(npc, context)
+        except TypeError:
+            return rule(context)
+
+    def _apply_priority_weights(self, utilities: dict[str, float], npc=None) -> dict[str, float]:
+        """
+        Apply NPC priorities as multiplicative weights.
+        """
+        if npc is None or not npc.priorities:
+            return dict(utilities)
+
+        adjusted = dict(utilities)
+
+        for action, value in adjusted.items():
+            weight = npc.priorities.get(action, 1.0)
+            adjusted[action] = value * weight
+
+        return adjusted
+
+    def _apply_emotions(self, utilities: dict[str, float], npc=None) -> dict[str, float]:
+        """
+        Adjust action utilities using NPC emotions.
+        """
+        if npc is None:
+            return dict(utilities)
+
+        adjusted = dict(utilities)
+
+        fear = npc.get_emotion("fear")
+        aggression = npc.get_emotion("aggression")
+
+        for action, value in adjusted.items():
+            if action in {"run", "hide"}:
+                adjusted[action] = value * (1 + fear)
+
+            if action in {"attack", "defend"}:
+                adjusted[action] = value * (1 + aggression)
+
+        return adjusted
+
+    def _apply_goal(self, utilities: dict[str, float], npc=None) -> dict[str, float]:
+        if npc is None or not npc.goal:
+            return dict(utilities)
+
+        adjusted = dict(utilities)
+        goal = npc.goal
+
+        for action, value in adjusted.items():
+            if goal == "survive" and action in {"run", "hide"}:
+                adjusted[action] = value * 2
+
+            if goal == "attack" and action == "attack":
+                adjusted[action] = value * 2
+
+        return adjusted
+
+
+    def _apply_learning(self, utilities: dict[str, float], npc=None) -> dict[str, float]:
+        """
+        Adjust action utilities according to past success rates.
+        """
+        if npc is None:
+            return dict(utilities)
+
+        adjusted = dict(utilities)
+
+        for action, value in adjusted.items():
+            success_rate = npc.get_action_success_rate(action)
+
+            if success_rate > 0:
+                adjusted[action] = value * (1 + success_rate)
+
+        return adjusted
+
+   
+
+    def decide(self, state: str, context: dict, npc=None) -> str:
+        """
+        Decide an action based on state, context and optional NPC traits.
+        """
+        utilities = self._resolve_utilities(state, context, npc)
+        utilities = self._apply_priority_weights(utilities, npc)
+        utilities = self._apply_emotions(utilities, npc)
+        utilities = self._apply_goal(utilities, npc)
+        utilities = self._apply_learning(utilities, npc)
+
+        probabilities = normalize_utilities(utilities)
+
+        return weighted_choice(probabilities)

npcore-0.1.0/src/npcore/environment.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from typing import List
+
+from npcore.npc import NPC
+
+
+class Environment:
+    """
+    Simple simulation environment for NPCs.
+    """
+
+    def __init__(self) -> None:
+        self.npcs: List[NPC] = []
+        self.tick_count = 0
+        self.global_state: dict = {}
+        self.events: list[str] = []
+        self.history: list[list[tuple[str, str]]] = []
+
+    def add_npc(self, npc: NPC) -> None:
+        self.npcs.append(npc)
+
+    def trigger_event(self, event: str) -> None:
+        self.events.append(event)
+
+    def get_nearby(self, npc: NPC, radius: int = 1) -> list[NPC]:
+        """
+        Return nearby NPCs based on Manhattan distance.
+        """
+        if npc.position is None:
+            return []
+
+        x1, y1 = npc.position
+        nearby: list[NPC] = []
+
+        for other in self.npcs:
+            if other is npc or other.position is None:
+                continue
+
+            x2, y2 = other.position
+            distance = abs(x1 - x2) + abs(y1 - y2)
+
+            if distance <= radius:
+                nearby.append(other)
+
+        return nearby
+
+    def step(self) -> list[tuple[str, str]]:
+        """
+        Run one simulation step.
+        Returns list of (npc_name, action)
+        """
+        results = []
+
+        for npc in self.npcs:
+            npc.update_context(events=self.events)
+            action = npc.act()
+            results.append((npc.name, action))
+
+            nearby = self.get_nearby(npc)
+            for other in nearby:
+                message = npc.greet(other)
+                results.append(("message", message))
+
+        self.tick_count += 1
+        self.history.append(results)
+        return results
+
+    def run(self, steps: int) -> list[list[tuple[str, str]]]:
+        """
+        Run multiple steps.
+        """
+        history = []
+        for _ in range(steps):
+            history.append(self.step())
+        return history
+
+    def action_counts(self) -> dict[str, int]:
+        """
+        Count how many times each action appears in the environment history.
+        """
+        counts: dict[str, int] = {}
+
+        for step_results in self.history:
+            for actor, action in step_results:
+                if actor == "message":
+                    continue
+                counts[action] = counts.get(action, 0) + 1
+
+        return counts
+
+    def summary(self) -> dict:
+        """
+        Return a summary of the simulation.
+        """
+        return {
+            "ticks": self.tick_count,
+            "npcs": len(self.npcs),
+            "history_length": len(self.history),
+            "action_counts": self.action_counts(),
+        }

npcore-0.1.0/src/npcore/npc.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from npcore.brain import Brain
+
+
+class NPC:
+    """
+    Represents an NPC with internal state, memory, social attributes,
+    emotions, and a decision-making brain.
+    """
+
+    def __init__(self, name: str, brain: Brain) -> None:
+        self.name = name
+        self.brain = brain
+
+        # estado actual y contexto inmediato
+        self.state = "idle"
+        self.context: dict = {}
+
+        # memoria
+        self.memory: dict = {}
+
+        # objetivos y prioridades
+        self.goal: str | None = None
+        self.priorities: dict[str, float] = {}
+
+        # inventario
+        self.inventory: list = []
+
+        # posición en el entorno
+        self.position: tuple[int, int] | None = None
+
+        # estructura social
+        self.group: str | None = None
+        self.rank: str | None = None
+        self.reputation: dict[str, float] = {}
+
+        # emociones
+        self.emotions: dict[str, float] = {
+            "fear": 0.0,
+            "trust": 0.0,
+            "aggression": 0.0,
+        }
+        
+        # aprendizaje simple
+        self.action_history: dict[str, list[bool]] = {}
+
+    def set_state(self, state: str) -> None:
+        self.state = state
+
+    def update_context(self, **kwargs) -> None:
+        self.context.update(kwargs)
+
+    def remember(self, key: str, value) -> None:
+        self.memory[key] = value
+
+    def recall(self, key: str, default=None):
+        return self.memory.get(key, default)
+
+    def forget(self, key: str) -> None:
+        if key in self.memory:
+            del self.memory[key]
+
+    def set_goal(self, goal: str) -> None:
+        self.goal = goal
+
+    def set_priorities(self, priorities: dict[str, float]) -> None:
+        self.priorities = priorities
+
+    def set_position(self, x: int, y: int) -> None:
+        self.position = (x, y)
+
+    def set_group(self, group: str) -> None:
+        self.group = group
+
+    def set_rank(self, rank: str) -> None:
+        self.rank = rank
+
+    def set_emotion(self, emotion: str, value: float) -> None:
+        self.emotions[emotion] = value
+
+    def get_emotion(self, emotion: str) -> float:
+        return self.emotions.get(emotion, 0.0)
+
+    def get_social_influence(self, others: list["NPC"]) -> dict:
+        influence = {
+            "leaders": 0,
+            "allies": 0,
+            "others": 0,
+        }
+
+        for other in others:
+            if other.group == self.group:
+                influence["allies"] += 1
+                if other.rank == "leader":
+                    influence["leaders"] += 1
+            else:
+                influence["others"] += 1
+
+        return influence
+
+    def greet(self, other: "NPC") -> str:
+        return f"{self.name} says hello to {other.name}"
+
+    def act(self) -> str:
+        """
+        Decide and return an action based on current state and context.
+        """
+        return self.brain.decide(self.state, self.context, self)
+    
+    def record_outcome(self, action: str, success: bool) -> None:
+        """
+        Store the outcome of an action.
+        """
+        if action not in self.action_history:
+            self.action_history[action] = []
+
+        self.action_history[action].append(success)
+
+
+    def get_action_history(self, action: str) -> list[bool]:
+        """
+        Return stored outcomes for an action.
+        """
+        return self.action_history.get(action, [])
+
+
+    def get_action_success_rate(self, action: str) -> float:
+        """
+        Return success rate for an action.
+        """
+        history = self.get_action_history(action)
+
+        if not history:
+            return 0.0
+
+        return sum(history) / len(history)

npcore-0.1.0/src/npcore/probability.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import random
+
+
+def validate_probabilities(options: dict[str, float]) -> None:
+    """
+    Validate that a probability dictionary is usable.
+
+    Rules:
+    - must not be empty
+    - all values must be numeric
+    - no value can be negative
+    - total must be greater than 0
+    """
+    if not options:
+        raise ValueError("Options dictionary cannot be empty.")
+
+    total = 0.0
+    for action, weight in options.items():
+        if not isinstance(weight, (int, float)):
+            raise TypeError(f"Weight for '{action}' must be numeric.")
+        if weight < 0:
+            raise ValueError(f"Weight for '{action}' cannot be negative.")
+        total += float(weight)
+
+    if total <= 0:
+        raise ValueError("Total probability weight must be greater than 0.")
+
+
+def normalize_probabilities(options: dict[str, float]) -> dict[str, float]:
+    """
+    Convert raw weights into normalized probabilities that sum to 1.
+    """
+    validate_probabilities(options)
+    total = sum(float(weight) for weight in options.values())
+    return {action: float(weight) / total for action, weight in options.items()}
+
+
+def weighted_choice(options: dict[str, float]) -> str:
+    """
+    Choose one action using weighted random selection.
+    """
+    validate_probabilities(options)
+    actions = list(options.keys())
+    weights = list(float(weight) for weight in options.values())
+    return random.choices(actions, weights=weights, k=1)[0]

npcore-0.1.0/src/npcore/utility.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Dict
+
+
+def normalize_utilities(utilities: Dict[str, float]) -> Dict[str, float]:
+    """
+    Normalize utilities into probabilities.
+    """
+    total = sum(utilities.values())
+
+    if total <= 0:
+        return dict(utilities)
+
+    return {k: v / total for k, v in utilities.items()}
+
+
+def softmax(utilities: Dict[str, float], temperature: float = 1.0) -> Dict[str, float]:
+    """
+    Convert utilities into probabilities using softmax.
+    """
+    import math
+
+    exp_values = {
+        k: math.exp(v / temperature) for k, v in utilities.items()
+    }
+
+    total = sum(exp_values.values())
+
+    return {k: v / total for k, v in exp_values.items()}
+
+
+def pick_best(utilities: Dict[str, float]) -> str:
+    """
+    Deterministic: choose the highest utility.
+    """
+    return max(utilities, key=utilities.get)

npcore-0.1.0/src/npcore.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: npcore
+Version: 0.1.0
+Summary: A Python library for simple NPC simulation with probabilistic decision-making.
+Author-email: Jose <jgmalfavaun@gmail.com>
+License: MIT
+Keywords: npc,simulation,probability,game-ai,agents
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# NPCore
+
+NPCore es una librería en Python para la simulación de agentes (NPCs) con toma de decisiones basada en reglas, contexto, emociones, objetivos y estructuras sociales. El proyecto está diseñado como una base modular y extensible para sistemas de inteligencia artificial en simulaciones o videojuegos.
+
+---
+
+## Descripción
+
+NPCore implementa un sistema de agentes donde cada NPC toma decisiones en función de su estado, su contexto y múltiples factores internos como prioridades, emociones y objetivos. Además, los NPCs interactúan entre sí dentro de un entorno que soporta eventos y proximidad.
+
+El sistema sigue una arquitectura clara y escalable que permite evolucionar hacia modelos más avanzados como Utility AI, aprendizaje dinámico o simulaciones complejas multi-agente.
+
+---
+
+## Características principales
+
+- Motor de decisiones modular (`Brain`)
+- Soporte para reglas en dos formatos:
+  - rule(context)
+  - rule(npc, context)
+- NPCs con:
+  - estado y contexto dinámico
+  - memoria (recordar, recuperar y olvidar información)
+  - objetivos (goals)
+  - prioridades
+  - emociones (como miedo y agresión)
+  - grupo y jerarquía social (rango)
+- Sistema de entorno (`Environment`):
+  - ejecución por pasos (simulation loop)
+  - eventos globales
+  - detección de proximidad
+  - interacción entre NPCs
+- Influencia social entre agentes
+- Integración de emociones y objetivos en la toma de decisiones
+- Normalización de probabilidades en decisiones
+- Tests automatizados con pytest
+
+---
+
+## Arquitectura
+
+El flujo principal del sistema es el siguiente:
+
+NPC -> Brain -> Rules -> Probabilities -> Decision
+
+Dentro del Brain, las probabilidades son modificadas por:
+
+- prioridades del NPC
+- emociones
+- objetivos
+
+Esto permite una toma de decisiones flexible y extensible.
+
+---
+
+## Instalación
+
+Clonar el repositorio:
+
+```bash
+git clone https://github.com/Hotzh3/npcore.git
+cd npcore
+
+## Instalación
+
+  pip install -e .
+
+## Uso básico
+  from npcore.brain import Brain
+  from npcore.npc import NPC
+  from npcore.environment import Environment
+
+  brain = Brain()
+
+  def idle_rule(context):
+      return {"walk": 0.5, "rest": 0.5}
+
+  brain.add_rule("idle", idle_rule)
+
+  npc = NPC("Guard", brain)
+  npc.set_state("idle")
+
+  env = Environment()
+  env.add_npc(npc)
+
+  results = env.step()
+  print(results)
+
+## Ejemplo con interacción entre NPCs
+  npc1 = NPC("Guard", brain)
+  npc2 = NPC("Villager", brain)
+
+  npc1.set_state("idle")
+  npc2.set_state("idle")
+
+  npc1.set_position(0, 0)
+  npc2.set_position(1, 0)
+
+  env = Environment()
+  env.add_npc(npc1)
+  env.add_npc(npc2)
+
+  results = env.step()
+
+## Para ejecutar todos los test
+  pytest --cache-clear
+
+## Estructura del proyecto
+  src/npcore/
+      brain.py
+      npc.py
+      environment.py
+
+      probability.py
+
+  tests/
+      test_npc.py
+      test_environment.py
+      test_probability.py
+
+## Ejecución
+
+### Demo simple
+![Demo simple](assets/demo_simple.png)
+
+### Demo interacción
+![Demo interacción](assets/demo_interaction.png)
+
+### Tests
+![Tests](assets/tests.png)
+
+### Demo simulación completa
+![Demo simulación](assets/demo_simulation.png)

npcore-0.1.0/src/npcore.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/npcore/__init__.py
+src/npcore/brain.py
+src/npcore/environment.py
+src/npcore/npc.py
+src/npcore/probability.py
+src/npcore/utility.py
+src/npcore.egg-info/PKG-INFO
+src/npcore.egg-info/SOURCES.txt
+src/npcore.egg-info/dependency_links.txt
+src/npcore.egg-info/top_level.txt
+tests/test_environment.py
+tests/test_npc.py
+tests/test_probability.py

npcore-0.1.0/src/npcore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

npcore-0.1.0/src/npcore.egg-info/top_level.txt

@@ -0,0 +1 @@
+npcore

npcore-0.1.0/tests/test_environment.py

@@ -0,0 +1,118 @@
+from npcore.brain import Brain
+from npcore.npc import NPC
+from npcore.environment import Environment
+
+
+def test_environment_runs():
+    brain = Brain()
+
+    def idle_rule(context):
+        return {"walk": 0.5, "rest": 0.5}
+
+    brain.add_rule("idle", idle_rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("idle")
+
+    env = Environment()
+    env.add_npc(npc)
+
+    results = env.step()
+
+    assert len(results) == 1
+    assert results[0][0] == "Guard"
+    assert results[0][1] in {"walk", "rest"}
+
+
+def test_npc_proximity_message():
+    brain = Brain()
+
+    def idle_rule(context):
+        return {"wait": 1.0}
+
+    brain.add_rule("idle", idle_rule)
+
+    npc1 = NPC("Guard", brain)
+    npc2 = NPC("Villager", brain)
+
+    npc1.set_state("idle")
+    npc2.set_state("idle")
+
+    npc1.set_position(0, 0)
+    npc2.set_position(1, 0)
+
+    env = Environment()
+    env.add_npc(npc1)
+    env.add_npc(npc2)
+
+    results = env.step()
+
+    messages = [r for r in results if r[0] == "message"]
+
+    assert len(messages) > 0
+
+
+def test_environment_event_propagation():
+    brain = Brain()
+
+    def danger_rule(npc, context):
+        if "danger" in context.get("events", []):
+            return {"run": 1.0}
+        return {"idle": 1.0}
+
+    brain.add_rule("react", danger_rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("react")
+
+    env = Environment()
+    env.add_npc(npc)
+
+    env.trigger_event("danger")
+
+    results = env.step()
+
+    assert results[0][1] == "run"
+    
+    
+def test_environment_tracks_history():
+    brain = Brain()
+
+    def idle_rule(context):
+        return {"wait": 1.0}
+
+    brain.add_rule("idle", idle_rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("idle")
+
+    env = Environment()
+    env.add_npc(npc)
+
+    env.run(3)
+
+    assert len(env.history) == 3
+    assert env.tick_count == 3
+    
+def test_environment_summary_contains_action_counts():
+    brain = Brain()
+
+    def idle_rule(context):
+        return {"wait": 1.0}
+
+    brain.add_rule("idle", idle_rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("idle")
+
+    env = Environment()
+    env.add_npc(npc)
+
+    env.run(2)
+
+    summary = env.summary()
+
+    assert summary["ticks"] == 2
+    assert summary["npcs"] == 1
+    assert summary["history_length"] == 2
+    assert summary["action_counts"]["wait"] == 2

npcore-0.1.0/tests/test_npc.py

@@ -0,0 +1,188 @@
+from npcore.brain import Brain
+from npcore.npc import NPC
+
+
+def make_brain(action_map: dict[str, float] | None = None) -> Brain:
+    """
+    Build a simple brain for tests.
+    """
+    brain = Brain()
+
+    if action_map is None:
+        action_map = {"wait": 1.0}
+
+    def idle_rule(context):
+        return action_map
+
+    brain.add_rule("idle", idle_rule)
+    return brain
+
+
+def test_npc_can_act():
+    brain = make_brain({"walk": 0.5, "rest": 0.5})
+
+    npc = NPC(name="Guard", brain=brain)
+    npc.set_state("idle")
+
+    action = npc.act()
+
+    assert action in {"walk", "rest"}
+
+
+def test_npc_goal_setting():
+    brain = make_brain({"walk": 0.5, "rest": 0.5})
+
+    npc = NPC(name="Guard", brain=brain)
+    npc.set_goal("survive")
+
+    assert npc.goal == "survive"
+
+
+def test_npc_priorities_setting():
+    brain = make_brain({"walk": 0.5, "rest": 0.5})
+
+    npc = NPC(name="Guard", brain=brain)
+    priorities = {"survival": 0.9, "combat": 0.3}
+    npc.set_priorities(priorities)
+
+    assert npc.priorities == priorities
+
+
+def test_npc_group_setting():
+    brain = make_brain()
+
+    npc = NPC(name="Guard", brain=brain)
+    npc.set_group("guards")
+
+    assert npc.group == "guards"
+
+
+def test_npc_rank_setting():
+    brain = make_brain()
+
+    npc = NPC(name="Guard", brain=brain)
+    npc.set_rank("leader")
+
+    assert npc.rank == "leader"
+
+
+def test_social_influence_counts():
+    brain = make_brain()
+
+    npc = NPC("A", brain)
+    npc.set_group("guards")
+
+    leader = NPC("Leader", brain)
+    leader.set_group("guards")
+    leader.set_rank("leader")
+
+    ally = NPC("Ally", brain)
+    ally.set_group("guards")
+
+    outsider = NPC("Stranger", brain)
+    outsider.set_group("villagers")
+
+    influence = npc.get_social_influence([leader, ally, outsider])
+
+    assert influence == {"leaders": 1, "allies": 2, "others": 1}
+
+
+def test_npc_decision_with_social_influence():
+    brain = Brain()
+
+    def social_rule(npc, context):
+        nearby = context.get("nearby", [])
+        influence = npc.get_social_influence(nearby)
+
+        if influence["leaders"] > 0:
+            return {"follow": 1.0}
+
+        return {"idle": 1.0}
+
+    brain.add_rule("social", social_rule)
+
+    npc = NPC("A", brain)
+    npc.set_state("social")
+    npc.set_group("guards")
+
+    leader = NPC("Leader", brain)
+    leader.set_group("guards")
+    leader.set_rank("leader")
+
+    npc.update_context(nearby=[leader])
+
+    action = npc.act()
+
+    assert action == "follow"
+
+def test_utility_weights_favor_higher_score():
+    brain = Brain()
+
+    def rule(context):
+        return {"run": 3.0, "walk": 1.0}
+
+    brain.add_rule("idle", rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("idle")
+
+    results = [npc.act() for _ in range(30)]
+
+    assert results.count("run") > results.count("walk")
+    
+def test_npc_can_record_action_outcome():
+    brain = make_brain()
+
+    npc = NPC("Guard", brain)
+    npc.record_outcome("run", True)
+    npc.record_outcome("run", False)
+
+    assert npc.get_action_history("run") == [True, False]
+
+
+def test_npc_action_success_rate():
+    brain = make_brain()
+
+    npc = NPC("Guard", brain)
+    npc.record_outcome("run", True)
+    npc.record_outcome("run", True)
+    npc.record_outcome("run", False)
+
+    assert npc.get_action_success_rate("run") == 2 / 3
+    
+def test_learning_increases_previously_successful_action():
+    brain = Brain()
+
+    def rule(context):
+        return {"run": 1.0, "walk": 1.0}
+
+    brain.add_rule("idle", rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("idle")
+
+    npc.record_outcome("run", True)
+    npc.record_outcome("run", True)
+    npc.record_outcome("run", True)
+
+    results = [npc.act() for _ in range(30)]
+
+    assert results.count("run") > results.count("walk")
+    
+def test_learning_does_not_boost_action_without_history():
+    brain = Brain()
+
+    def rule(context):
+        return {"run": 1.0, "walk": 1.0}
+
+    brain.add_rule("idle", rule)
+
+    npc = NPC("Guard", brain)
+    npc.set_state("idle")
+
+    npc.record_outcome("run", True)
+
+    history_run = npc.get_action_success_rate("run")
+    history_walk = npc.get_action_success_rate("walk")
+
+    assert history_run > history_walk

npcore-0.1.0/tests/test_probability.py

@@ -0,0 +1,23 @@
+from npcore.probability import (
+    normalize_probabilities,
+    validate_probabilities,
+    weighted_choice,
+)
+
+
+def test_validate_probabilities_accepts_valid_data():
+    options = {"attack": 0.6, "defend": 0.3, "flee": 0.1}
+    validate_probabilities(options)
+
+
+def test_normalize_probabilities_sums_to_one():
+    options = {"attack": 2, "defend": 1, "flee": 1}
+    normalized = normalize_probabilities(options)
+    assert abs(sum(normalized.values()) - 1.0) < 1e-9
+
+
+def test_weighted_choice_returns_valid_action():
+    options = {"attack": 0.6, "defend": 0.3, "flee": 0.1}
+    result = weighted_choice(options)
+    assert result in options
+