Tu primer juego con IA: 2 minijuegos (3D y 2D) con Claude, Godot y three.js

Crea un minijuego 3D en el navegador con three.js y Vite, llamado "Caza de monedas".

Assets (ya están en public/assets, descargados de Studio Tank):
- hero.glb: personaje chibi de ~1,6 m, mira hacia +Z, clips Idle, Run, Jump, Hit y Victory (30 fps)
- fox.glb: zorro, clips Idle, Walk y Run
- oak.glb y pine.glb: árboles, clip Wind (balanceo)
- chest.glb: baúl, clip Open
Todos usan 1 unidad = 1 metro y una textura-paleta (no cambies los materiales).

El juego:
1. Isla redonda (radio 15 m) rodeada de agua, con 14 árboles repartidos. Copia los árboles con
   SkeletonUtils.clone y reproduce Wind en cada uno, empezando en tiempos distintos. Mete cada modelo
   en un THREE.Group y posiciona el grupo (algunos clips animan la raíz del archivo).
2. El jugador se mueve con WASD/flechas (y un joystick táctil en el móvil) y salta con espacio. Gira el
   modelo hacia el movimiento con Math.atan2(x, z). Cambia Idle/Run/Jump con crossFade de 0,15 s;
   Jump y Hit se reproducen una vez (LoopOnce + clampWhenFinished).
3. 10 monedas doradas (un cilindro de three.js) girando. Con todas, aparece el baúl; al tocarlo se
   reproduce Open y el jugador celebra con Victory.
4. El zorro pasea (Walk) y persigue al jugador (Run) a menos de 7 m. Si lo toca, el jugador reproduce
   Hit, sale empujado y pierde una moneda, que vuelve a la isla.
5. 70 segundos para ganar. HUD en HTML con monedas y tiempo, y pantalla final con "Jugar otra vez".
6. Cámara en tercera persona, desde arriba y detrás, siguiendo suave. Sombras activadas.

Trabaja por pasos: primero la escena con el personaje caminando, luego monedas, zorro y fin del juego.
Ejecútalo con npm run dev y dime qué probar en cada paso.

Crea un minijuego 3D en Godot 4 (GDScript), llamado "Caza de monedas".

Assets en res://assets (GLB de Studio Tank, 1 unidad = 1 m, el modelo mira hacia +Z):
- hero.glb: Idle, Run, Jump, Hit, Victory
- fox.glb: Idle, Walk, Run
- oak.glb y pine.glb: Wind
- chest.glb: Open

1. Al importar, activa Loop en Idle, Run, Walk y Wind (Advanced Import Settings > Animation).
2. Escena principal: isla redonda (CSGCylinder3D verde, radio 15) sobre un plano de agua,
   DirectionalLight3D con sombras y WorldEnvironment con cielo claro. 14 árboles reproduciendo Wind.
3. Jugador: CharacterBody3D con cápsula y hero.glb como hijo. WASD/flechas mueven (relativo a la cámara),
   espacio salta. Usa el AnimationPlayer del GLB: play("Run"), play("Idle"), con blend de 0,15 s.
   El modelo mira hacia +Z: gira con atan2(dirección.x, dirección.z).
4. 10 monedas (Area3D con cilindro dorado) girando. Con todas, aparece el baúl; al llegar, se reproduce
   Open y el jugador reproduce Victory.
5. El zorro (CharacterBody3D) pasea con Walk y persigue al jugador con Run a menos de 7 m. Al tocarlo,
   el jugador reproduce Hit, sale empujado y pierde una moneda.
6. Temporizador de 70 s, HUD con Label (monedas y tiempo) y pantalla de victoria/derrota con botón
   "Jugar otra vez".

Crea los archivos .tscn y .gd y dime dónde conectar cada señal. Si el MCP de Godot está activo, crea las
escenas con él y ejecuta el proyecto para comprobar.

Crea un juego de plataformas 2D en Godot 4 (GDScript), llamado "Salto del zorro".

Sprites en res://sprites (Studio Tank: de lado, mirando a la derecha, cuadros de 128 px, 12 fps).
Cada animación es un PNG + un JSON en formato "hash" (frames[nombre].frame = x, y, w, h; meta.fps; meta.loop):
- hero_Idle, hero_Run, hero_Jump, hero_Hit, hero_Victory
- fox_Walk, chest_Open
- oak_Wind y pine_Wind (árboles, cuadros de 256 px, 8 fps)

1. Escribe un script @tool que lea cada JSON y arme un SpriteFrames (.tres) con una animación por
   archivo: cuadros ordenados por nombre, velocidad = meta.fps, loop = meta.loop.
2. Jugador: CharacterBody2D + AnimatedSprite2D. Flechas/A-D corren (300 px/s), espacio salta, con
   "coyote time" de 0,1 s. Usa flip_h al ir a la izquierda. Los pies no tocan el borde inferior del
   cuadro: ajusta el offset del sprite para que los pies queden en el suelo.
3. Nivel de ~4.000 px: suelo con huecos y plataformas (TileMapLayer o StaticBody2D), árboles animados
   al fondo y un Parallax2D con colinas.
4. Monedas (Area2D) para recoger. Zorros que patrullan: saltar encima los elimina; tocarlos de lado
   quita una de 3 vidas (el jugador reproduce hero_Hit). Caer en un hueco también quita una vida.
5. Al final del nivel, el baúl: al tocarlo se reproduce chest_Open, el jugador reproduce hero_Victory y
   aparece la pantalla de victoria con las monedas recogidas.
Camera2D siguiendo al jugador, limitada al nivel.

Crea el mismo juego de plataformas 2D ("Salto del zorro") en el navegador, en un único archivo HTML con
canvas y JavaScript puro, sin librerías. Los sprites están en ./sprites (mismos nombres y formato de arriba).

- Carga cada JSON con fetch y la imagen de meta.image; ordena los cuadros por nombre.
- Cuadro actual = floor(tiempo * meta.fps) (con loop) o el último cuadro (sin loop).
- Dibuja con drawImage; para mirar a la izquierda, usa scale(-1, 1).
- Busca la línea del pie de cada hoja (última fila con píxel opaco en el primer cuadro) y úsala para
  apoyar los personajes en el suelo.
- Mismas reglas: correr, saltar con coyote time, monedas, zorros (pisar elimina, de lado hace daño),
  3 vidas, huecos y el baúl al final. Canvas de 960x540 que se adapta al ancho de la pantalla.