// ================================================== // Project Imports // ================================================== // App.jsx import React, { useEffect, useRef, useState, useCallback, useMemo } from 'react'; import ReactDOM from 'react-dom/client'; import * as THREE from 'three'; // Audio URL const BACKGROUND_MUSIC_URL = 'https://play.rosebud.ai/assets/ecosphere theme.mp3?J0xc'; import ReactDOM from 'react-dom/client'; import * as THREE from 'three'; import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls'; import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader'; // ================================================== // General Notes for Rosie AI // ================================================== // Note: In sandboxed environments, avoid using

elements and traditional // form submissions as they may be blocked by security policies. Instead, use // controlled components with direct event handlers (onClick, onChange, etc.). // ================================================== // ChatAIClass Definition // ================================================== // This module provides a class, ChatAIClass, which uses a ChatManager (provided externally) // to conduct a conversation with an AI. The AI's behavior is defined by a description string, // and the ChatAIClass offers a simple getResponse method to get AI responses. // // This is AI is powered by Rosebud AI and is Rosebud's method to add in-game AI features. // // IMPORTANT NOTE: // - Do not assume how ChatManager works beyond what is described here. // - We only know that: // 1. ChatManager is constructed by passing in a description string. // 2. We can add messages by calling chatManager.addMessage('user', prompt). // 3. We can get an AI-generated response by calling chatManager.getCharacterResponse('classify'). // - Any other assumptions about ChatManager internals or methods should not be made. // // This code can be used in any JS project by simply importing this class and using it. ////////////////////////////////////////////////////////////// // Defines how the AI should behave. This should change to match the project. const AI_BEHAVIOR_DESCRIPTION = ` You are an advanced and knowledgeable AI system capable of assisting users with a wide range of topics. You should respond concisely and helpfully, ensuring that the information you provide is accurate, clear, and context-aware. `; /** * ChatAIClass: * * This class is intended for non-technical users who want to interact with an AI system. * * Usage: * 1. Create an instance of ChatAIClass: * const chat = new ChatAIClass(); * * 2. Call getResponse(prompt) to get a response from the AI: * const answer = await chat.getResponse("What is quantum computing?"); * console.log(answer); */ export class ChatAIClass { constructor() { // Directly create a new ChatManager instance with the AI behavior description. // We assume ChatManager is available globally or imported from elsewhere. this.chatManager = new ChatManager(AI_BEHAVIOR_DESCRIPTION); } /** * Generates a response from the AI based on the given prompt. * * @param {string} prompt - The user's input or question. * @returns {Promise} - The AI's response as text. */ async getResponse(prompt) { // Add the user's message to the conversation. this.chatManager.addMessage('user', prompt); // Ask the ChatManager for the AI's response and return it. const response = await this.chatManager.getCharacterResponse('classify'); // Add the AI's message to the conversation so it has memory of it. this.chatManager.addMessage('assistant', response); return response; } } // ================================================== // Main App Component with Three.js Scene // ================================================== const MainMenu = ({ onStartGame }) => { const handleStartGame = () => { // Add black overlay const overlay = document.createElement('div'); overlay.style.position = 'fixed'; overlay.style.top = '0'; overlay.style.left = '0'; overlay.style.width = '100%'; overlay.style.height = '100%'; overlay.style.backgroundColor = '#000000'; overlay.style.zIndex = '1000'; overlay.style.opacity = '0'; overlay.style.transition = 'opacity 1s ease-in'; document.body.appendChild(overlay); // Fade to black requestAnimationFrame(() => { overlay.style.opacity = '1'; // After fade to black, start game and fade out setTimeout(() => { onStartGame(); overlay.style.opacity = '0'; // Remove overlay after fade out setTimeout(() => { document.body.removeChild(overlay); }, 1000); }, 1000); }); }; return (

