Diferencias

Muestra las diferencias entre dos versiones de la página.

--- public:vj1231:arbolesdedecision:start [2026/10/06 09:59] – [Clase Hoja] mperez
+++ public:vj1231:arbolesdedecision:start [2026/10/06 11:07] (actual) – [Árboles dirigidos por datos (data-driven)] mperez
@@ Línea 41: / Línea 41: @@
   * Visualizar y exportar el árbol como imagen o código.
-====== Componentes del árbol ======
+====== Enfoque Orientado a Objetos ======
+En el enfoque Orientado a Objetos (Nodos en Código) se crea la estructura del árbol en memoria. Se definen clases para los nodos (ej. ''NodoDecision'' para las condiciones y ''Hoja'' para las acciones). El árbol se construye instanciando y conectando estos objetos mediante código.
 ===== Clase NodoDecision =====
@@ Línea 85: / Línea 86: @@
 </code>
-{{ :public:vj1231:arbolesdedecision:decisiontreeexample.v2.tgz |}}
-====== Ejemplo ======
+===== Ejemplo =====
-{{:public:vj1231:arbolesdedecision:arboles_npc.f1.png?1200|}}
 En esta imagen se muestra el comportamiento de tres NPCs distintos modelados usando árboles de decisión. Los nodos de condición aparecen en azúl mientras que los nodos de acción aparecen en verde.
-Puedes ver y ejecutar el ejemplo en este {{ :public:vj1231:arbolesdedecision:decisiontreeexample.v2.tgz | script de python}}
+{{:public:vj1231:arbolesdedecision:arboles_npc.f1.png?1200|}}
+Los tres árboles de decisión representados en formato de texto serían:
+### 🟢 NPC Normal
+es el más simple: solo decide entre perseguir o patrullar según si detecta al jugador.
+```
+¿ve_al_jugador?
+├─ Sí → Acción: seguir_jugador
+└─ No → Acción: patrullar_borde
+```
+### 🟠 NPC Tímido
+Es el más complejo (3 niveles de profundidad). Su comportamiento cambia drásticamente dependiendo de si está en "misión de alerta" (buscando al guardia para reportar la posición del jugador:
+   - Si **está en alerta**, prioriza su seguridad (huye hacia un guardia o completa un informe).
+   - Si **no está en alerta**, se comporta de forma más agresiva (inicia la alerta si el jugador está cerca, o lo sigue si está lejos).
+```
+¿en_mision_alerta?
+├─ Sí → ¿muy_cerca_guardia?
+│    ├─ Sí → Acción: irse_al_guardia
+│    └─ No → Acción: completar_informe
+└─ No → ¿ve_al_jugador?
+     ├─ Sí → ¿muy_cerca_jugador?
+     │    ├─ Sí → Acción: iniciar_mision_alerta
+     │    └─ No → Acción: seguir_jugador
+     └─ No → Acción: patrullar_borde
+```
+### 🔵 NPC Guardia
+tiene un comportamiento intermedio. Si no ve al jugador, actúa como un "investigador": va a la última posición reportada del jugador si tiene esa información, o vuelve a patrullar si no.
+```
+¿ve_al_jugador?
+├─ Sí → Acción: seguir_jugador
+└─ No → ¿tiene_posicion_reportada?
+     ├─ Sí → Acción: ir_a_posicion_reportada
+     └─ No → Acción: patrullar
+```
+Puedes ver y ejecutar el ejemplo en este {{ :public:vj1231:arbolesdedecision:decisiontreeexample.v3.py.tar.gz | script de python}}
+====== Árboles dirigidos por datos (data-driven) ======
+Es un caso muy similar al enfoque orientado a objetos, pero en este caso el árbol se define en un archivo de datos externo (como un JSON, XML o un formato binario personalizado). El juego carga este archivo en tiempo de ejecución (o en tiempo de carga) y un parser lo convierte en la estructura de Objetos mencionada en el enfoque anterior.
+Por ejemplo, el NPC tímido se representaria de esta forma
+<code json>
+{
+  "type": "decision",
+  "condition": "en_mision_alerta",
+  "true_branch": {
+    "type": "decision",
+    "condition": "muy_cerca_guardia",
+    "true_branch": {
+      "type": "action",
+      "action": "irse_al_guardia"
+    },
+    "false_branch": {
+      "type": "action",
+      "action": "completar_informe"
+    }
+  },
+  "false_branch": {
+    "type": "decision",
+    "condition": "ve_al_jugador",
+    "true_branch": {
+      "type": "decision",
+      "condition": "muy_cerca_jugador",
+      "true_branch": {
+        "type": "action",
+        "action": "iniciar_mision_alerta"
+      },
+      "false_branch": {
+        "type": "action",
+        "action": "seguir_jugador"
+      }
+    },
+    "false_branch": {
+      "type": "action",
+      "action": "patrullar_bc"
+    }
+  }
+}
+</code>
+y el código en python para leer el ''json'' y crear el árbol sería:
+<code python>
+def construir_arbol(nodo_json):
+    """
+    Lee un diccionario JSON y devuelve una instancia de NodoDecision o Hoja.
+    """
+    tipo = nodo_json.get("type")
+    if tipo == "action":
+        # Caso base: Es una hoja. Buscamos la función en el registro.
+        nombre_accion = nodo_json["action"]
+        funcion_accion = REGISTRO_ACCIONES[nombre_accion]
+        return Hoja(funcion_accion)
+    elif tipo == "decision":
+        # Caso recursivo: Es un nodo de decisión.
+        nombre_condicion = nodo_json["condition"]
+        funcion_condicion = REGISTRO_CONDICIONES[nombre_condicion]
+        nodo = NodoDecision(funcion_condicion)
+        # Construimos las ramas recursivamente
+        nodo.true_case = construir_arbol(nodo_json["true_branch"])
+        nodo.false_case = construir_arbol(nodo_json["false_branch"])
+        return nodo
+    else:
+        raise ValueError(f"Tipo de nodo desconocido: {tipo}")
+</code>
+y se construiría con
+<code python>
+    def crear_arbol(self, datos_json):
+        arbol = construir_arbol(datos_json)
+        return arbol
+</code>