ECOSPHERE

); }; const App = () => { const [gameStarted, setGameStarted] = useState(false); const mountRef = useRef(null); const audioRef = useRef(null); const templateModelsRef = useRef({}); // Store initial templates const sceneRef = useRef(null); // Add scene reference const [selectedOrganism, setSelectedOrganism] = useState('algae'); const [points, setPoints] = useState(10); // Start with 10 points const organismCosts = useMemo(() => ({ algae: 2, bacteria: 3, ameba: 6, bioluminescentAlgae: 4, verticalAlgae: 8, anaerobicBacteria: 5 }), []); const [ecosystemStats, setEcosystemStats] = useState({ lightIntensity: 0, oxygenLevel: 50, // Start with 50% oxygen algae: { total: 0, adults: 0, children: 0, avgNutrition: 0 }, bacteria: { total: 0, adults: 0, children: 0, avgNutrition: 0 }, ameba: { total: 0, adults: 0, children: 0, avgNutrition: 0 }, bioluminescentAlgae: { total: 0, adults: 0, children: 0, avgNutrition: 0 }, verticalAlgae: { total: 0, adults: 0, children: 0, avgNutrition: 0 }, anaerobicBacteria: { total: 0, adults: 0, children: 0, avgNutrition: 0 } }); const timeRef = useRef(0.25); // Start at noon for better visibility const lightsRef = useRef({}); const modelsRef = useRef({}); const populationRef = useRef({ algae: [], // Will be populated with initial 5 algae bacteria: [], ameba: [], bioluminescentAlgae: [], verticalAlgae: [], anaerobicBacteria: [] }); useEffect(() => { if (!gameStarted) return; // Initialize and play background music const audio = new Audio(BACKGROUND_MUSIC_URL); audio.loop = true; audio.volume = 1.0; // Set volume to 100% audio.play().catch(error => console.warn('Audio autoplay failed:', error)); audioRef.current = audio; // Scene setup const scene = new THREE.Scene(); sceneRef.current = scene; // Store scene reference scene.fog = new THREE.Fog(0x87CEEB, 1, 100); const camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 0.1, 1000); // Add lighting system const ambientLight = new THREE.AmbientLight(0x555555, 0.5); scene.add(ambientLight); const sunLight = new THREE.DirectionalLight(0xffffff, 1); sunLight.position.set(1, 1, 1); scene.add(sunLight); const moonLight = new THREE.DirectionalLight(0x4444ff, 0.1); moonLight.position.set(-1, 1, -1); scene.add(moonLight); // Store lights in ref for animation access lightsRef.current = { ambient: ambientLight, sun: sunLight, moon: moonLight }; // Create sun sphere const sunGeometry = new THREE.SphereGeometry(0.3, 16, 16); const sunMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00, emissive: 0xffff00, emissiveIntensity: 1, }); const sunSphere = new THREE.Mesh(sunGeometry, sunMaterial); scene.add(sunSphere); // Create glass sphere (fish bowl) const sphereGeometry = new THREE.SphereGeometry(4, 32, 32); const glassMaterial = new THREE.MeshPhysicalMaterial({ transparent: true, opacity: 0.3, roughness: 0, transmission: 1, thickness: 0.5, clearcoat: 1, clearcoatRoughness: 0, }); const sphere = new THREE.Mesh(sphereGeometry, glassMaterial); scene.add(sphere); // Create brown disk base const diskGeometry = new THREE.CircleGeometry(3, 32); const diskMaterial = new THREE.MeshStandardMaterial({ color: 0x8B4513, roughness: 0.8, metalness: 0.2 }); const disk = new THREE.Mesh(diskGeometry, diskMaterial); disk.rotation.x = -Math.PI / 2; // Rotate to lay flat disk.position.y = -4; // Position at bottom of sphere scene.add(disk); // Load and setup 3D models const loader = new GLTFLoader(); const loadModel = (url, scale = 0.5, glowColor = null) => { return new Promise((resolve, reject) => { loader.load(url, (gltf) => { gltf.scene.scale.set(scale, scale, scale); // Add glow effect if color is specified if (glowColor) { gltf.scene.traverse((child) => { if (child.isMesh) { // Create a new material with enhanced glow for bioluminescent algae const glowMaterial = new THREE.MeshStandardMaterial({ ...child.material, emissive: new THREE.Color(glowColor), emissiveIntensity: url.includes('bioluminescent') ? 1.5 : 0.5, // Triple glow for bioluminescent algae toneMapped: false }); child.material = glowMaterial; } }); } resolve(gltf.scene); }, undefined, reject); }); }; // Load all models Promise.all([ loadModel('https://play.rosebud.ai/assets/algae.glb?KQ0s', 0.0714, 0x008800), // Darker green glow loadModel('https://play.rosebud.ai/assets/bacteria.glb?23JF', 0.0216, 0xff0000), // Red glow loadModel('https://play.rosebud.ai/assets/ameba.glb?vCQM', 0.131625, 0x00ffff), // Cyan glow loadModel('https://play.rosebud.ai/assets/bioluminescent algae.glb?NZtv', 0.011156, 0x00ff00), // Bioluminescent algae loadModel('https://play.rosebud.ai/assets/vertical algae.glb?Ta9s', 0.237762, 0x004400), // Dark green glow loadModel('https://play.rosebud.ai/assets/anaerobic bacteria.glb?QZRw', 0.00648, 0xff8c00) // Orange glow for anaerobic bacteria (80% smaller) ]).then(([algae, bacteria, ameba, bioluminescentAlgae, verticalAlgae, anaerobicBacteria]) => { // Store templates first templateModelsRef.current = { algae, bacteria, ameba, bioluminescentAlgae, verticalAlgae, anaerobicBacteria }; // Initialize populations after templates are loaded // Initial algae population // Initialize only algae population for (let i = 0; i < 2; i++) { addOrganism('algae'); } // Log template storage console.log('Templates stored:', { algae: !!templateModelsRef.current.algae, bacteria: !!templateModelsRef.current.bacteria, ameba: !!templateModelsRef.current.ameba }); // Position models inside sphere with random positions within bounds algae.position.set( Math.random() * 3 - 1.5, // x: -1.5 to 1.5 -2 + Math.random(), // y: -2 to -1 Math.random() * 2 - 1 // z: -1 to 1 ); bacteria.position.set( Math.random() * 3 - 1.5, -1 + Math.random() * 2, Math.random() * 2 - 1 ); ameba.position.set( Math.random() * 3 - 1.5, Math.random() * 2, Math.random() * 2 - 1 ); // Store models for animation modelsRef.current = { algae: populationRef.current.algae.map(() => { const model = algae.clone(); model.position.set( Math.random() * 3 - 1.5, -2 + Math.random(), Math.random() * 2 - 1 ); scene.add(model); return model; }), bacteria: populationRef.current.bacteria.map(() => { const model = bacteria.clone(); model.position.set( Math.random() * 3 - 1.5, -1 + Math.random() * 2, Math.random() * 2 - 1 ); scene.add(model); return model; }), ameba: populationRef.current.ameba.map(() => { const model = ameba.clone(); model.position.set( Math.random() * 3 - 1.5, Math.random() * 2, Math.random() * 2 - 1 ); scene.add(model); return model; }) }; }).catch(error => console.error('Error loading models:', error)); const renderer = new THREE.WebGLRenderer({ alpha: true, antialias: true, logarithmicDepthBuffer: true }); renderer.setClearColor(0x87CEEB, 1); // Add orbit controls const controls = new OrbitControls(camera, renderer.domElement); controls.enableDamping = true; // Smooth camera movement controls.dampingFactor = 0.05; controls.minDistance = 4; // Minimum zoom distance (closer to sphere) controls.maxDistance = 50; // Maximum zoom distance (much further out) controls.maxPolarAngle = Math.PI / 1.5; // Limit vertical rotation controls.minPolarAngle = Math.PI / 4; // Limit vertical rotation // Handle window resizing const handleResize = () => { const width = window.innerWidth; const height = window.innerHeight; const pixelRatio = window.devicePixelRatio; camera.aspect = width / height; camera.updateProjectionMatrix(); renderer.setSize(width, height); renderer.setPixelRatio(pixelRatio); // Position camera for better initial view camera.position.set(15, 8, 15); camera.lookAt(0, -2, 0); }; // Initial setup renderer.setPixelRatio(window.devicePixelRatio); mountRef.current.appendChild(renderer.domElement); handleResize(); // Call once to set initial dimensions window.addEventListener('resize', handleResize); // Animation const animate = () => { requestAnimationFrame(animate); controls.update(); // Update time of day timeRef.current = (timeRef.current + 1/(60 * 60)) % 1; // Complete cycle in 60 seconds // Calculate sun and moon positions const sunAngle = timeRef.current * Math.PI * 2; const moonAngle = sunAngle + Math.PI; // Update light and sun sphere positions const sunDistance = 10; const sunX = Math.cos(sunAngle) * sunDistance; const sunY = Math.sin(sunAngle) * sunDistance; lightsRef.current.sun.position.x = sunX; lightsRef.current.sun.position.y = sunY; // Update sun sphere position sunSphere.position.set(sunX, sunY, 0); // Hide sun sphere during night sunSphere.visible = Math.sin(sunAngle) > 0; lightsRef.current.moon.position.x = Math.cos(moonAngle) * 10; lightsRef.current.moon.position.y = Math.sin(moonAngle) * 10; // Update light intensities const dayIntensity = Math.sin(sunAngle) < 0 ? 0 : Math.sin(sunAngle); const nightIntensity = Math.sin(moonAngle) < 0 ? 0 : Math.sin(moonAngle) * 0.1; lightsRef.current.sun.intensity = dayIntensity; lightsRef.current.moon.intensity = Math.max(0.01, nightIntensity); // Minimum moonlight intensity of 0.01 lightsRef.current.ambient.intensity = 0.03 + dayIntensity * 0.35; // Base ambient light of 0.03 during night // Update ecosystem stats const calculateStats = (organisms, populationData) => { // Initialize default stats const defaultStats = { total: 0, adults: 0, children: 0, avgNutrition: 0 }; // Check if data exists and is valid if (!organisms || !populationData) return defaultStats; if (!Array.isArray(organisms) || !Array.isArray(populationData)) return defaultStats; if (organisms.length === 0 || populationData.length === 0) return defaultStats; // Ensure arrays are of equal length and contain valid data const validLength = Math.min(organisms.length, populationData.length); const validPopulation = populationData.slice(0, validLength).filter(o => o && typeof o.nutrition === 'number'); const total = organisms.length; const adults = populationData.filter(o => o && o.nutrition >= 1.5).length; const children = total - adults; const avgNutrition = populationData.reduce((sum, o) => sum + (o ? o.nutrition || 0 : 0), 0) / total || 0; return { total, adults, children, avgNutrition }; }; setEcosystemStats(prev => ({ ...prev, lightIntensity: dayIntensity, oxygenLevel: prev.oxygenLevel, algae: calculateStats(modelsRef.current.algae, populationRef.current.algae), bacteria: calculateStats(modelsRef.current.bacteria, populationRef.current.bacteria), ameba: calculateStats(modelsRef.current.ameba, populationRef.current.ameba), bioluminescentAlgae: calculateStats( modelsRef.current.bioluminescentAlgae, populationRef.current.bioluminescentAlgae ), verticalAlgae: calculateStats( modelsRef.current.verticalAlgae, populationRef.current.verticalAlgae ), anaerobicBacteria: calculateStats( modelsRef.current.anaerobicBacteria, populationRef.current.anaerobicBacteria ) })); // Update scene colors const dayColor = new THREE.Color(0x87CEEB); // Sky blue const nightColor = new THREE.Color(0x020305); // Almost black with slight blue tint const currentColor = dayColor.lerp(nightColor, 1 - dayIntensity); scene.fog.color.copy(currentColor); renderer.setClearColor(currentColor); // Animate models and handle food chain if (modelsRef.current.algae) { // Update each algae modelsRef.current.algae.forEach((algae, index) => { if (populationRef.current.algae[index].nutrition <= 0) { scene.remove(algae); return; } // Algae grows with sunlight and dies without it if (dayIntensity > 0) { // Increased nutrition gain based on light intensity const nutritionGain = dayIntensity * 0.003; // Tripled from 0.001 populationRef.current.algae[index].nutrition += nutritionGain; // Oxygen production by algae during photosynthesis setEcosystemStats(prev => ({ ...prev, oxygenLevel: Math.min(100, prev.oxygenLevel + (dayIntensity * 0.01)) })); } else { // Lose nutrition during dark periods populationRef.current.algae[index].nutrition -= 0.0005; } // Floating motion for algae const time = Date.now() * 0.001; const floatAmplitude = 0.1; const floatFrequency = 0.5; // Calculate new position with floating motion algae.position.y += Math.sin(time * floatFrequency) * 0.0004; // Decreased by 20% from 0.0005 // Keep algae within sphere bounds const distance = algae.position.length(); if (distance > 3.5) { algae.position.normalize().multiplyScalar(3.5); } algae.rotation.y += 0.005; // Reproduction check if (populationRef.current.algae[index].nutrition >= 1.9) { let newAlgaeCreated = false; let attempts = 0; while (!newAlgaeCreated && attempts < 10) { // Calculate offset within a sphere const radius = 0.4; const theta = Math.random() * Math.PI * 2; const phi = Math.random() * Math.PI; const offsetX = radius * Math.sin(phi) * Math.cos(theta); const offsetY = radius * Math.sin(phi) * Math.sin(theta); const offsetZ = radius * Math.cos(phi); const safePosition = new THREE.Vector3( algae.position.x + offsetX, algae.position.y + offsetY, algae.position.z + offsetZ ); // Keep within sphere bounds if (safePosition.length() > 3.5) { safePosition.normalize().multiplyScalar(3.5); } // Check distance from predators with more lenient distances const isSafe = (!modelsRef.current.bacteria || !modelsRef.current.bacteria.some(b => b.position.distanceTo(safePosition) < 0.5)) && // More lenient distance from bacteria (!modelsRef.current.ameba || !modelsRef.current.ameba.some(a => a.position.distanceTo(safePosition) < 0.8)); // More lenient distance from ameba if (isSafe) { const newAlgae = algae.clone(); newAlgae.position.copy(safePosition); scene.add(newAlgae); modelsRef.current.algae.push(newAlgae); populationRef.current.algae.push({ nutrition: 1, createdAt: Date.now(), maxAge: 85000 + Math.random() * 10000 // Random lifespan between 85-95 seconds }); newAlgaeCreated = true; // Reset parent's nutrition populationRef.current.algae[index].nutrition = 1; // Award point for successful reproduction setPoints(prev => prev + 1); } attempts++; } // Reset parent's nutrition populationRef.current.algae[index].nutrition = 1; } }); // Remove dead algae // Filter and remove dead algae const deadAlgaeIndices = []; modelsRef.current.algae.forEach((algae, index) => { const organism = populationRef.current.algae[index]; if (!algae || !organism || organism.nutrition <= 0 || Date.now() - organism.createdAt > (organism.maxAge || 90000)) { // Die when reaching individual max age deadAlgaeIndices.push(index); scene.remove(algae); algae?.traverse((child) => { if (child?.isMesh) { child.geometry?.dispose(); if (Array.isArray(child.material)) { child.material.forEach(material => material?.dispose()); } else { child.material?.dispose(); } } }); } }); // Remove dead algae from both arrays modelsRef.current.algae = modelsRef.current.algae.filter((_, index) => !deadAlgaeIndices.includes(index) ); populationRef.current.algae = populationRef.current.algae.filter((_, index) => !deadAlgaeIndices.includes(index) ); } // Handle vertical algae if (modelsRef.current.verticalAlgae) { modelsRef.current.verticalAlgae.forEach((algae, index) => { if (populationRef.current.verticalAlgae[index].nutrition <= 0) { scene.remove(algae); return; } // Vertical algae grows with sunlight and dies without it if (dayIntensity > 0) { const nutritionGain = dayIntensity * 0.003; populationRef.current.verticalAlgae[index].nutrition += nutritionGain; // Double oxygen production setEcosystemStats(prev => ({ ...prev, oxygenLevel: Math.min(100, prev.oxygenLevel + (dayIntensity * 0.02)) })); } else { // Lose nutrition during dark periods populationRef.current.verticalAlgae[index].nutrition -= 0.0005; } // Seaweed-like swaying motion const time = Date.now() * 0.001; const swayAmplitudeX = 0.15; const swayAmplitudeZ = 0.1; const swayFrequencyX = 0.8; const swayFrequencyZ = 1.2; // Complex swaying motion combining multiple sine waves algae.rotation.x = Math.sin(time * swayFrequencyX) * 0.05; algae.rotation.z = Math.sin(time * swayFrequencyZ + algae.position.x) * swayAmplitudeX + Math.sin(time * 0.5) * swayAmplitudeZ; // Keep base position fixed and anchored inside the disk algae.position.y = Math.max(algae.position.y, -4.1); // Reproduction check (requires double energy) if (populationRef.current.verticalAlgae[index].nutrition >= 3.8) { let newAlgaeCreated = false; let attempts = 0; while (!newAlgaeCreated && attempts < 10) { // Calculate offset for new position const radius = 0.4; const angle = Math.random() * Math.PI * 2; const offsetX = Math.cos(angle) * radius; const offsetZ = Math.sin(angle) * radius; const safePosition = new THREE.Vector3( algae.position.x + offsetX, -3.8 + (Math.random() * 0.2), // Stay at bottom algae.position.z + offsetZ ); // Check if position is safe const isSafe = (!modelsRef.current.bacteria || !modelsRef.current.bacteria.some(b => b.position.distanceTo(safePosition) < 0.5)); if (isSafe) { const newAlgae = algae.clone(); newAlgae.position.copy(safePosition); scene.add(newAlgae); modelsRef.current.verticalAlgae.push(newAlgae); populationRef.current.verticalAlgae.push({ nutrition: 1, createdAt: Date.now() }); newAlgaeCreated = true; // Reset parent's nutrition after reproduction populationRef.current.verticalAlgae[index].nutrition = 1; // Award point for successful reproduction setPoints(prev => prev + 1); } attempts++; } } }); // Remove dead vertical algae const deadVerticalAlgaeIndices = []; modelsRef.current.verticalAlgae.forEach((algae, index) => { const organism = populationRef.current.verticalAlgae[index]; if (!algae || !organism || organism.nutrition <= 0 || Date.now() - organism.createdAt > 90000) { deadVerticalAlgaeIndices.push(index); scene.remove(algae); algae?.traverse((child) => { if (child?.isMesh) { child.geometry?.dispose(); if (Array.isArray(child.material)) { child.material.forEach(material => material?.dispose()); } else { child.material?.dispose(); } } }); } }); modelsRef.current.verticalAlgae = modelsRef.current.verticalAlgae.filter((_, index) => !deadVerticalAlgaeIndices.includes(index) ); populationRef.current.verticalAlgae = populationRef.current.verticalAlgae.filter((_, index) => !deadVerticalAlgaeIndices.includes(index) ); } // Handle bioluminescent algae - similar to regular algae but produces energy regardless of light if (modelsRef.current.bioluminescentAlgae) { modelsRef.current.bioluminescentAlgae.forEach((algae, index) => { if (populationRef.current.bioluminescentAlgae[index].nutrition <= 0) { scene.remove(algae); return; } // Reduced nutrition gain for bioluminescent algae const nutritionGain = 0.0008; // Significantly reduced from 0.003 populationRef.current.bioluminescentAlgae[index].nutrition += nutritionGain; // Reduced oxygen production setEcosystemStats(prev => ({ ...prev, oxygenLevel: Math.min(100, prev.oxygenLevel + 0.003) })); // Floating motion const time = Date.now() * 0.001; // Add constant upward motion plus gentle wave movement algae.position.y += 0.001; // Constant upward drift algae.position.x += Math.sin(time * 0.5) * 0.0002; // Gentle side-to-side motion algae.position.z += Math.cos(time * 0.5) * 0.0002; // Gentle front-to-back motion // Keep within sphere bounds with special handling for upper limit const distance = algae.position.length(); if (distance > 3.5 || algae.position.y > 3) { // Reset to bottom when reaching the top if (algae.position.y > 3) { algae.position.y = -2 + Math.random(); algae.position.x = (Math.random() * 2 - 1) * 2; algae.position.z = (Math.random() * 2 - 1) * 2; } else { algae.position.normalize().multiplyScalar(3.5); } } algae.rotation.y += 0.005; // Reproduction check if (populationRef.current.bioluminescentAlgae[index].nutrition >= 1.7) { let newAlgaeCreated = false; let attempts = 0; while (!newAlgaeCreated && attempts < 10) { const radius = 0.4; const theta = Math.random() * Math.PI * 2; const phi = Math.random() * Math.PI; const offsetX = radius * Math.sin(phi) * Math.cos(theta); const offsetY = radius * Math.sin(phi) * Math.sin(theta); const offsetZ = radius * Math.cos(phi); const safePosition = new THREE.Vector3( algae.position.x + offsetX, algae.position.y + offsetY, algae.position.z + offsetZ ); if (safePosition.length() > 3.5) { safePosition.normalize().multiplyScalar(3.5); } const isSafe = (!modelsRef.current.bacteria || !modelsRef.current.bacteria.some(b => b.position.distanceTo(safePosition) < 0.5)) && (!modelsRef.current.ameba || !modelsRef.current.ameba.some(a => a.position.distanceTo(safePosition) < 0.8)); if (isSafe) { const newAlgae = algae.clone(); newAlgae.position.copy(safePosition); scene.add(newAlgae); modelsRef.current.bioluminescentAlgae.push(newAlgae); populationRef.current.bioluminescentAlgae.push({ nutrition: 1 }); newAlgaeCreated = true; populationRef.current.bioluminescentAlgae[index].nutrition = 1; // Award point for successful reproduction setPoints(prev => prev + 1); } attempts++; } } }); // Remove dead bioluminescent algae modelsRef.current.bioluminescentAlgae = modelsRef.current.bioluminescentAlgae.filter((_, index) => populationRef.current.bioluminescentAlgae[index].nutrition > 0 ); populationRef.current.bioluminescentAlgae = populationRef.current.bioluminescentAlgae.filter(a => a.nutrition > 0 ); } if (modelsRef.current.bacteria) { // Remove dependency on algae presence // Filter and remove dead bacteria // Filter and remove dead bacteria const deadBacteriaIndices = []; modelsRef.current.bacteria.forEach((bacteria, index) => { const organism = populationRef.current.bacteria[index]; if (!bacteria || !organism || organism.nutrition <= 0 || Date.now() - organism.createdAt > 90000) { // Die after 90 seconds deadBacteriaIndices.push(index); scene.remove(bacteria); bacteria?.traverse((child) => { if (child?.isMesh) { child.geometry?.dispose(); if (Array.isArray(child.material)) { child.material.forEach(material => material?.dispose()); } else { child.material?.dispose(); } } }); } }); // Remove dead bacteria from both arrays modelsRef.current.bacteria = modelsRef.current.bacteria.filter((_, index) => !deadBacteriaIndices.includes(index) ); populationRef.current.bacteria = populationRef.current.bacteria.filter((_, index) => !deadBacteriaIndices.includes(index) ); // Update remaining bacteria modelsRef.current.bacteria.forEach((bacteria, index) => { // Find nearest prey (either regular or bioluminescent algae) let nearestPrey = null; let minDistance = Infinity; let preyType = null; // Check regular algae modelsRef.current.algae?.forEach((algae, algaeIndex) => { const distance = bacteria.position.distanceTo(algae.position); if (distance < minDistance) { minDistance = distance; nearestPrey = { model: algae, index: algaeIndex }; preyType = 'algae'; } }); // Check bioluminescent algae modelsRef.current.bioluminescentAlgae?.forEach((algae, algaeIndex) => { const distance = bacteria.position.distanceTo(algae.position); if (distance < minDistance) { minDistance = distance; nearestPrey = { model: algae, index: algaeIndex }; preyType = 'bioluminescentAlgae'; } }); if (nearestPrey && preyType) { const directionToPrey = new THREE.Vector3().subVectors( nearestPrey.model.position, bacteria.position ); if (minDistance > 0.5) { // Move towards prey bacteria.position.add(directionToPrey.normalize().multiplyScalar(0.00271)); // Increased by 25% } else { // Consume prey when close const nutritionGain = preyType === 'bioluminescentAlgae' ? 0.006 : 0.005; // Bioluminescent algae provide more nutrition populationRef.current.bacteria[index].nutrition += nutritionGain; // Damage the prey populationRef.current[preyType][nearestPrey.index].nutrition -= nutritionGain * 2; // Check if bacteria should die from overeating if (populationRef.current.bacteria[index].nutrition > 3) { populationRef.current.bacteria[index].nutrition = 0; } } } bacteria.rotation.z += 0.003; // Reproduction check if (populationRef.current.bacteria[index].nutrition >= 1.5) { // Create new bacteria // Find safe position for new bacteria let safePosition; let attempts = 0; do { safePosition = new THREE.Vector3( bacteria.position.x + (Math.random() * 1.2 - 0.6), bacteria.position.y + (Math.random() * 1.2 - 0.6), bacteria.position.z + (Math.random() * 1.2 - 0.6) ); // Check distance from ameba const isSafe = !modelsRef.current.ameba || !modelsRef.current.ameba.some(a => a.position.distanceTo(safePosition) < 1.2); if (isSafe || attempts > 10) { const newBacteria = bacteria.clone(); newBacteria.position.copy(safePosition); scene.add(newBacteria); modelsRef.current.bacteria.push(newBacteria); populationRef.current.bacteria.push({ nutrition: 1, createdAt: Date.now() }); break; } attempts++; } while (true); // Reset parent's nutrition populationRef.current.bacteria[index].nutrition = 1; // Award point for successful reproduction setPoints(prev => prev + 1); } // Natural decrease and oxygen consumption let nutritionLoss = 0.001; // Base nutrition loss // Increased starvation when no prey available const noPreyAvailable = (!modelsRef.current.algae || modelsRef.current.algae.length === 0) && (!modelsRef.current.bioluminescentAlgae || modelsRef.current.bioluminescentAlgae.length === 0); if (noPreyAvailable) { nutritionLoss += 0.0004; // Starvation rate when no prey exists (halved) } else if (!nearestPrey || minDistance > 2) { nutritionLoss += 0.0002; // Mild hunger when prey is too far (halved) } // Additional loss in darkness if (dayIntensity <= 0) { nutritionLoss += 0.001; } // Apply total nutrition loss populationRef.current.bacteria[index].nutrition = Math.max( 0, populationRef.current.bacteria[index].nutrition - nutritionLoss ); // Each bacteria consumes oxygen continuously while alive setEcosystemStats(prev => ({ ...prev, oxygenLevel: Math.max(0, prev.oxygenLevel - 0.01) // Double oxygen consumption for bacteria })); // Bacteria dies faster if no oxygen if (ecosystemStats.oxygenLevel <= 0) { populationRef.current.bacteria[index].nutrition -= 0.1; } }); // Natural decrease for all bacteria populationRef.current.bacteria.forEach((bacteria, index) => { bacteria.nutrition -= 0.001; }); } if (modelsRef.current.ameba) { // Remove dependency on bacteria presence // Update each ameba modelsRef.current.ameba.forEach((ameba, index) => { if (populationRef.current.ameba[index].nutrition <= 0) { scene.remove(ameba); return; } // Find nearest bacteria let nearestBacteria = null; let minDistance = Infinity; modelsRef.current.bacteria.forEach((bacteria, bacteriaIndex) => { // Only consider bacteria that are alive (nutrition > 0) if (populationRef.current.bacteria[bacteriaIndex].nutrition > 0) { const distance = ameba.position.distanceTo(bacteria.position); if (distance < minDistance) { minDistance = distance; nearestBacteria = { model: bacteria, index: bacteriaIndex }; } } }); if (nearestBacteria) { const directionToBacteria = new THREE.Vector3().subVectors( nearestBacteria.model.position, ameba.position ); if (minDistance > 0.5) { ameba.position.add(directionToBacteria.normalize().multiplyScalar(0.004660)); // Increased by additional 20% } else { // Consume bacteria when close const nutritionGain = 0.008; // Reduced from 0.015 populationRef.current.ameba[index].nutrition += nutritionGain; populationRef.current.bacteria[nearestBacteria.index].nutrition -= nutritionGain * 2; } } ameba.rotation.x += 0.002; // Reproduction check if (populationRef.current.ameba[index].nutrition >= 1.4) { // Create new ameba // Find safe position for new ameba let safePosition; let attempts = 0; do { safePosition = new THREE.Vector3( ameba.position.x + (Math.random() * 1.2 - 0.6), ameba.position.y + (Math.random() * 1.2 - 0.6), ameba.position.z + (Math.random() * 1.2 - 0.6) ); // Check distance from other ameba const isSafe = !modelsRef.current.ameba.some(a => a !== ameba && a.position.distanceTo(safePosition) < 1.5); if (isSafe || attempts > 10) { const newAmeba = ameba.clone(); newAmeba.position.copy(safePosition); scene.add(newAmeba); modelsRef.current.ameba.push(newAmeba); populationRef.current.ameba.push({ nutrition: 1, createdAt: Date.now() }); break; } attempts++; } while (true); // Reset parent's nutrition populationRef.current.ameba[index].nutrition = 1; // Award point for successful reproduction setPoints(prev => prev + 1); } // Natural decrease and oxygen consumption let nutritionLoss = 0.0015; // Base nutrition loss // Increased starvation when no prey available if (!modelsRef.current.bacteria || modelsRef.current.bacteria.length === 0) { nutritionLoss += 0.0003; // Halved starvation penalty } else if (!nearestBacteria || minDistance > 2) { nutritionLoss += 0.0002; // Halved distance penalty } // Additional loss in darkness if (dayIntensity <= 0) { nutritionLoss += 0.001; } // Apply total nutrition loss populationRef.current.ameba[index].nutrition = Math.max( 0, populationRef.current.ameba[index].nutrition - nutritionLoss ); // Each ameba consumes more oxygen than bacteria setEcosystemStats(prev => ({ ...prev, oxygenLevel: Math.max(0, prev.oxygenLevel - 0.03) // Triple oxygen consumption for ameba })); // Ameba dies faster if no oxygen if (ecosystemStats.oxygenLevel <= 0) { populationRef.current.ameba[index].nutrition -= 0.15; } }); // Filter and remove dead ameba // Filter and remove dead ameba const deadAmebaIndices = []; modelsRef.current.ameba.forEach((ameba, index) => { const organism = populationRef.current.ameba[index]; if (!ameba || !organism || organism.nutrition <= 0 || Date.now() - organism.createdAt > 90000) { // Die after 90 seconds deadAmebaIndices.push(index); scene.remove(ameba); ameba?.traverse((child) => { if (child?.isMesh) { child.geometry?.dispose(); if (Array.isArray(child.material)) { child.material.forEach(material => material?.dispose()); } else { child.material?.dispose(); } } }); } }); // Remove dead ameba from both arrays modelsRef.current.ameba = modelsRef.current.ameba.filter((_, index) => !deadAmebaIndices.includes(index) ); populationRef.current.ameba = populationRef.current.ameba.filter((_, index) => !deadAmebaIndices.includes(index) ); } // Handle anaerobic bacteria if (modelsRef.current.anaerobicBacteria) { modelsRef.current.anaerobicBacteria.forEach((bacteria, index) => { // Find nearest prey (either regular or bioluminescent algae) let nearestPrey = null; let minDistance = Infinity; let preyType = null; // Check regular algae modelsRef.current.algae?.forEach((algae, algaeIndex) => { const distance = bacteria.position.distanceTo(algae.position); if (distance < minDistance) { minDistance = distance; nearestPrey = { model: algae, index: algaeIndex }; preyType = 'algae'; } }); // Check bioluminescent algae modelsRef.current.bioluminescentAlgae?.forEach((algae, algaeIndex) => { const distance = bacteria.position.distanceTo(algae.position); if (distance < minDistance) { minDistance = distance; nearestPrey = { model: algae, index: algaeIndex }; preyType = 'bioluminescentAlgae'; } }); if (nearestPrey && preyType) { const directionToPrey = new THREE.Vector3().subVectors( nearestPrey.model.position, bacteria.position ); if (minDistance > 0.5) { // Move towards prey bacteria.position.add(directionToPrey.normalize().multiplyScalar(0.00271)); // Increased by 25% } else { // Consume prey when close const nutritionGain = preyType === 'bioluminescentAlgae' ? 0.006 : 0.005; populationRef.current.anaerobicBacteria[index].nutrition += nutritionGain; // Damage the prey populationRef.current[preyType][nearestPrey.index].nutrition -= nutritionGain * 2; // Check if bacteria should die from overeating if (populationRef.current.anaerobicBacteria[index].nutrition > 3) { populationRef.current.anaerobicBacteria[index].nutrition = 0; } } } bacteria.rotation.z += 0.003; // Reproduction check if (populationRef.current.anaerobicBacteria[index].nutrition >= 1.5) { let safePosition; let attempts = 0; do { safePosition = new THREE.Vector3( bacteria.position.x + (Math.random() * 1.2 - 0.6), bacteria.position.y + (Math.random() * 1.2 - 0.6), bacteria.position.z + (Math.random() * 1.2 - 0.6) ); // Check distance from ameba const isSafe = !modelsRef.current.ameba || !modelsRef.current.ameba.some(a => a.position.distanceTo(safePosition) < 1.2); if (isSafe || attempts > 10) { const newBacteria = bacteria.clone(); newBacteria.position.copy(safePosition); scene.add(newBacteria); modelsRef.current.anaerobicBacteria.push(newBacteria); populationRef.current.anaerobicBacteria.push({ nutrition: 1, createdAt: Date.now() }); break; } attempts++; } while (true); // Reset parent's nutrition populationRef.current.anaerobicBacteria[index].nutrition = 1; // Award point for successful reproduction setPoints(prev => prev + 1); } // Natural decrease (but no oxygen dependency) let nutritionLoss = 0.001; // Base nutrition loss // Increased starvation when no prey available const noPreyAvailable = (!modelsRef.current.algae || modelsRef.current.algae.length === 0) && (!modelsRef.current.bioluminescentAlgae || modelsRef.current.bioluminescentAlgae.length === 0); if (noPreyAvailable) { nutritionLoss += 0.0004; // Halved starvation penalty for anaerobic bacteria } else if (!nearestPrey || minDistance > 2) { nutritionLoss += 0.0002; // Halved distance penalty } // Apply total nutrition loss populationRef.current.anaerobicBacteria[index].nutrition = Math.max( 0, populationRef.current.anaerobicBacteria[index].nutrition - nutritionLoss ); }); // Remove dead anaerobic bacteria const deadAnaerobicBacteriaIndices = []; modelsRef.current.anaerobicBacteria.forEach((bacteria, index) => { const organism = populationRef.current.anaerobicBacteria[index]; if (!bacteria || !organism || organism.nutrition <= 0 || Date.now() - organism.createdAt > 90000) { deadAnaerobicBacteriaIndices.push(index); scene.remove(bacteria); bacteria?.traverse((child) => { if (child?.isMesh) { child.geometry?.dispose(); if (Array.isArray(child.material)) { child.material.forEach(material => material?.dispose()); } else { child.material?.dispose(); } } }); } }); modelsRef.current.anaerobicBacteria = modelsRef.current.anaerobicBacteria.filter((_, index) => !deadAnaerobicBacteriaIndices.includes(index) ); populationRef.current.anaerobicBacteria = populationRef.current.anaerobicBacteria.filter((_, index) => !deadAnaerobicBacteriaIndices.includes(index) ); } renderer.render(scene, camera); }; animate(); // Cleanup return () => { // Stop and cleanup audio if (audioRef.current) { audioRef.current.pause(); audioRef.current.src = ''; audioRef.current = null; } window.removeEventListener('resize', handleResize); if (mountRef.current && mountRef.current.contains(renderer.domElement)) { mountRef.current.removeChild(renderer.domElement); } controls.dispose(); // Clean up controls renderer.dispose(); sphereGeometry.dispose(); glassMaterial.dispose(); diskGeometry.dispose(); diskMaterial.dispose(); sunGeometry.dispose(); sunMaterial.dispose(); }; }, [gameStarted]); const addOrganism = useCallback((type) => { // Check if player has enough points if (points < organismCosts[type]) { console.warn(`Not enough points to add ${type}. Need ${organismCosts[type]} points`); return; } // Check if templates are loaded if (!templateModelsRef.current || !templateModelsRef.current[type]) { console.error('Templates not loaded yet or invalid type:', type); return; } // Get scene from ref const scene = sceneRef.current; if (!scene) { console.error('Scene not found'); return; } console.log('Scene accessed successfully:', { children: scene.children.length, isScene: scene instanceof THREE.Scene }); // Get template from stored templates const template = templateModelsRef.current[type]; if (!template) { console.error('No template found for organism type:', type); console.log('Available templates:', Object.keys(templateModelsRef.current)); console.log('Template ref state:', templateModelsRef.current); return; } // Create new organism const newOrganism = template.clone(); if (!newOrganism) { console.error('Failed to clone organism'); return; } // Random position within sphere bounds const radius = Math.random() * 2.5; const theta = Math.random() * Math.PI * 2; const phi = Math.acos((Math.random() * 2) - 1); // Set position based on organism type with better vertical distribution let verticalPosition; switch(type) { case 'algae': case 'bioluminescentAlgae': verticalPosition = -2 + (Math.random() * 0.5); // Bottom layer: -2 to -1.5 break; case 'verticalAlgae': verticalPosition = -4.1 + (Math.random() * 0.2); // Deeper in disk: -4.1 to -3.9 break; case 'bacteria': case 'anaerobicBacteria': verticalPosition = -1 + (Math.random() * 1.5); // Middle layer: -1 to 0.5 break; case 'ameba': verticalPosition = Math.random() * 1.5; // Top layer: 0 to 1.5 break; default: verticalPosition = Math.random() * 2 - 1; // Fallback: -1 to 1 } // Calculate and validate position const x = radius * Math.sin(phi) * Math.cos(theta); const y = verticalPosition; const z = radius * Math.sin(phi) * Math.sin(theta); // Validate position is within bounds if (Math.abs(x) > 3.5 || Math.abs(y) > 3.5 || Math.abs(z) > 3.5) { console.warn('Position out of bounds, normalizing...'); const scale = 3.5 / Math.max(Math.abs(x), Math.abs(y), Math.abs(z)); newOrganism.position.set(x * scale, y * scale, z * scale); } else { newOrganism.position.set(x, y, z); } // Log position for verification console.log(`Adding ${type} at position:`, { x: newOrganism.position.x.toFixed(2), y: newOrganism.position.y.toFixed(2), z: newOrganism.position.z.toFixed(2) }); // Initialize arrays if they don't exist if (!modelsRef.current[type]) { modelsRef.current[type] = []; } if (!populationRef.current[type]) { populationRef.current[type] = []; } // Add to scene and update tracking arrays scene.add(newOrganism); modelsRef.current[type].push(newOrganism); // Deduct points for adding organism setPoints(prev => prev - organismCosts[type]); populationRef.current[type].push({ nutrition: 1, createdAt: Date.now(), maxAge: 85000 + Math.random() * 10000 // Random lifespan between 85-95 seconds }); console.log(`Added new ${type} successfully`, { position: newOrganism.position, totalPopulation: modelsRef.current[type].length }); }, []); if (!gameStarted) { return setGameStarted(true)} />; } return (

Ecosystem Stats

Points: {points}

Light: {((ecosystemStats?.lightIntensity || 0) * 100).toFixed(1)}%

O₂: {(ecosystemStats?.oxygenLevel || 0).toFixed(1)}%

Biomass: {( (ecosystemStats.algae.total * ecosystemStats.algae.avgNutrition) + (ecosystemStats.bacteria.total * ecosystemStats.bacteria.avgNutrition) + (ecosystemStats.ameba.total * ecosystemStats.ameba.avgNutrition) + (ecosystemStats.bioluminescentAlgae.total * ecosystemStats.bioluminescentAlgae.avgNutrition) + (ecosystemStats.verticalAlgae.total * ecosystemStats.verticalAlgae.avgNutrition) + (ecosystemStats.anaerobicBacteria.total * ecosystemStats.anaerobicBacteria.avgNutrition) ).toFixed(1)}

Algae:

Pop: {ecosystemStats.algae.total}

Adult: {ecosystemStats.algae.adults}

Child: {ecosystemStats.algae.children}

Nutr: {ecosystemStats.algae.avgNutrition.toFixed(2)}

Bacteria:

Pop: {ecosystemStats.bacteria.total}

Adult: {ecosystemStats.bacteria.adults}

Child: {ecosystemStats.bacteria.children}

Nutr: {ecosystemStats.bacteria.avgNutrition.toFixed(2)}

Ameba:

Pop: {ecosystemStats.ameba.total}

Adult: {ecosystemStats.ameba.adults}

Child: {ecosystemStats.ameba.children}

Nutr: {ecosystemStats.ameba.avgNutrition.toFixed(2)}

Bio Algae:

Pop: {ecosystemStats.bioluminescentAlgae.total}

Adult: {ecosystemStats.bioluminescentAlgae.adults}

Child: {ecosystemStats.bioluminescentAlgae.children}

Nutr: {ecosystemStats.bioluminescentAlgae.avgNutrition.toFixed(2)}

Vert Algae:

Pop: {ecosystemStats.verticalAlgae.total}

Adult: {ecosystemStats.verticalAlgae.adults}

Child: {ecosystemStats.verticalAlgae.children}

Nutr: {ecosystemStats.verticalAlgae.avgNutrition.toFixed(2)}

Ana Bacteria:

Pop: {ecosystemStats.anaerobicBacteria.total}

Adult: {ecosystemStats.anaerobicBacteria.adults}

Child: {ecosystemStats.anaerobicBacteria.children}

Nutr: {ecosystemStats.anaerobicBacteria.avgNutrition.toFixed(2)}

Add Organism

); }; // Create HTML container for itch.io document.body.innerHTML = ` Ecosystem Simulator

`; const container = document.getElementById('renderDiv'); const root = ReactDOM.createRoot(container); root.render();