[
{
"path": ".dockerignore",
"content": ".git\n.github\n__pycache__/\n*.pyc\n*.pyo\n*.pyd\n*.swp\n*.swo\n*.tmp\nlogs/\nsaves/\n.env\n.env.*\n*.zip\n*.tar\n*.tar.gz\n*.7z\n.vscode/\n.idea/\n.DS_Store\nThumbs.db"
},
{
"path": ".github/ISSUE_TEMPLATE/submit_squid.yml",
"content": "name: 🦑 Submit a Squid Save\ndescription: Share your evolved squid! (Must be a .zip containing uuid.txt)\nlabels: [\"squid-submission\"]\nbody:\n - type: input\n id: name\n attributes:\n label: Squid Nickname\n placeholder: Squid\n validations:\n required: true\n - type: input\n id: save_url\n attributes:\n label: Save File (.zip)\n description: Drag and drop your ZIP here, then copy the link.\n validations:\n required: true\n"
},
{
"path": ".github/workflows/build-nuitka.yml",
"content": "name: Build (Nuitka)\n\non:\n workflow_dispatch:\n\njobs:\n build:\n\n strategy:\n matrix:\n os: [windows-latest, ubuntu-latest, macos-latest]\n\n runs-on: ${{ matrix.os }}\n\n defaults:\n run:\n shell: bash\n\n steps:\n\n - name: Checkout repo\n uses: actions/checkout@v4\n\n - name: Setup Python\n uses: actions/setup-python@v5\n with:\n python-version: \"3.11\"\n cache: pip\n\n - name: Install dependencies\n run: |\n python -m pip install --upgrade pip\n pip install nuitka pyqt5 numpy\n\n - name: Install macOS icon dependency\n if: runner.os == 'macOS'\n run: pip install imageio\n\n # Standalone mode produces a folder of files rather than a single\n # self-extracting binary. This avoids Defender false positives on Windows\n # which flag onefile/packed executables as suspicious by default.\n # Defender is also disabled during build to prevent it quarantining\n # Nuitka's intermediate files mid-compile.\n - name: Disable Windows Defender during build\n if: runner.os == 'Windows'\n shell: pwsh\n run: |\n Set-MpPreference -DisableRealtimeMonitoring $true\n Add-MpPreference -ExclusionPath \"${{ github.workspace }}\"\n\n - name: Build executable\n run: |\n if [[ \"${{ runner.os }}\" == \"Windows\" ]]; then\n ICON_FLAG=\"--windows-icon-from-ico=images/icons/squidblack.ico\"\n elif [[ \"${{ runner.os }}\" == \"Linux\" ]]; then\n ICON_FLAG=\"--linux-icon=images/icons/squidblack.png\"\n else\n ICON_FLAG=\"--macos-app-icon=images/icons/squidblack.png\"\n fi\n\n python -m nuitka \\\n --mode=standalone \\\n --windows-console-mode=force \\\n --assume-yes-for-downloads \\\n --enable-plugin=pyqt5 \\\n --disable-plugin=options-nanny \\\n --output-dir=build \\\n --output-filename=Dosidicus \\\n --include-package=src \\\n --include-package=plugins \\\n --include-module=uuid \\\n --include-module=src.brain_designer \\\n --include-module=src.brain_designer_launcher \\\n --include-module=src.brain_state_bridge \\\n --include-module=src.designer_canvas \\\n --include-module=src.designer_canvas_utils \\\n --include-module=src.designer_constants \\\n --include-module=src.designer_core \\\n --include-module=src.designer_dialogs \\\n --include-module=src.designer_logging \\\n --include-module=src.designer_network_generator \\\n --include-module=src.designer_outputs_panel \\\n --include-module=src.designer_panels \\\n --include-module=src.designer_sensor_discovery \\\n --include-module=src.designer_templates \\\n --include-module=src.designer_window \\\n $ICON_FLAG \\\n main.py\n\n - name: Show build output\n run: find build -maxdepth 2 | sort\n\n - name: Create release directory\n run: mkdir release\n\n - name: Copy repository structure\n run: |\n for item in *; do\n case \"$item\" in\n release|dist|build|__pycache__|*.spec) ;;\n *) cp -r \"$item\" release/ 2>/dev/null || true ;;\n esac\n done\n\n - name: Remove python entrypoint\n run: rm -f release/main.py || true\n\n - name: Insert compiled executable\n run: |\n if [[ \"${{ runner.os }}\" == \"macOS\" ]]; then\n APP=$(find build -maxdepth 1 -name \"*.app\" | head -1)\n if [ -n \"$APP\" ]; then\n cp -r \"$APP\" release/Dosidicus.app\n else\n cp -r build/main.dist/. release/\n fi\n else\n cp -r build/main.dist/. release/\n fi\n\n # Ad-hoc signing suppresses some Gatekeeper warnings on macOS.\n # This is free but NOT a substitute for full notarization ($99/yr Apple\n # Developer account). Users on macOS will still need to right-click ->\n # Open -> Open Anyway the first time. Document this in your README.\n - name: Ad-hoc sign for macOS\n if: runner.os == 'macOS'\n run: |\n APP=$(find release -maxdepth 1 -name \"*.app\" | head -1)\n if [ -n \"$APP\" ]; then\n codesign --deep --force --sign - \"$APP\"\n else\n codesign --deep --force --sign - release/Dosidicus\n fi\n\n # ─── Smoke tests ────────────────────────────────────────────────────────────\n # Launch the binary, capture stdout, and look for the startup print from\n # MainWindow.__init__: \"📄 Applied language from config:\"\n # This fires after Qt initialises and all imports resolve, confirming the\n # build is not silently broken.\n\n - name: Smoke test (Linux)\n if: runner.os == 'Linux'\n run: |\n QT_QPA_PLATFORM=offscreen ./release/Dosidicus > smoke.log 2>&1 &\n PID=$!\n echo \"Started PID $PID\"\n\n # Poll for the expected startup line, up to 30s\n for i in $(seq 1 30); do\n sleep 1\n if grep -q \"Applied language from config\" smoke.log 2>/dev/null; then\n echo \"✅ Startup confirmed at ${i}s\"\n echo \"--- stdout/stderr ---\"\n cat smoke.log\n kill $PID 2>/dev/null || true\n exit 0\n fi\n # Bail early if the process already died\n if ! kill -0 $PID 2>/dev/null; then\n echo \"❌ Process exited before printing startup line\"\n echo \"--- stdout/stderr ---\"\n cat smoke.log\n exit 1\n fi\n done\n\n echo \"❌ Startup line not seen after 30s\"\n echo \"--- stdout/stderr ---\"\n cat smoke.log\n kill $PID 2>/dev/null || true\n exit 1\n\n - name: Smoke test (macOS)\n if: runner.os == 'macOS'\n run: |\n APP=$(find release -maxdepth 1 -name \"*.app\" | head -1)\n if [ -n \"$APP\" ]; then\n BIN=$(find \"$APP\" -type f -perm +111 -name \"Dosidicus\" | head -1)\n else\n BIN=release/Dosidicus\n fi\n\n \"$BIN\" > smoke.log 2>&1 &\n PID=$!\n echo \"Started PID $PID\"\n\n for i in $(seq 1 30); do\n sleep 1\n if grep -q \"Applied language from config\" smoke.log 2>/dev/null; then\n echo \"✅ Startup confirmed at ${i}s\"\n echo \"--- stdout/stderr ---\"\n cat smoke.log\n kill $PID 2>/dev/null || true\n exit 0\n fi\n if ! kill -0 $PID 2>/dev/null; then\n echo \"❌ Process exited before printing startup line\"\n echo \"--- stdout/stderr ---\"\n cat smoke.log\n exit 1\n fi\n done\n\n echo \"❌ Startup line not seen after 30s\"\n echo \"--- stdout/stderr ---\"\n cat smoke.log\n kill $PID 2>/dev/null || true\n exit 1\n # ────────────────────────────────────────────────────────────────────────────\n\n # Zip may strip execute permissions - restore them before archiving\n - name: Mark Linux binary executable\n if: runner.os == 'Linux'\n run: chmod +x release/Dosidicus\n\n - name: Create zip\n run: |\n OS_NAME=$(echo \"${{ runner.os }}\" | tr '[:upper:]' '[:lower:]')\n python -c \"import shutil; shutil.make_archive('Dosidicus${{ github.ref_name }}-${OS_NAME}', 'zip', 'release')\"\n\n - name: Upload artifact\n uses: actions/upload-artifact@v4\n with:\n name: nuitka-${{ runner.os }}\n path: Dosidicus${{ github.ref_name }}-*.zip\n"
},
{
"path": ".github/workflows/process_submission.yml",
"content": "name: Squid Gallery Bot\non:\n issues:\n types: [opened]\n\njobs:\n add-to-gallery:\n if: contains(github.event.issue.labels.*.name, 'squid-submission')\n runs-on: ubuntu-latest\n permissions:\n contents: write\n issues: write\n steps:\n - name: Checkout Code\n uses: actions/checkout@v4\n\n - name: Process Squid Save\n env:\n ISSUE_BODY: ${{ github.event.issue.body }}\n GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n ISSUE_NUMBER: ${{ github.event.issue.number }}\n run: |\n # 1. Extract URL and Nickname\n FILE_URL=$(echo \"$ISSUE_BODY\" | grep -o 'https://github.com/[^)]*' | head -n 1)\n NICKNAME=$(echo \"$ISSUE_BODY\" | grep -A 1 \"Squid Nickname\" | tail -n 1 | xargs | tr -d ' ')\n \n mkdir -p gallery\n curl -L $FILE_URL -o \"temp_squid.zip\"\n\n # 2. Verify ZIP and extract UUID\n if unzip -l temp_squid.zip | grep -q \"uuid.txt\"; then\n UUID=$(unzip -p temp_squid.zip uuid.txt | head -n 1 | xargs)\n FINAL_NAME=\"${NICKNAME}_${UUID}.zip\"\n \n mv temp_squid.zip \"gallery/${FINAL_NAME}\"\n \n # 3. Commit to repo\n git config user.name \"SquidBot\"\n git config user.email \"bot@github.com\"\n git add gallery/\n git commit -m \"New Squid verified: ${NICKNAME} (${UUID})\"\n git push\n \n gh issue comment $ISSUE_NUMBER --body \"✅ **Squid Verified!** $NICKNAME has been added to the gallery. UUID: \\`$UUID\\`\"\n gh issue close $ISSUE_NUMBER\n else\n gh issue comment $ISSUE_NUMBER --body \"❌ **Validation Failed:** This ZIP does not contain a \\`uuid.txt\\`. Please check your save file and try again.\"\n exit 1\n fi\n"
},
{
"path": "CONTRIBUTING.md",
"content": "## Contributing to Dosidicus 🦑\nDosidicus isn't just a repository; it’s an open-ended experiment in transparent artificial life. We are building a world where cognition isn't a black box, but a visible, hackable structure. Whether you are a neuro-enthusiast, a Python wizard, or a digital explorer, there is a place for you in the sandbox.\n\n### 🧠 1. Evolve the Core (src/)\nThe STRINg engine is the beating heart of the project. We’ve avoided heavy frameworks like TensorFlow to keep things \"bare metal\" and interpretable.\n\nThe Challenge: Optimize neural algorithms, refine Hebbian plasticity logic, or enhance the real-time UI.\n\nGoal: Make the simulation faster and the neural dynamics more expressive.\n\n### 🧩 2. Architect New Realities (plugins/)\nDosidicus is designed to be modular. Our plugin system allows you to inject new logic without touching the core engine.\n\nThe Challenge: Create a new plugin folder with a plugin.txt descriptor.\n\nIdeas: Environmental stressors, advanced \"Achievement\" triggers, or even a Twitch-integrated \"Chat-controlled Evolution.\"\n\n### 🧬 3. Map the Connectome (custom_brains/)\nHelp us build a library of diverse neural starting points. By contributing JSON templates to custom_brains/, you define the \"DNA\" that users experiment with.\n\nThe Challenge: Design a unique neural layout—perhaps a highly recurrent \"memory loop\" or a sensory-heavy \"predator\" build.\n\n### 📂 4. Share Your Specimens (example_squids/)\nIn this sandbox, Structure + Experience = Behavior. No two squids are identical.\n\nThe Challenge: Export your .json save files and share them. Did your squid develop a strange obsession with a specific corner of the map? Did it grow a massive neural cluster after a specific training session?\n\nAction: Submit your most interesting \"trained\" squids as examples for others to study.\n\n### 🌍 5. Bridge the Language Gap (translations/)\nWe want \"visible minds\" to be accessible to everyone.\n\nThe Challenge: Add a new language file (e.g., fr.py, jp.py) to the translations/ directory. Help us ensure that concepts like Neurogenesis and Activation Patterns translate clearly across cultures.\n\n### 🛠️ 6. Documentation & Educational Outreach\nIf a newcomer can’t understand how to \"read\" a squid’s mind, the transparency is lost.\n\nThe Challenge: Improve docstrings, write \"Field Guides\" for new users, or record a video of a specific behavioral emergence.\n\nGoal: Turn complex neuroscience concepts into playable tutorials.\n\n### 🚀 How to Get Started\nCheck the \"Ahead\" Forks: See what the community is already building in the Network Graph.\n\nOpen an Issue: Have a wild idea for a new neuron type? Let's discuss it first!\n\nSubmit a PR: We welcome all PRs, from single-typo fixes to massive engine overhauls.\n\nEvery commit is a mutation. Every contribution helps the system grow.\n"
},
{
"path": "Dockerfile",
"content": "# syntax=docker/dockerfile:1\n\nFROM python:3.11-slim AS base\nENV PYTHONDONTWRITEBYTECODE=1 \\\n PYTHONUNBUFFERED=1 \\\n PIP_DISABLE_PIP_VERSION_CHECK=1\nWORKDIR /app\n\n# Install core dependencies needed by ALL targets\nRUN python -m pip install --no-cache-dir numpy>=1.21\n\n# ------------------------------\n# Headless trainer target\n# ------------------------------\nFROM base AS headless\n# Only copy what is needed for headless training\nCOPY headless/ ./headless/\nCOPY custom_brains/ ./custom_brains/\n\nENTRYPOINT [\"python\", \"headless/headless_trainer.py\"]\nCMD [\"--ticks\", \"10000\", \"--output\", \"trained_brain.json\"]\n\n# ------------------------------\n# GUI target (requires X11)\n# ------------------------------\nFROM base AS gui\n# Install system libraries for GUI support\nRUN apt-get update && apt-get install -y --no-install-recommends \\\n libgl1 \\\n libgl1-mesa-dri \\\n libglib2.0-0 \\\n libx11-6 \\\n libx11-xcb1 \\\n libxkbcommon-x11-0 \\\n libxkbcommon0 \\\n libxext6 \\\n libxrender1 \\\n libxrandr2 \\\n libxfixes3 \\\n libxdamage1 \\\n libxi6 \\\n libxcomposite1 \\\n libxcursor1 \\\n libxss1 \\\n libxtst6 \\\n libfontconfig1 \\\n libfreetype6 \\\n libnss3 \\\n libdbus-1-3 \\\n libxcb1 \\\n libxcb-icccm4 \\\n libxcb-image0 \\\n libxcb-keysyms1 \\\n libxcb-randr0 \\\n libxcb-render0 \\\n libxcb-render-util0 \\\n libxcb-shape0 \\\n libxcb-shm0 \\\n libxcb-sync1 \\\n libxcb-xfixes0 \\\n libxcb-xinerama0 \\\n libxcb-xkb1 \\\n libxcb-cursor0 \\\n libxshmfence1 \\\n libwayland-client0 \\\n libwayland-cursor0 \\\n libwayland-egl1 \\\n && rm -rf /var/lib/apt/lists/*\n\n# Install GUI-specific Python dependencies\nRUN python -m pip install --no-cache-dir PyQt5>=5.15\n\n# Copy the entire project for the GUI\nCOPY . .\n\nENV QT_X11_NO_MITSHM=1\nENTRYPOINT [\"python\", \"main.py\"]\n"
},
{
"path": "Docs/Cognitive Sandbox Manifesto - Artificial Life and Transparent Neural Systems.md",
"content": "\n \n\n\n\n\n## 1. Why This Exists\n\nMost artificial intelligence today is powerful, fast, and opaque: Large neural networks are trained on vast datasets producing remarkable outputs.\nHowever the learning process itself is hidden inside millions or billions of parameters.\n\n* You cannot watch a mind form - you can only inspect the result.\n\nDosidicus was created from a different question:\n\n* What if cognition could be SEEN emerging?\n\nNot as a metaphor or as a visualisation layered on top, but at the level of individual neurons.\n\n## 2. The Cognitive Sandbox\n\nDosidicus is a cognitive sandbox.\n\nA sandbox is not a finished product.\nIt is a contained environment where systems interact, evolve, and reveal behaviour.\n\nEach squid:\n\n* Is born with a randomly wired neural architecture\n* Starts with 8 neurons\n* Learns through Hebbian dynamics\n* Grows new structure through neurogenesis\n* Forms memories\n* Develops behavioural tendencies\n\nNo two squids are identical.\n\nEvery save file becomes a record of accumulated experience.\n\nThe sandbox does not prescribe intelligence, it allows structure to form through interaction.\n\n## 3. Transparency as a Design Principle\n\nMost AI systems are black boxes. Dosidicus rejects opacity as default. Every neuron is:\n\n* Visible\n* Inspectable\n* Directly stimulatable\n* Modifiable\n\nYou can see activation values and observe connection strengths change.\nYou can influence structural growth.\n\nThis is not industrial-scale AI, it is intentionally small-scale and transparent.\n\nThe goal is not performance but **visibility**.\n\nTransparency transforms AI from a service into an object of study.\n\n## 4. Artificial Life\n\nDosidicus is not an attempt at AGI. It is a constrained, evolving, micro-organism simulation which exists in a narrow world:\n\n* Hunger\n* Interaction\n* Stimulus\n* Memory\n* Simple drives\n\nYet within these constraints, patterns emerge.\n\nArtificial life is not about scale.\nIt is about process.\n\nA small system that adapts and accumulates experience over time can evoke something that feels alive — even when it is mechanistic.\nThis boundary between mechanism and perceived life is intentional.\n\n## 5. Attachment to Visible Minds\n\nHumans bond with simple systems.\n\nWe bond with:\n\n* Tamagotchi\n* Virtual pets\n* Pixel creatures\n* Even malfunctioning robots\n\nDosidicus introduces a twist:\n\nYou can see the internal cause of behaviour.\n\nIf your squid develops an aversion to something,\nyou can trace the neural path that led there.\n\nThis changes the psychology of attachment.\n\nInstead of caring for a scripted creature you are shaping a developing structure.\n\n* Responsibility becomes more concrete.\n* Every interaction leaves a trace.\n\n## 6. Retro as Constraint / computational meta-art\n\nDosidicus uses minimal animation.\nTwo tentacle frames.\nHand-drawn sprites.\nDeliberately simple presentation.\n\nIt is a design constraint.\n\nComplex graphics distract from internal complexity.\n\nThe squid is art.\n\nThe brain is system.\n\nTogether, they create **computational meta-art**:\na drawn creature whose behaviour emerges from real learning dynamics.\n\n \n\n## 7. STRINg: The Simulation Engine\n\nUnder the hood runs a [custom engine](https://github.com/ViciousSquid/Dosidicus/wiki/Engine-overview):\n\n[STRINg](https://github.com/ViciousSquid/Dosidicus/wiki/Engine-overview)\n`S`imulated `T`amagotchi `R`eactions via `I`nferencing and `N`eurogenesis\n\nBuilt from scratch using NumPy.\n\n* No TensorFlow.\n* No PyTorch.\n\n#### Core properties:\n\n* Explicit neuron-level simulation\n* Hebbian plasticity\n* Structural growth (neurogenesis)\n* Dual memory system (short-term and long-term)\n* Headless training capability\n* Plugin extensibility\n\nSTRINg is optimised for interpretability not scale.\n\nIt treats neural networks not as static architectures, but as evolving structures.\n\n## 8. Educational Intent\n\nDosidicus functions as:\n\n* A learning tool for understanding neural dynamics\n* A demonstration of Hebbian learning\n* A sandbox for artificial life experimentation\n* A way to visualise structural plasticity\n* A gateway into neuroscience concepts through play\n\nInstead of teaching neural networks as equations alone, it allows learners to raise one.\n\nUnderstanding becomes experiential.\n\n## 9. Individuality Through Random Birth\n\nEvery squid begins differently.\n* Initial wiring is randomised.\n* Early experiences alter trajectory.\n* Small differences amplify over time.\n\nThis models a core biological principle:\n\n_**Structure + experience = behaviour.**_\n\nThe system does not claim biological realism.\n\nIt demonstrates structural sensitivity.\n\nNo two digital lives are identical.\n\n## 10. What This Is Not\n\n* Not Skynet.\n* Not a productivity AI.\n* Not a chatbot.\n* Not a pretrained monolith.\n* Not an optimised inference engine.\n\nIt is a visible micro-mind.\n\nContained.\nHackable.\nInspectable.\nEvolving.\n"
},
{
"path": "Docs/README.md",
"content": "\n_\"What if a Tamagotchi had a neural network and could learn stuff?\"_\n— [Gigazine](https://gigazine.net/gsc_news/en/20250505-dosidicus-electronicae/)\n\n
\n \n \n \n \n
\n\n# _Dosidicus electronicus_\n\n🦑 _A transparent neural sandbox disguised as a digital pet squid with a neural network you can **see thinking**_\n\nMicro neural engine for small autonomous agents that learn via Hebbian dynamics and grow new structure\n\n- Part **educational neuro tool**, part **sim game**, part **fever dream**\n- [Build-your-own neural network ](https://github.com/ViciousSquid/Dosidicus/wiki/Brain-Designer) - learn neuroscience by raising a squid that **might develop irrational fears**\n- Custom [simulation engine](https://github.com/ViciousSquid/Dosidicus/wiki/Engine-overview) using Numpy - **No Tensorflow or PyTorch**\n- Most AI is a **black box**; Dosidicus is **transparent** - every neuron is visible, stimulatable, understandable.\n- Starts with 8 neurons — grows via **neurogenesis** and rewires using **Hebbian learning**.\n- Includes `achievements` with **50** to collect!\n\n \n \n- -----------------------------\n\n---\n\n### Getting Started\n\n| Page | Description |\n|------|-------------|\n| [Home](getting-started/Home.md) | Project overview |\n| [Care Guide](getting-started/Care-Guide.md) | How to look after your squid |\n| [Example Squids](getting-started/Example-Squids.md) | Pre-made squid configurations |\n| [Changelog](getting-started/Changelog.md) | Version history |\n\n---\n\n### STRINg Simulation Engine\n\n| Page | Description |\n|------|-------------|\n| [Engine Overview](engine/Engine-Overview.md) | High-level architecture |\n| [Decision Engine](engine/Decision-Engine.md) | How the squid makes choices |\n| [Data Flow Summary](engine/Data-Flow-Summary.md) | How data moves through the system |\n| [Plugin System](engine/Plugin-System.md) | Extending Dosidicus with plugins |\n| [Plugin Hooks](engine/Plugin-Hooks.md) | Available hook points |\n| [Save File Format](engine/Save-File-Format.md) | Structure of `.squid` save files |\n| [config.ini](engine/config.ini.md) | Configuration reference |\n| [Multiplayer](engine/Multiplayer.md) | Multiplayer support |\n\n---\n\n### Neural Network\n\n| Page | Description |\n|------|-------------|\n| [Technical Overview](neural-network/Technical-Overview.md) | Neural network architecture |\n| [Hebbian Learning](neural-network/Hebbian-Learning.md) | Weight update algorithm |\n| [STDP](neural-network/STDP.md) | Spike-Timing-Dependent Plasticity |\n| [Neurogenesis](neural-network/Neurogenesis.md) | Creating new neurons at runtime |\n| [Experience Buffer](neural-network/Experience-Buffer.md) | Short/long-term memory experiences |\n| [Vision System](neural-network/Vision-System.md) | Food detection via vision cone |\n| [Personality](neural-network/Personality.md) | The 7 personality types |\n| [AI Accelerator Support](neural-network/AI-Accelerator-Support.md) | Hardware acceleration options |\n\n---\n\n### Brain Tool\n\n| Page | Description |\n|------|-------------|\n| [Brain Designer](brain-tool/Brain-Designer.md) | GUI for designing custom brains |\n| [Brain Trainer (Headless)](brain-tool/Brain-Trainer-Headless.md) | CLI training without a GUI |\n| [Network Tab](brain-tool/Network-Tab.md) | Visualising the neuron network |\n| [Learning Tab](brain-tool/Learning-Tab.md) | Monitoring learning in real time |\n| [Memory Tab](brain-tool/Memory-Tab.md) | Inspecting memory contents |\n| [Decisions Tab](brain-tool/Decisions-Tab.md) | Watching decision-making live |\n| [Personality Tab](brain-tool/Personality-Tab.md) | Adjusting personality traits |\n| [Neuron Laboratory](brain-tool/Neuron-Laboratory.md) | Experimenting with individual neurons |\n\n---\n\n### Source Reference\n\nDocumentation for individual source files:\n\n| File | File |\n|------|------|\n| [main.py](source-reference/main.py.md) | [brain_tool.py](source-reference/brain_tool.py.md) |\n| [squid.py](source-reference/squid.py.md) | [brain_widget.py](source-reference/brain_widget.py.md) |\n| [tamagotchi_logic.py](source-reference/tamagotchi_logic.py.md) | [brain_worker.py](source-reference/brain_worker.py.md) |\n| [memory_manager.py](source-reference/memory_manager.py.md) | [brain_render_worker.py](source-reference/brain_render_worker.py.md) |\n| [vision_worker.py](source-reference/vision_worker.py.md) | [brain_neuron_hooks.py](source-reference/brain_neuron_hooks.py.md) |\n| [custom_brain_loader.py](source-reference/custom_brain_loader.py.md) | [brain_neuron_outputs.py](source-reference/brain_neuron_outputs.py.md) |\n| [designer_window.py](source-reference/designer_window.py.md) | [neurogenesis_show.py](source-reference/neurogenesis_show.py.md) |\n\n---\n\n### Extras\n\n| Page | Description |\n|------|-------------|\n| [Achievements](extras/Achievements.md) | Unlockable achievements |\n| [Easter Eggs](extras/Easter-Eggs.md) | Hidden features |\n| [Decoration Window](extras/Decoration-Window.md) | Customising the environment |\n| [SaveViewer](extras/SaveViewer.md) | Browser-based save file inspector |\n| [UUID](extras/UUID.md) | Squid identity system |\n"
},
{
"path": "Docs/brain-tool/Brain-Designer.md",
"content": "### Design your own (GPL!) squid brain!\n\nAdd new **neurons** / **layers** - see how they affect the squid's ability to process his environment\n \n\n\nClick the brain button in the bottom right of the \n [network tab](../brain-tool/Network-Tab.md) to swich into Designer mode\n\n\n\nFROM LEFT TO RIGHT:\n\n1. -- Fast-Generate a random network with no prompt\n2. -- Generate a random network with controls\n3. -- Add a new Custom/Input Neuron\n4. -- Export the brain to a .json file\n5. -- Clear all connections\n6. -- Quick-generate a network from template\n\n--------------------------------------\n\nIf designer mode is launched from within the simulation (default behaviour):\n\n* The running brain will be automatically imported into the designer. \n* The purple '**Switch to Game**' button passes the brain from the designer to the running brain tool\n\n```\nSome buttons will not be available if the designer is launched standalone (main.py -designer)\n```\n\n---------------------------------\n#### CONTROLS:\n\n* to add a neuron\n\n\n* Mouse wheel on the canvas to zoom in/out, hold right mouse button to drag\n* Click on a neuron and hold to drag a connection line - release on another neuron\n* Select a link and use the mouse wheel to increase/decrease the connection weight (range: -1.00 to +1.00)\n* negative weights are inhibitory (red), positive weights are excitory (green). \n* Press **DEL** to delete a connection link\n* **SPACE** to change the direction of a connecting line (indicated with arrows)\n* Stronger weights are indicated with thicker lines.\n* **Ctrl-click-and drag** to reposition any neuron.\n* Use the Layers tab to create more complicated brains with additional layers\n* The Sensors tab shows available INPUT neurons\n* The Output tab lists Output bindings for bridging neuron activations to game behaviours:\n\nChoose a **source neuron**, a **trigger**, and **behaviour** for that trigger\n\nEXAMPLES:\n```\nIF .. can_see_food .. THEN .. change colour\nIF .. happiness = <30 .. THEN .. pick up a rock\nIF .. anxiety = >60 .. THEN .. seek plant\n```\n\nThese can be combined to create reactive behaviours (simulated _biological drives/**urges**_)\n\n\n\n\n------------------------\n\n### `Generate sparse network`\n\nThe 'generate sparse network' button creates biologically-inspired neural networks using the core 8 neurons. Each generated brain is unique and randomised.\n\n\n\n"
},
{
"path": "Docs/brain-tool/Brain-Trainer-Headless.md",
"content": "A headless training tool is included in the `headless` folder. This can be used to train brains in a time-accelerated environment \n\n* **Headless Operation**: No GUI required, runs purely on CPU\n* **Accelerated Time**: Runs 25,000-35,000+ ticks per second (vs ~1 tick/second in real-time)\n* **Neurogenesis**: Automatic creation of new neurons based on stress/novelty/reward triggers\n* **Hebbian Learning**: Continuous weight updates based on co-activation\n* **Training Scenarios**: Predefined scenarios for different training goals\n* **Export Trained Brains**: Save trained brains back to JSON for use in the main game\n\nDocumentation for this tool can be found here: https://github.com/ViciousSquid/Dosidicus/blob/v2.6.1.0__b1218_LatestVersion/headless/README_headless_trainer.md\n\n#### WORK IN PROGRESS, BUGGY, WORK IN PROGRESS, BUGGY, WORK IN PROGRESS, BUGGY\n\n\n#### `headless_launcher.html` is a user-friendly launcher for this tool: drag and drop or Browse for a brain and then select how to train it and for how long\n\n"
},
{
"path": "Docs/brain-tool/Decisions-Tab.md",
"content": "\n\n\n
The Decisions Tab provides a fascinating, step-by-step visualization of your squid's thought process. It breaks down how the squid goes from assessing his environment and internal needs to making a final, actionable decision. This view is updated every time the squid makes a new choice.
\n\nDecisions reflected here are made by the [Decision Engine](../engine/Decision-Engine.md) which is driven by the [Neural Network](../neural-network/Technical-Overview.md)\n\n\n\n
Interface Elements
Thought Process Path: A vertical flow-chart that visualizes the decision-making pipeline.
📡 Sensing the World: This step shows the raw inputs the squid is currently processing. This includes his internal stats (hunger, happiness, etc.) and any objects he can see in his environment (food, poop, etc.).
\n
⚖️ Calculating Base Urges: Based on the inputs, the tool calculates the initial \"weight\" or \"urge\" for each possible action. The action with the highest initial score is listed as the strongest urge.
🎭 Applying Personality & Memories: The base urges are then modified by the squid's personality and recent memories. For example, a \"Timid\" squid might have his urge to \"explore\" reduced, while a \"Greedy\" squid will have his urge to \"eat\" increased. This step shows how much each score was adjusted.
✅ Making the Final Decision: This step shows the final, adjusted scores for all possible actions. The action with the highest final score is the one the squid chooses.
Final Action Bar: A fixed bar at the bottom of the tab that prominently displays the squid's final chosen action (e.g., \"Eat\", \"Sleep\", \"Explore\") and his calculated confidence in that decision.
"
},
{
"path": "Docs/brain-tool/Learning-Tab.md",
"content": "\n\n#### `Hebbian learning` is a principle grounded in the functioning of biological neural networks\n\n\n
The Learning Tab is your window into understanding how your squid learns. It focuses on the Hebbian learning principle: \"neurons that fire together, wire together.\" \n\nThis tab visualizes **neuron pairs** that were selected for learning (happens every 30 seconds by default)\n The connection strength between them (weight) was either **strengthened** or **weakened**, meaning they became more or less associated with each other.\n\n For example: if Hunger and Satisfaction both happened to be firing at the same time (perhaps the squid just had a positive eating experience) these two neurons would have their connection strengthened when the counter reaches zero\n\nOver time the same useful connections will keep strengthening and strong pathways will develop. This is how the squid 'learns' favourable behaviours\n\n\n----------------------------\n\n#### Further Reading:\nExternal links\n\n* https://medium.com/@reutdayan1/hebbian-learning-biologically-plausible-alternative-to-backpropagation-6ee0a24deb00\n* https://informatics.ed.ac.uk/sites/default/files/2024-03/Qiuye%20Zhang%20Lovelace%20Colloquium%20Poster.pdf\n* https://en.wikipedia.org/wiki/Hebbian_theory\n* https://www.youtube.com/watch?v=TvTQQO5yTa4\n\n\n"
},
{
"path": "Docs/brain-tool/Memory-Tab.md",
"content": "\n\n\n\n
The Memory Tab allows you to explore the memories your squid has formed. It separates memories into short-term (recent events) and long-term (consolidated, important events), giving you insight into what has recently affected your squid and what it has learned to remember.
Interface Elements
Memory Sub-Tabs:
🧠 Short-Term: Displays recent memories that are still being processed. These are temporary and will decay over time unless they are significant.
📚 Long-Term: Displays memories that have been deemed important enough to be stored permanently. These memories have a lasting impact on the squid's behavior.
📊 Overview: Shows high-level statistics about the memory system, including the total count of short-term and long-term memories and a breakdown of memories by category (e.g., food, interaction, mental\\_state).
Memory Cards: Both STM and LTM are displayed as a series of cards. Each card is color-coded to indicate its emotional valence:
Pastel Green: A positive memory (e.g., eating tasty food).
Pastel Red: A negative memory (e.g., being startled).
Pastel Yellow: A neutral memory.
Card Content: Each card displays the memory's category, its formatted content, and the time it was created. Important memories are marked with a \"⭐ Important\" indicator. Clicking on a short-term memory card can increase its importance, making it more likely to be transferred to long-term memory.
"
},
{
"path": "Docs/brain-tool/Network-Tab.md",
"content": "The Network Tab provides a live, visual representation of the overall structure and health of the neural network in real-time. \n\n\n\n\n- Each neural network is unique and randomly generated (with rules) when the squid is hatched\n- Red lines represent Excitory (positive) connections between neurons\n- Green lines represent Inhibitory (negative) connections\n- The thicker the line, the stronger the connection\n\n\n\n
Interface Elements
Neural Visualizer: The main canvas displaying the neurons as nodes and their connections as lines. The pulsing and glowing of neurons and links indicate activity and learning events.
Metrics Bar: Located at the top, this bar provides at-a-glance statistics:
Neurons: The total number of neurons currently in the brain.
Connections: The total number of weighted connections between neurons.
Network Health: Overall stability and efficiency of the network, primarily based on average connection strength.
Hebbian Timer: A countdown (e.g., \"Hebbian: 25\") showing the time remaining until the next Hebbian learning cycle is performed.
Control Checkboxes:
Show links: Toggles the visibility of the lines connecting the neurons.
Show weights: Toggles the display of the numerical weight on each connection line.
Enable pruning: Toggles the automatic removal of old, weak, or unused neurons to maintain network stability. Disabling this can lead to an unconstrained and potentially unstable network.
\n\nThe big button with the brain on it opens the [Brain Designer](../brain-tool/Brain-Designer.md) which allows you to build and edit custom brains and behaviours\n"
},
{
"path": "Docs/brain-tool/Neuron-Laboratory.md",
"content": "### **Double click on any neuron** to view the Neuron Laboratory\nIt can be used to inspect individual neurons. The 'Edit Sandbox' tab allows direct adjustment of the live brain state. \n\nThis window also displays the Neurogenesis Experience buffer and neural patterns (last tab) that determine the squid's learned responses.\n\n\n\n\n-----------------------------\n\n\n### Unlocking the 'sandbox' tab allows for full manual control of neuron values:\n \n\n\n\n\n"
},
{
"path": "Docs/brain-tool/Personality-Tab.md",
"content": "\n\n\n
The Personality Tab details the innate character of your squid, which is randomly assigned at the beginning of a new game.\n--------------\n\n This [personality](../neural-network/Personality.md) has a significant and constant influence on its behaviour, decision-making, and needs.
Interface Elements
Squid Personality: Displays the name of the determined personality (e.g., Timid, Adventurous, Lazy).
Description: Provides a paragraph explaining the general nature of this personality type.
Personality Modifiers: Lists the specific, hard-coded rules that this personality applies to the squid's brain. For example, it might detail how anxiety increases 50% faster or how curiosity is boosted.
Care Tips: Offers practical advice on how to best care for a squid with this specific personality, helping you keep it happy and healthy.
"
},
{
"path": "Docs/engine/Data-Flow-Summary.md",
"content": "## Data Flow Summary\n\n### [Main Loop](../source-reference/main.py.md)\n\n**Game Loop** → [`TamagotchiLogic`](../source-reference/tamagotchi_logic.py.md) feeds stats → `BrainWidget.update_brain_state()`\n\n---\n\n### Central Hub: [BrainWidget](../source-reference/brain_widget.py.md)\n\n| Component | Description |\n|-----------|-------------|\n| `state` dict | Neuron activations |\n| `weights` dict | Connection strengths |\n| Coordinates | All subsystems |\n\n---\n\n### Worker Threads\n\n| Worker | Responsibility | Output |\n|--------|----------------|--------|\n| [**BrainWorker**](../source-reference/brain_worker.py.md) | Hebbian learning, Neurogenesis | Signals → BrainWidget |\n| [**BrainRenderWorker**](../source-reference/brain_render_worker.py.md) | Offscreen painting | QImage → paintEvent |\n| [**NeuronOutputMonitor**](../source-reference/brain_neuron_outputs.py.md) | Threshold checks | Hooks → Squid behaviors |\n\n---\n\n### Signal Flow\n```\nBrainWorker ──────────┐\n │\n ▼\n BrainWidget ──────▶ Squid\n ▲\n │\nBrainRenderWorker ────┘\n```\n\n---\n\n### Complete Pipeline\n\n1. **Input Stage**\n - [`BrainNeuronHooks`](../source-reference/brain_neuron_hooks.py.md) converts game events → neuron activations\n - Sensors: `can_see_food`, `plant_proximity`, `is_fleeing`, etc.\n\n2. **Processing Stage**\n - [`BrainWidget`](../source-reference/brain_widget.py.md) updates state dictionary\n - [`BrainWorker`](../source-reference/brain_worker.py.md) performs Hebbian learning (weight updates)\n - [`BrainWorker`](../source-reference/brain_worker.py.md) checks [neurogenesis](../neural-network/Neurogenesis.md) triggers\n\n3. **Output Stage**\n - [`NeuronOutputMonitor`](../source-reference/brain_neuron_outputs.py.md) checks activation thresholds\n - Fires output hooks → game behaviours\n - Actions: `flee`, `seek_food`, `sleep`, `change_colour`, etc.\n\n4. **Rendering Stage**\n - [`BrainRenderWorker`](../source-reference/brain_render_worker.py.md) receives state snapshot\n - Renders to offscreen QImage\n - Main thread blits cached image\n"
},
{
"path": "Docs/engine/Decision-Engine.md",
"content": "#### view source: _[decision_engine.py](https://github.com/ViciousSquid/Dosidicus/blob/2.6.1.2_LatestVersion/src/decision_engine.py)_ _version 2.6.1.2_\n\n## Overview\n\n```\n exploration of emergent behavioural complexity via dynamic, biologically-inspired neural architecture rather than a static state machine. \n```\n\nThe **Decision Engine** is the core action-selection system for Dosidicus. It is responsible for selecting and executing behaviour based on the squid’s *current neural state*, *physiological drives*, *memory influences*, and *personality modifiers*. \n\nUnlike traditional game AI systems (finite-state machines, behaviour trees, or rule stacks), the Decision Engine is **neural-first**: it does not directly reason about the world. Instead, *all perception and context must flow through the brain*.\n\nIn practical terms, this means behaviour is not scripted. It **emerges** from continuous internal signals competing for expression.\n\nThe engine is designed to be:\n\n* Explainable (full decision traces are recorded)\n* Extensible (new drives, memories, or actions integrate naturally)\n* Compatible with future learning systems (dopamine, reinforcement, plasticity)\n\n---\n\n## Design Philosophy\n\n### Neural-First Authority\n\nThe Decision Engine treats the brain as the **single source of truth**. It does not perform manual world queries (e.g. checking for food, scanning objects) to *decide* what to do. Instead, it consumes:\n\n* Perceptual neuron outputs (via [`BrainNeuronHooks`](../source-reference/brain_neuron_hooks.py.md))\n* Internal state neurons (hunger, anxiety, curiosity, etc.)\n* Learned and persistent neural values\n\nDirect world interaction is limited to *execution*, not *decision-making*.\n\n### Continuous Competition\n\nActions are not triggered by rules. Instead, all candidate actions receive **weights** derived from internal signals. These weights compete, and the strongest wins. Small differences matter, enabling hesitation, oscillation, and personality-driven variance.\n\n### Modulation, Not Commands\n\nMemory and personality do not issue instructions. They *bias* behaviour by scaling weights. This ensures:\n\n* Memories influence but do not dominate\n* Personalities remain relevant in all contexts\n* New behaviours automatically inherit modulation\n\n---\n\n## Decision Pipeline\n\nThe decision process is executed in six structured stages.\n\n---\n\n### 1. Perceptual & Brain State Construction\n\nAll perceptual input is retrieved via [`BrainNeuronHooks`](../source-reference/brain_neuron_hooks.py.md):\n\n* Temporal sensors are decayed each tick\n* No manual perception checks are allowed\n\nThe full brain state is constructed from:\n\n* Core neurons\n* Learned neurons\n* Perceptual inputs (merged defensively)\n\nThis combined state represents the squid’s *entire subjective reality* at the moment of decision.\n\n---\n\n### 2. Memory Influence\n\nActive memories are retrieved from the memory manager and converted into **multiplicative biases** on specific actions.\n\nExamples:\n\n* Positive food memories bias eating\n* Object interaction memories bias play and throwing\n* Startle memories suppress exploration and increase comfort-seeking\n\nMemory effects are:\n\n* Directional (positive or negative bias)\n* Non-deterministic\n* Stackable\n\nThis models habits, preferences, and learned aversions rather than explicit recall.\n\n---\n\n### 3. Physiological Urgency (Nonlinear Drives)\n\nPhysiological needs generate **exponential urgency curves**:\n\n* Hunger amplifies eating\n* Sleepiness amplifies sleeping\n\nNonlinear scaling ensures that high-need states *crowd out* other motivations rather than simply increasing priority linearly.\n\n#### Reflex Overrides\n\nCertain extreme states bypass competition entirely:\n\n* Exhaustion → forced sleep\n* Active sleep → no decision\n* Extreme external stimulus → startle response\n\nThese represent **reflex arcs**, not cognitive decisions.\n\n---\n\n### 4. Base Action Weight Construction\n\nEach candidate action receives a base weight derived from the brain state.\n\nActions include:\n\n* Exploring\n* Eating\n* Approaching plants (comfort-seeking)\n* Playing\n* Throwing objects\n* Sleeping\n* Fleeing\n\nWeights are influenced by:\n\n* Drives (hunger, curiosity, satisfaction)\n* Threat and anxiety\n* Perceptual confidence (e.g. food visibility)\n* Contextual suppressors (illness, external stimuli)\n\nThis stage defines *what the squid wants* before learning, memory, or personality intervene.\n\n---\n\n### 5. Memory & Personality Modulation\n\n#### Memory Modifiers\n\nMemory multipliers are applied to relevant actions, biasing selection without enforcing outcomes.\n\n#### Personality Modifiers\n\n[Personalities](../neural-network/Personality.md) act as **gain controls**:\n\n* **Adventurous**: boosts exploration and play\n* **Timid**: suppresses exploration, amplifies comfort-seeking\n* **Greedy**: amplifies eating\n* **Lazy**: suppresses energetic actions\n* **Energetic**: boosts play and exploration\n\nPersonality does not define behaviour — it shapes *how strongly* drives express themselves.\n\n#### Anxiety Coupling\n\nHigh anxiety further amplifies comfort-seeking behaviour, creating feedback between affect and action selection.\n\n---\n\n### 6. Stochastic Selection & Confidence\n\nAfter all modifiers:\n\n* Small stochastic noise is applied to prevent determinism\n* The highest-weighted action is selected\n\n#### Confidence Metric\n\nDecision confidence is computed as the relative margin between the top two competing actions.\n\nThis signal can be used for:\n\n* Animation blending\n* UI visualization\n* Learning-rate modulation\n* Behavioural hesitation\n\n---\n\n## Execution Phase\n\nOnce an action is selected, it is executed via `_execute_neural_decision`.\n\nKey principles:\n\n* Execution respects neural intent\n* World scanning is minimized\n* Fallback behaviours preserve personality flavour\n\nExecution returns a *descriptive outcome string*, not just an action label, enabling rich UI feedback.\n\n---\n\n## Decision Tracing & Visualization\n\nEach decision produces a full trace containing:\n\n* Raw perceptual inputs\n* Brain state snapshot\n* Base action weights\n* Memory influences\n* Urgency multipliers\n* Personality modifiers\n* Final adjusted weights\n* Selected action\n* Confidence score\n\nThis trace is exposed to the Brain Tool UI for inspection and debugging.\n\n---\n\n## What the Decision Engine Is (and Is Not)\n\n### It Is:\n\n* A neural-modulated action selection system\n* Continuous and explainable\n* Designed for emergent behaviour\n* Compatible with learning extensions\n\n### It Is Not:\n\n* A finite-state machine\n* A behaviour tree\n* A planner or lookahead system\n* A reinforcement learner (yet)\n\n---\n\n## Future Extensions\n\nThe Decision Engine is intentionally structured to support:\n\n* Dopaminergic reinforcement signals\n* Action-value learning\n* Noise modulation by arousal or confidence\n* Fully neural affordance perception\n\nThe hardest architectural work — unified perception, continuous competition, and traceability — is already in place.\n\n---\n\n## Summary\n\nThe Decision Engine forms the behavioural core of Dosidicus. By enforcing neural authority, continuous competition, and modulation-based influence, it produces behaviour that is adaptive, interpretable, and personality-consistent — without relying on brittle scripts or hard-coded modes.\n\nIt is not merely a controller, but a foundation for a growing cognitive system.\n"
},
{
"path": "Docs/engine/Engine-Overview.md",
"content": "## `S`imulated `T`amagotchi `R`eactions via `I`nferencing and `N`eurogenesis `(STRINg)`\n\n### simulation engine overview:\n\nThe architecture of Dosidicus is a \"Bottom-Up\" sensory system where raw environmental data is distilled into neural inputs, which are then filtered through the squid's [personality](https://github.com/ViciousSquid/Dosidicus/wiki/Personality) to produce behaviour.\n\nBuilt from scratch using NumPy.\n\n- No TensorFlow.\n- No PyTorch.\n\n### Core properties:\n* Explicit neuron-level simulation\n* Hebbian plasticity\n* Structural growth (neurogenesis)\n* Dual memory system (short-term and long-term)\n* Headless training capability\n* Plugin extensibility\n* STRINg is optimised for interpretability not scale.\n\nIt treats neural networks not as static architectures, but as evolving structures.\n\n---------------------\n\n\n- Network grows via **[neurogenesis](https://github.com/ViciousSquid/Dosidicus/wiki/Neurogenesis)** and self-trains via **[Hebbian learning](https://github.com/ViciousSquid/Dosidicus/wiki/Hebbian-learning)**\n\n- Automatic **pruning** of redundant neurons and weights (can be turned off)\n- [Experience buffer](https://github.com/ViciousSquid/Dosidicus/wiki/Experience-Buffer) records and encodes learned experiences\n- [decision_engine](https://github.com/ViciousSquid/Dosidicus/wiki/Decision-Engine) uses neural data to make decisions\n\n\n------------------\n\n* Beta (and optional) support for [AI accelerators via ONNX Runtime](https://github.com/ViciousSquid/Dosidicus/wiki/AI-accelerator-support)\n* _Experimental and a work in progress_\n* _Probably not the best way to do this!_ 😃\n\n---------------------------------\n\n\n\n\n## Read Next: [Data flow Summary](https://github.com/ViciousSquid/Dosidicus/wiki/Data-Flow-Summary) overview\n\n#### Further engine studies:\n\n- [Decision Engine](https://github.com/ViciousSquid/Dosidicus/wiki/Decision-Engine)\n- [Brain Widget](https://github.com/ViciousSquid/Dosidicus/wiki/brain_widget.py)\n\nExternal links\n\n* https://medium.com/@reutdayan1/hebbian-learning-biologically-plausible-alternative-to-backpropagation-6ee0a24deb00\n* https://informatics.ed.ac.uk/sites/default/files/2024-03/Qiuye%20Zhang%20Lovelace%20Colloquium%20Poster.pdf\n* https://en.wikipedia.org/wiki/Hebbian_theory\n* https://www.youtube.com/watch?v=TvTQQO5yTa4\n\n\n\n"
},
{
"path": "Docs/engine/Multiplayer.md",
"content": "**Basic Multiplayer functionality** has been implemented as a plugin (`plugins/multiplayer`) enabled via the Plugin manager\n\n\n_source code: https://github.com/ViciousSquid/Dosidicus/tree/2.5.0.0_latest_release/plugins/multiplayer_\n\n\n\nWhen Multiplayer is enabled:\n\n* the client will search for and automatically connect to other running networked clients on LAN\n\n* Squids can **leave their tanks** via an edge and appear in **other tanks** where they may attempt to steal rocks/decorations and bring them back home as trophies\n\n* Squids will automatically return home after a random duration (between 2 and 5 minutes)\n\n* Supports UDP (default) or TCP/IP (experimental, untested) via included control panel (Plugins>Multiplayer menu)\n\n* 'Dashboard' is included to see connected clients\n\n* Experimental work in progress, please report issues"
},
{
"path": "Docs/engine/Plugin-Hooks.md",
"content": "The following hooks are available for [plugins](../engine/Plugin-System.md) to subscribe to:\n\n ### Lifecycle hooks\n`on_startup`\n-called when the application launches\n\n`on_shutdown`\n-called when the application shuts down\n\n`on_new_game`\n-called when a new game is started\n\n`on_save_game`\n-called when a game is saved\n \n`on_load_game`\n-called when a game is loaded\n \n ### Simulation hooks\n`pre_update`\n-called immediately BEFORE the update of a frame (once per 1000 milliseconds) \n\n`post_update`\n-called immediately AFTER the update of a frame \n\n`on_speed_change`\n-called when the game speed is changed \n \n ### Squid state hooks\n`on_squid_state_change`\n-called when any of the squid's states change \n\n`on_hunger_change`\n-called every time the value of HUNGER changes \n\n`on_happiness_change`\n-called every time the value of HAPPINESS changes \n\n`on_cleanliness_change`\n-called every time the value of CLEANLINESS changes\n \n`on_sleepiness_change`\n-called every time the value of SLEEPINESS changes \n \n`on_satisfaction_change`\n-called every time the value of SATISFACTION changes \n\n`on_anxiety_change`\n-called every time the value of ANXIETY changes \n\n`on_curiosity_change`\n-called every time the value of ANXIETY changes \n \n ### Action hooks\n`on_feed`\n-called when the squid is fed via Actions>Feed\n\n`on_clean`\n-called when the tank is cleaned via Actions>Clean\n\n`on_medicine`\n-called when squid is administered medicine via Actions>Medicine\n\n`on_sleep`\n-squid calls this when going to sleep\n \n`on_wake`\n-squid calls this when waking up\n\n`on_startle`\n-squid calls this upon being startled \n \n ### Interaction hooks\n`on_rock_pickup`\n-called when squid picks up a rock\n \n`on_rock_throw`\n-called when squid throws a rock\n \n`on_decoration_interaction`\n-called when squid interacts with a decoration item such as rock or plant\n \n`on_ink_cloud`\n-squid calls this if he is sufficiently startled to produce an ink cloud (rare) \n \n ### Neural/memory hooks\n`on_neurogenesis`\n-called when a new neuron is created via neurogenesis\n \n`on_memory_created`\n-called when a new memory is created \n\n`on_memory_to_long_term`\n-called when a short term memory is transferred to long term memory \n \n ### UI hooks\n`on_menu_creation`\n-custom mod submenu (used with `register_menu_actions` [see below]) \n`on_message_display`\n-Displays a UI message \n \n### Custom menu action hooks\n`register_menu_actions`\n-Creates a submenu underneath the 'Plugins' menu \n\n### Designer Hooks\n\nregister_neuron_handler(name, handler, plugin_name, metadata) - plugins call this to register custom neurons"
},
{
"path": "Docs/engine/Plugin-System.md",
"content": "### Hooks\n\n\nThe application can be extended via **HOOKS** which are made available by the simulation engine when certain events occur\n* Available hooks are documented here: ../engine/Plugin-Hooks.md\n\nPlugins can subscribe to these hooks by calling the following methods in `src/plugin_manager.py` :\n\n### `register_hook`, `subscribe_to_hook`, `trigger_hook`\n\nShow full methods\n\n```python\n\ndef register_hook(self, hook_name: str) -> None:\n \"\"\"\n Register a new hook that plugins can subscribe to.\n \"\"\"\n if hook_name not in self.hooks:\n self.hooks[hook_name] = []\n self.logger.debug(f\"Registered hook: {hook_name}\")\n\n```\n\n-----------------\n\n```python\n\ndef subscribe_to_hook(self, hook_name: str, plugin_name: str, callback: Callable) -> bool:\n \"\"\"\n Subscribe a plugin's callback to a specific hook.\n \"\"\"\n if hook_name not in self.hooks:\n self.logger.warning(f\"Plugin {plugin_name} tried to subscribe to non-existent hook: {hook_name}\")\n return False\n \n self.hooks[hook_name].append({\n \"plugin\": plugin_name,\n \"callback\": callback\n })\n self.logger.debug(f\"Plugin {plugin_name} subscribed to hook: {hook_name}\")\n return True\n\n```\n\n--------------------\n\n```python\n\ndef trigger_hook(self, hook_name, **kwargs):\n \"\"\"\n Trigger a hook, calling all subscribed plugin callbacks.\n \"\"\"\n if hook_name not in self.hooks:\n self.logger.warning(f\"Attempted to trigger non-existent hook: {hook_name}\")\n return []\n \n results = []\n for subscriber in self.hooks[hook_name]:\n plugin_name = subscriber[\"plugin\"]\n # Only trigger hooks for enabled plugins\n if plugin_name.lower() not in self.enabled_plugins:\n continue\n \n try:\n callback = subscriber[\"callback\"]\n result = callback(**kwargs)\n results.append(result)\n except Exception as e:\n self.logger.error(f\"Error in plugin {plugin_name} for hook {hook_name}: {str(e)}\", exc_info=True)\n \n return results\n\n```\n\n\n\n\n--------------------------\n\n### A Quick Guide to Creating a Plugin\n\n#### A really good starting place would be to look at [multiplayer main.py](https://github.com/ViciousSquid/Dosidicus/blob/2.4.5.1_latest_release/plugins/multiplayer/main.py) and [achievements main.py](https://github.com/ViciousSquid/Dosidicus/blob/2.4.5.1_latest_release/plugins/achievements/main.py) and then refer back to this guide\n\nThis guide will walk you through the essential steps to create a basic plugin that correctly initializes and registers with the system's `PluginManager` _(src/plugin_manager.py)_\n\n```\nThe plugin manager expects:\n* A folder in plugins/ directory (e.g., plugins/pluginname/)\n* A main.py file inside that folder\n* Module-level constants: PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR, PLUGIN_DESCRIPTION, PLUGIN_REQUIRES\n* An initialize(plugin_manager) function that:\n\n1. Creates the plugin instance\n1. Registers it with the plugin manager via plugin_manager.plugins[name] = {..., 'instance': instance}\n1. Returns `True` on success\n```\n\n### Step 1: Create the Plugin Folder Structure\nFirst, create a new folder for your plugin inside the plugins/ directory. The name of this folder will be your plugin's unique identifier (its key), so choose a simple, lowercase name.\n\n```\nDosidicus/\n├── plugins/\n│ ├── my_new_plugin/ <-- Your new plugin folder\n│ │ └── main.py <-- Your plugin's entry point\n│ ├── auto_care/\n│ └── multiplayer/\n└── src/\n └── ...\n```\n\n### Step 2: Define Plugin Metadata\nYou must define Module-level constants that the PluginManager uses to identify and load your plugin.\n\n* `PLUGIN_NAME`: (Required) The display name of your plugin. ### **MUST **BE LOWERCASE!\n\n* `PLUGIN_DESCRIPTION`: A brief description of what your plugin does.\n\n* `PLUGIN_AUTHOR`: Your name or alias.\n\n* `PLUGIN_VERSION`: The version of your plugin.\n\n```python\n# plugins/my_new_plugin/main.py\n\n# --- Plugin Metadata --- # PLUGIN_NAME must be lowercase\nPLUGIN_NAME = \"my new plugin\"\nPLUGIN_DESCRIPTION = \"A simple plugin that demonstrates the basics.\"\nPLUGIN_AUTHOR = \"Seymour Butts\"\nPLUGIN_VERSION = \"1.0\"\n```\n\n### Step 3: Create the Main Plugin Class\nIt's best practice to encapsulate your plugin's logic within a class. This class will hold the state and functionality of your plugin, such as methods for enabling, disabling, and handling events (hooks).\n\n```python\n# plugins/my_new_plugin/main.py\n\nclass MyPlugin:\n def __init__(self, plugin_manager, plugin_key):\n self.plugin_manager = plugin_manager\n self.plugin_key = plugin_key # e.g., \"my_new_plugin\"\n self.is_enabled = False\n\n # Subscribe to a system event (hook)\n self.plugin_manager.subscribe_to_hook(\n \"on_startup\",\n self.plugin_key,\n self.on_app_startup\n )\n\n def enable(self):\n \"\"\"Called when the user enables the plugin.\"\"\"\n print(f\"[{self.plugin_key}] Plugin Enabled!\")\n self.is_enabled = True\n return True # Return True on success\n\n def disable(self):\n \"\"\"Called when the user disables the plugin.\"\"\"\n print(f\"[{self.plugin_key}] Plugin Disabled!\")\n self.is_enabled = False\n return True # Return True on success\n\n def on_app_startup(self, **kwargs):\n \"\"\"Callback for the on_startup hook.\"\"\"\n if self.is_enabled:\n print(f\"[{self.plugin_key}] Application has started up!\")\n```\n\n### Step 4: Implement the initialize Function\nThe PluginManager requires a global function named initialize in your main.py. This function's job is to:\n\n1. Get the plugin's unique key (the folder name).\n\n2. Create an instance of your main plugin class.\n\n3. Register the instance with the PluginManager.\n\nThis is the crucial step that connects your plugin to the main application.\n\n```python\n# plugins/my_new_plugin/main.py\nimport os\n\n# (Metadata and Class definition from above)\n# ...\n\ndef initialize(plugin_manager_instance):\n \"\"\"\n This function is called by the PluginManager to initialize the plugin.\n \"\"\"\n # Get the plugin's unique key from its directory name\n # os.path.basename(os.path.dirname(__file__)) will return \"my_new_plugin\"\n plugin_key = os.path.basename(os.path.dirname(__file__))\n\n try:\n # Create an instance of your main plugin class\n plugin_instance = MyPlugin(plugin_manager_instance, plugin_key)\n\n # Register the plugin instance with the manager\n # This makes the manager aware of the plugin and its instance\n plugin_manager_instance.plugins[plugin_key] = {\n 'instance': plugin_instance,\n 'is_enabled_by_default': False # ALWAYS FALSE NEVER CHANGE THIS\n }\n\n print(f\"[{plugin_key}] Plugin initialized successfully.\")\n return True # IMPORTANT: Return True on successful initialization\n\n except Exception as e:\n print(f\"[{plugin_key}] Failed to initialize: {e}\")\n return False # Return False on failure\n```\n\nWith these steps, you have a complete, well-structured plugin that the system can discover, load, and run. The user can then enable and disable it manually through the application's plugin management UI."
},
{
"path": "Docs/engine/Save-File-Format.md",
"content": "Save and load functionality is handled by the [SaveManager](https://github.com/ViciousSquid/Dosidicus/blob/2.4.4_stable/src/save_manager.py) class. \n\nIt uses a structured approach that packages all game data into a single, portable file.
Save File Location and Types
The SaveManager creates and manages files within a `saves` directory in the application's root folder. It maintains two distinct save slots:
`autosave.zip`: This file is used for periodic, automatic saves that occur in the background.
`save_data.zip`: This file is used when the player manually saves their game through the File menu.
Save File Structure
When `save_game()` is called, it bundles data into the following internal JSON files within the zip archive:
game_state.json: Contains general game state information, such as the squid's core stats (hunger, happiness), and other top-level game variables.
brain_state.json: Stores the complete state of the neural network, including neurogenesis data and the `pattern buffer` of learned experiences.
ShortTerm.json: A snapshot of all memories currently in the squid's short-term memory.
LongTerm.json: A snapshot of all memories that have been consolidated into long-term memory.
plugin_data.json: Contains any persistent data that active plugins have chosen to save.
statistics.json: Stores persistant statistics tracked over time such as squid age, distance swam, foods eaten, etc
uuid.txt: Unique squid identifier (128bit number)
\n\n------------------------------------------\n\n[SaveViewer.html](../extras/SaveViewer.md) is available for easy viewing and comparisons of save files. \n\nThis tool can also convert old v1 saved games (pre 2.4.5.0) to the new v2 format (2.5.0.0+)\n\n"
},
{
"path": "Docs/engine/config.ini.md",
"content": "The [config.ini](https://github.com/ViciousSquid/Dosidicus/blob/2.4.4_stable/config.ini) file allows for the fine-tuning of various game mechanics without needing to alter the source code. It is structured into sections, each controlling a different aspect of the application's behavior. \n\n```\nNOTE: As of 2.6.1.0 there is a dedicated preferences window that exposes every setting. \nit can be accessed via the View menu (View>Preferences)\nManual editing of the Config file still works but is not recommended\n```\n\n
[General]
\n\n`language`: = `en` (Default) - Can be `de`, `en`, `es`, `fr`, `ja`, `ml` or `zh`\n\n
[Debug]
\n\n`multiplayer_debug` Show debug messages when multiplayer is enabled (Defaults to False) [Developer feature]\n\n
[RockInteractions]
This section controls the logic for how the squid interacts with rock items.
pickup_probability: A value from 0.0 to 1.0 representing the chance the squid will decide to pick up a rock it encounters.
throw_probability: A value from 0.0 to 1.0 representing the chance the squid will throw a rock it is currently carrying.
min_carry_duration: The minimum time in seconds the squid will carry a rock before considering throwing it.
max_carry_duration: The maximum time in seconds the squid will carry a rock.
cooldown_after_throw: Time in seconds the squid must wait after throwing a rock before it can throw another.
happiness_boost, satisfaction_boost, anxiety\\reduction: The numerical amount that the corresponding stats are changed when a positive rock interaction occurs.
[Neurogenesis]
This is the main section for controlling the creation of new neurons.
enabled: A boolean (True/False) that globally enables or disables the neurogenesis feature.
cooldown: The mandatory waiting period in seconds after a neuron is created before another one can be.
max_neurons: The maximum number of neurons the brain can have. Neurogenesis stops if this limit is reached and pruning is enabled.
These subsections control the specific triggers for creating new neurons. Each has the following parameters:
enabled: Enables or disables this specific pathway for neurogenesis.
threshold: The value the corresponding counter must exceed to trigger neuron creation.
decay_rate: The rate at which the counter's value decreases over time (e.g., 0.80 means the counter retains 80% of its value after a decay cycle).
max_counter: The maximum value the counter can reach.
*_modifier: Personality-specific multipliers that make it easier or harder for certain personalities to trigger neurogenesis (e.g., adventurous_modifier = 1.2 makes adventurous squids 20% more sensitive to novelty).
[Neurogenesis.NeuronProperties]
This section defines the default properties for newly created neurons.
base_activation: The initial activation value for a new neuron.
position_variance: Determines the random offset when placing a new neuron on the brain map.
default_connections: A boolean to enable or disable the automatic creation of pre-wired connections for new neurons.
connection_strength, reciprocal_strength: The initial weights for the default connections that a new neuron forms.
These sections control the visual feedback for neurogenesis.
*_color: Defines the RGB color for each type of new neuron.
*shape: Defines the shape (triangle, square, circle) for each type of new neuron.
highlight_duration, highlight_radius: Controls the size and duration of the visual highlight effect when a neuron is created.
pulse_effect, pulse_speed: Configures the pulsing animation on the new neuron.
"
},
{
"path": "Docs/extras/Achievements.md",
"content": "Achievements are implemented via the [achievements plugin](https://github.com/ViciousSquid/Dosidicus/tree/2.5.0.0_latest_release/plugins/achievements) (Enabled by default)\n\n\n# Achievements List\n\n### **Total Achievements:** **50** (41 visible, 9 secret)\n Worth 1125 max possible points\n\n---\n\n## 🍽️ Feeding Category (5)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🍽️ | First Bite | Feed the squid for the first time | 10 | 1 |\n| 🥄 | Regular Meals | Feed the squid 10 times | 15 | 1 |\n| 🍴 | Dedicated Caretaker | Feed the squid 50 times | 25 | 2 |\n| 👨🍳 | Master Chef | Feed the squid 100 times | 50 | 3 |\n| 🌟 | Culinary Legend | Feed the squid 500 times | 100 | 4 |\n\n---\n\n## 🧠 Neurogenesis Category (6)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🧠 | Brain Spark | Create the first neurogenesis neuron | 20 | 1 |\n| 🔮 | Neural Network | Create 10 neurons through neurogenesis | 30 | 2 |\n| 💫 | Expanding Mind | Create 50 neurons through neurogenesis | 50 | 3 |\n| 🌌 | Cerebral Powerhouse | Create 100 neurons through neurogenesis | 75 | 4 |\n| ⚡ | Strengthened Synapse | Level up a neuron for the first time | 15 | 1 |\n| 🌠 | Peak Performance | Level a neuron to maximum strength | 40 | 3 |\n\n---\n\n## 😴 Sleep Category (3)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 😴 | Sweet Dreams | The squid wakes from its first sleep | 10 | 1 |\n| 🛏️ | Well Rested | The squid has slept 10 times | 20 | 2 |\n| 💭 | Deep Dreamer | Squid entered REM sleep | 25 | 2 |\n\n---\n\n## 📅 Milestones Category (7)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| ⏰ | One Hour Old | Squid reached 1 hour old | 15 | 1 |\n| 📅 | Growing Up | Squid reached 10 hours old | 30 | 2 |\n| 🎂 | One Day Wonder | Squid survived for 24 hours | 50 | 3 |\n| 🏅 | Week Veteran | Squid has lived for one week | 100 | 4 |\n| 🎖️ | Month Veteran | Squid has lived for one month | 150 | 5 |\n| 😄 | Pure Bliss | Reach 100% happiness | 20 | 2 |\n| ⚖️ | Perfect Balance | All stats above 80% simultaneously | 40 | 3 |\n\n---\n\n## 🧹 Cleaning Category (3)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🧼 | First Scrub | Clean the tank for the first time | 10 | 1 |\n| ✨ | Spotless Environment | Clean the tank 25 times | 25 | 2 |\n| 🧹 | Germaphobe | Keep cleanliness above 90% for 1 hour straight | 30 | 2 |\n\n---\n\n## 💊 Health Category (3)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 💊 | First Aid | Give medicine for the first time | 10 | 1 |\n| 🩺 | Doctor Squid | Give medicine 10 times | 20 | 2 |\n| 💪 | Comeback Kid | Recover from critically low health (<20%) to full | 40 | 3 |\n\n---\n\n## 🎯 Interaction Category (14)\n\n### Rocks\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🪨 | Rock Collector | Pick up a rock for the first time | 10 | 1 |\n| ⛰️ | Stone Gatherer | Pick up 10 rocks | 15 | 1 |\n| 🏔️ | Boulder Hoarder | Pick up 50 rocks | 30 | 2 |\n| 🎯 | Skipping Stones | Throw a rock for the first time | 10 | 1 |\n| 🚀 | Rock Launcher | Throw 25 rocks | 20 | 2 |\n| 💨 | Catapult Master | Throw 100 rocks | 40 | 3 |\n\n### Decorations & Plants\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🪴 | Interior Decorator | Push a decoration for the first time | 10 | 1 |\n| 🏠 | Furniture Mover | Push decorations 10 times | 15 | 1 |\n| 🎨 | Feng Shui Master | Push decorations 50 times | 30 | 2 |\n| 🌱 | Green Thumb | Interact with a plant for the first time | 10 | 1 |\n| 🌿 | Garden Explorer | Interact with plants 10 times | 15 | 1 |\n| 🌳 | Botanist | Interact with plants 50 times | 30 | 2 |\n\n### General Interaction\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🔍 | Curious Inspector | Investigate 25 different objects | 25 | 2 |\n| 🕵️ | Master Detective | Investigate 100 different objects | 50 | 3 |\n\n---\n\n## 💩 Exploration Category (1)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 💩 | Mischief Maker | Squid threw a poop for the first time | 10 | 1 |\n\n---\n\n## 🖤 Ink Category (2)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🖤 | Smoke Screen | Squid releases ink cloud for the first time | 15 | 1 |\n| 🌫️ | Ink Master | Release 20 ink clouds | 25 | 2 |\n\n---\n\n## 💾 Memory Category (3)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 💾 | First Memory | Form the first memory | 15 | 1 |\n| 🗄️ | Long Term Thinking | Promote a memory to long-term storage | 25 | 2 |\n| 📚 | Photographic Memory | Have 50 memories stored | 40 | 3 |\n\n---\n\n## 😊 Emotional Category (4)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🤔 | Curious George | Curiosity reaches 100% | 15 | 1 |\n| 🧘 | Zen Master | Keep anxiety below 10% for 30 minutes | 30 | 2 |\n| 😱 | Startled! | Startle the squid for the first time | 10 | 1 |\n| 😰 | Nervous Wreck | Anxiety reaches 100% | 15 | 2 |\n\n---\n\n## 🔬 Meta Category (3)\n\n| Icon | Name | Condition | Points | Tier |\n|------|------|-----------|--------|------|\n| 🔬 | Brain Surgeon | Open the brain visualization tool | 10 | 1 |\n| ⏩ | Speed Demon | Run simulation at max speed for 10 minutes | 15 | 2 |\n| 🏆 | Completionist | Unlock 30 other achievements | 100 | 4 |\n\n---\n\n## 📊 Tier System\n\nThe tier system uses 5 levels with different colors:\n\n| Tier | Name | Color | Example Achievements |\n|------|------|-------|----------------------|\n| 1 | Bronze | #CD7F32 | First Bite, Brain Spark, Sweet Dreams |\n| 2 | Silver | #C0C0C0 | Regular Meals, Neural Network, Pure Bliss |\n| 3 | Gold | #FFD700 | Master Chef, Peak Performance, Perfect Balance |\n| 4 | Platinum | #E5E4E2 | Culinary Legend, Cerebral Powerhouse, Completionist |\n| 5 | Diamond | #B9F2FF | Month Veteran |\n\n---\n\n## Summary Statistics\n\n- **Total Achievements:** 50\n- **Visible Achievements:** 41\n- **Hidden Achievements:** 9\n- **Total Points Available:** 1,125\n- **Most Common Tier:** Tier 1 (Bronze)\n- **Most Common Category:** Interaction (14 achievements)\n"
},
{
"path": "Docs/extras/Decoration-Window.md",
"content": "\n\n\n# Press `D` to open the decorations window\n* ## or use the `View > Decorations` menu\n\n------------------------\n\nThe Decorations Window is your catalog for all the items you can use to furnish your squid's environment. Placing decorations is not just for cosmetic appeal; each item has a unique effect on the squid's mood and well-being, influencing his stats and behavior. This feature allows you to customize the tank and actively manage your squid's environment.
How to Use the Decorations Window
Opening the Window: To open the catalog, navigate to the menu bar at the top of the main application window, click on View> Decorations (`Or simply press T`) \n
Adding an Item: To place a decoration, click and hold the desired item from the Decorations Window, drag it over to the main tank area, and release to drop it.
Interacting with Placed Decorations
Once an item has been dropped into the tank, you can manipulate it directly:
Select: Click on any decoration in the tank to select it.
Move: Click and drag a selected item to move it.
Resize: Select an item use mouse wheel to scale it. Note that some items, like rocks, cannot be resized.
Delete: Select an item and press Delete to permanently remove it from the tank.
Decoration Effects
Every decoration has hidden properties defined in [decoration_stats.json](https://github.com/ViciousSquid/Dosidicus/blob/2.4.4_stable/src/decoration_stats.json) - when the squid interacts with or is near a decoration, these properties can influence his statistics, such as happiness, anxiety, and curiosity. Experiment with different items to see how they affect your squid's mood and development!\n"
},
{
"path": "Docs/extras/Easter-Eggs.md",
"content": "\n\n On the About tab of the Brain Window, a colour can be selected for the squid.\n\nThis colour will be added to your save file and will persist across play sessions\n\n--------------\n\n\n\n**ml** (Millennial) is an available language (along with 7 others)\n\n--------------\n\nResizing the play window will startle the squid\n"
},
{
"path": "Docs/extras/SaveViewer.md",
"content": "#### SaveViewer.html\n\n* Quickly and easily open save files and view the contents.\n* `Network` tab visualises entire network\n* No need to open the game\n\n"
},
{
"path": "Docs/extras/UUID.md",
"content": "When a squid is created at the start of a new game he is assigned a unique fingerprint (also the name of his save file)\n\nIt looks like this:\n```example\nSquidSignature ab148370-6cd7-4d7e-a3d2-e33b68c4b615\n```\n\n\nThis currently serves no purpose but in future it will be used for any/all/none of the following:\n\n* DNA / Genetic code\n* Encoding personality traits/behaviours\n* Use as node name in multiplayer\n* seed to always generate the exact same squid\n* Verification (used as a 'magic number' or checksum)"
},
{
"path": "Docs/getting-started/Care-Guide.md",
"content": "
Care Guide: Nurturing Body and Mind
Caring for your squid is a unique experience that goes beyond simple pet simulation. You are not only responsible for its physical well-being but also for the growth and development of its simulated brain. This guide will walk you through the essentials of caring for your squid's core needs and enriching its environment to foster a healthy, intelligent, and happy companion.
Part 1: Managing Your Squid's Core Needs
Your squid has several fundamental needs that you must monitor and manage. These are handled primarily through the Actions menu in the main application window.
Feeding Your Squid:
How: Select Actions > Feed from the menu to drop food into the tank.
Why: Hunger is a primary driver of your squid's behavior. A hungry squid will become anxious and its happiness will decrease. Feeding it not only satisfies hunger but also increases happiness and satisfaction, creating a positive memory.
Cleaning the Environment:
How: As your squid lives in its environment, it will produce poop. Select Actions > Clean or click on a poop and press DEL to delete it.
Why: A dirty environment is a major source of stress and anxiety for your squid. Keeping the tank clean is essential for maintaining high happiness and low stress levels.
Administering Medicine:
How: If your squid becomes sick, select Actions > Medicine.
Why: Sickness can negatively impact all of your squid's stats. Promptly administering medicine is crucial for its recovery and overall health.
Part 2: Enriching Your Squid's Mind & Stimulating the Brain
A healthy squid needs more than just food and a clean tank; it needs mental stimulation. Your actions directly influence the development of its neural network through learning (strengthening connections) and neurogenesis (creating new neurons).
Fostering Learning (Strengthening Connections)
Your squid's brain learns by associating events. When two of its neurons are active at the same time, the connection between them gets stronger. You can encourage this process through consistent care.
Example: When your squid is hungry, its hunger neuron is highly active. When you feed it, its satisfaction neuron becomes active. The brain sees these two events happen together and strengthens the connection between them. Over time, the squid \"learns\" that eating leads to satisfaction.
Stimulating Neurogenesis (Creating New Neurons)
Neurogenesis is the birth of new neurons and is the key to enriching your squid's mind. You can trigger this process by providing specific types of stimulation that correspond to the three neurogenesis pathways.
1. Provide Novelty:
Goal: To create novel neurons that boost curiosity.
How-To: The best way to provide novelty is to regularly change the squid's environment. Open the Decorations window (from the View menu) and drag-and-drop new items like plants or different rocks into the tank. Each new object the squid investigates increases the novelty counter, and when it surpasses its threshold, a new neuron can be born.
2. Provide Rewards:
Goal: To create reward neurons that reinforce happiness and satisfaction.
How-To: Positive reinforcement is key. Consistently feeding the squid when it's hungry, keeping its tank clean, and encouraging play (like interacting with rocks) will increase the reward counter. This teaches the squid which behaviors lead to positive outcomes.
3. Provide Healthy Challenges:
Goal: To create stress neurons that act as coping mechanisms for unpleasant situations.
How-To: While chronic stress is harmful, allowing the squid to experience and overcome small, manageable stressors helps it build resilience. For instance, allowing it to get moderately hungry before feeding it can build the stress counter. When a stress neuron is created, it comes pre-wired with an inhibitory connection to the anxiety neuron, effectively making your squid better at managing anxiety in the future.
Cater to Your Squid's Personality
Remember that every squid has a unique personality that affects its needs. Check the Personality Tab in the Brain Tool to understand your squid's specific traits and get tailored advice.
Example: A Timid squid's anxiety will decrease significantly when it is near plants, making them an essential decoration for its well-being. In contrast, an Adventurous squid will thrive on a constantly changing environment with new decorations to investigate, which will be your primary method for providing novelty.
"
},
{
"path": "Docs/getting-started/Changelog.md",
"content": "### version 2.6.1.2\n`23 Feb 2026`\n\n* Optional [hardware AI accelerator support via ONNX Runtime](../neural-network/AI-Accelerator-Support.md) - _Experimental, disabled by default_\n\n* NEW: [brain_to_keras.py](https://github.com/ViciousSquid/Dosidicus/blob/2.6.1.2_LatestVersion/extras/brain_to_keras.py) (from the dev branch) in the `extras` folder - _attempts to convert a Dosidicus brain.json to Keras v3 (experimental)_\n\n* Improved Brain Tool short-term and long-term memory tabs: **more varied and verbose memories**\n* **Random Humboldt squid facts** can occasionally appear in status bar\n* FIXED: BrainTool Hebbian timers weren't in sync [(20)](https://github.com/ViciousSquid/Dosidicus/issues/20)\n* FIXED squid now properly goes to sleep when sleepiness=max\n\n-------------------------\n\n\n### version 2.6.1.1\n`20 Feb 2026`\n\n### Milestone 2\n* Added `linux_setup.sh`\n* Code optimisations & bug fixes\n\n-------------------------\n\n### version 2.6.1.0\n\n`21 Jan 2026`\n\n#### build 1219\n* Translation files for 7 languages: _English_, _French_, _Spanish_, _German_, _Chinese_, _Japanese_, _Millennial_\n* [Stable release for Windows](https://github.com/ViciousSquid/Dosidicus/releases/tag/v2.6.1.0)\n\n`18 Dec 2025`\n\n#### build 1218 **Milestone 2** Release \n* Integrated Designer into Brain Tool\n* Added ability to create custom neurons\n* NEW: [Headless brain trainer](https://github.com/ViciousSquid/Dosidicus/blob/v2.6.1.0__b1218_LatestVersion/headless/README_headless_trainer.md) with accelerated time epochs\n* NEW: Global preferences window\n* Added an additional 4 custom brains\n* French and Spanish Translations (_does not currently include Designer_)\n\n-------------------\n\n### version 2.6.0.3\n`11 Dec 2025`\n\n* Added FEED, CLEAN, MEDICINE buttons to UI\n* Added 5 example [custom brains](https://github.com/ViciousSquid/Dosidicus/tree/2.6.0.2_latest_release/custom_brains)\n* Neuron/font sizes and other UI elements now configurable via config.ini\n* FIXED: missing `update_score` method in `StatisticsWindow`\n* [Brain Designer](../brain-tool/Brain-Designer.md) can now import current running brain from Brain Tool\n* NEW: Neuron output bindings can be used to create simple IF THEN behaviours for the squid\n\n-------------------\n\n### version 2.6.0.2\n`8 Dec 2025`\n\n* NEW: [Brain Designer](../brain-tool/Brain-Designer.md) - create your own custom squid brains!\n* NEW: 5 custom brain templates that can be edited however you like [[dir](https://github.com/ViciousSquid/Dosidicus/tree/2.6.0.1_latest_release/custom_brains)]\n* NEW: [Example squid](../getting-started/Example-Squids.md) **Miroslav**\n\n-------------------\n\n### version 2.5.0.0\n`3 Dec 2025`\n\n* New [Save Viewer](../extras/SaveViewer.md)\n* Added 8 additional plant decorations & associated stats\n* Brain Network tab now has buttons for Experience Buffer and Neuron Laboratory\n* Fixed a bug where the brain state was not being restored properly from save\n* Added [showman wrapper](../source-reference/neurogenesis_show.py.md) for Neurogenesis\n* Code refactoring and removal of legacy cruft (pre version 2.4.X)\n* Feature-complete stable code-base \n\n-------------------\n\n### version 2.4.5.1 _patch_\n`25 Nov 2025`\n\n* [Engine](../engine/Engine-Overview.md) update - Neurogenesis and hebbian calculations now in own thread so UI remains responsive\n* **New**: Improved [multiplayer](../engine/Multiplayer.md) plugin!!\n* **New**: [Achievements](../extras/Achievements.md) (50 to collect)\n* **New**: Full interactive tutorial when starting a new game\n* Every squid is born with a `uuid` that stays with him his entire life\n* Added [Neuron Laboratory](../brain-tool/Neuron-Laboratory.md) via the View menu or by double clicking any neuron\n\n\n\n-------------------\n\n### version 2.4.5.0\n`15 Nov 2025`\n\n* Improved [plugin manager](../engine/Plugin-System.md)\n* Massively overhauled and [improved](../source-reference/neurogenesis_show.py.md) neurogenesis\n* Track statistics such as squid age, distance travelled, total foods eaten, etc\n* Improved load/save mechanism (backward compatible with v2.3 saves and earlier)\n* Hebbian now trains on 2 active neuron pairs at once\n* Redesigned Brain Tool [learning tab](../brain-tool/Learning-Tab.md)\n* Global counters now respect game speed\n* Arcade-style (High-Score) system\n* Animations throughout the UI\n\n\n-------------------\n\n### version 2.4.4.1\n`04 Sept 2025`\n\n* Code cleanup and stability improvements\n* WIP: Track statistics such as squid age, distance travelled, total foods eaten, etc\n* ADDED: Small chance of squid creating an ink cloud when startled\n* ADDED: Experimental [multiplayer](../engine/Multiplayer.md) plugin\n\n-------------------\n\n### version 2.4.3\n\nMilestone 1\n\n**Initial stable release**\n\n### **AUTHOR GOT A TATTOO** to celebrate 1 year of this project!\n\n\n\n "
},
{
"path": "Docs/getting-started/Example-Squids.md",
"content": "```\nThe example_squids folder contains saved brains that have already accumulated some experiences:\n```\n-------------------------\n\n\n### [b071f720_593e_471f_8412_8ee84172a1b0.zip](https://github.com/ViciousSquid/Dosidicus/blob/2.6.0.0_latest_release/example_squids/b071f720_593e_471f_8412_8ee84172a1b0.zip) \n\n#### Squid name: Miroslav | Age: 5 | Number of neurons: 12\n\n* Young squid with default brain type (7 core neurons)\n* ${\\color{red}stress}$ neurons have developed in response to being extremely hungry in the past\n* ${\\color{yellow}novelty}$ neurons have developed - positive experiences related to investigation/exploration\n* many connections (111!) - strong brain, highly responsive, quick to learn (high plasticity)\n* `novelty_object_investigation` has extremely high multiplier of 14 suggesting episodes of manic excitement\n\n\n\n\n\n-------------------------\n\n"
},
{
"path": "Docs/getting-started/Home.md",
"content": "### _A transparent neural sandbox disguised as a digital pet_\nA micro neural engine for small autonomous agents that learn via Hebbian dynamics and grow new structure when exposed to novelty.\n\n----------------------------------\n\n## [Manifesto](https://github.com/ViciousSquid/Dosidicus/wiki/Cognitive-Sandbox-Manifesto-%7C-Artificial-Life-and-Transparent-Neural-Systems) | [Wiki](https://github.com/ViciousSquid/Dosidicus/wiki) | [Changelog](https://github.com/ViciousSquid/Dosidicus/wiki/changelog) \n\n----------------------------\n\n## Getting Started\nNew to Dosidicus? Start here to understand how to interact with your squid.\n* **[Care Guide / Getting Started](../getting-started/Care-Guide.md)**\n* **[Personalities](../neural-network/Personality.md)** — How different squid types behave.\n* **[Decoration Window](../extras/Decoration-Window.md)** — Managing the squid's environment.\n\n---\n\n\n### Biological Autonomy\n* **[Vision System](../neural-network/Vision-System.md)** — Realistic foraging and food detection.\n* **[Hebbian Learning](../neural-network/Hebbian-Learning.md)** — The algorithm behind 30-second learning cycles.\n* **[Neurogenesis](../neural-network/Neurogenesis.md)** — How the squid creates new neurons based on environment.\n* **[Decision Engine](../engine/Decision-Engine.md)** — Making choices based on hunger, sleep, and memory.\n\n### Engine Architecture & Logic\n* **[Engine Overview](../engine/Engine-Overview.md)** — High-level system architecture.\n* **[main.py](../source-reference/main.py.md)** — The main simulation loop.\n* **[tamagotchi_logic.py](../source-reference/tamagotchi_logic.py.md)** — Core needs and health management.\n* **[squid.py](../source-reference/squid.py.md)** — The physical squid class.\n* **[Memory System](https://github.com/ViciousSquid/Dosidicus/blob/main/Docs/Memory%20System.md)** & **[memory_manager.py](../source-reference/memory_manager.py.md)** — Managing experiences.\n\n---\n\n## Tools & Configuration\nFine-tune the simulation and monitor the squid's neural activity.\n\n### [The Brain Tool](../brain-tool/Network-Tab.md)\n* **[Network Tab](../brain-tool/Network-Tab.md)** | **[Learning Tab](../brain-tool/Learning-Tab.md)**\n* **[Memory Tab](../brain-tool/Memory-Tab.md)** | **[Decisions Tab](../brain-tool/Decisions-Tab.md)**\n* **[Personality Tab](../neural-network/Personality.md-tab)**\n\n### System Settings\n* **[config.ini](../engine/config.ini.md)** — Adjusting simulation parameters.\n* **[Save File Format](../engine/Save-File-Format.md)** — Structure of persisted data.\n* **[Plugin System](../engine/Plugin-System.md)** — Extending the engine's capabilities.\n"
},
{
"path": "Docs/neural-network/AI-Accelerator-Support.md",
"content": "#### New in v2.6.1.2 (experimental)\n\n[compute_backend.py](https://github.com/ViciousSquid/Dosidicus/blob/2.6.1.2_onnx/src/compute_backend.py) facilitates hardware acceleration for neural calculations by changing one line:\n\nin `config.ini`:\n\n```\n[Compute]\n\nbackend = numpy\n```\n\n Options:\n- `numpy` - default, no extra dependencies\n- `onnx` - enables hardware AI accelerator support via ONNX Runtime\n\nauto-selects `DirectML`, `OpenVINO`, `QNN`, or falls back to `numpy` if no runtime is present.\n\n---------------------------------\n\nrequires package to be installed (refer to the following list:)\n\n#### Recommended packages by platform:\n\n- **Windows** | _NVIDIA + AMD + Intel GPU + NPU (DirectML)_ | `pip install onnxruntime-directml`\n\n- **Windows** | _NVIDIA only (maximum CUDA performance)_ | `pip install onnxruntime-gpu`\n\n- **Windows** | _Qualcomm 8CX / SQX / Snapdragon (NPU)_ | `pip install onnxruntime-qnn`\n\n- **macOS** | _Apple Silicon and Intel Macs_ | `pip install onnxruntime`\n\n- **Linux** | _NVIDIA GPUs_ | `pip install onnxruntime-gpu`\n\n- **Linux** | _AMD GPUs_ | Use the ROCm/MIGraphX build (see [ONNX Runtime docs](https://onnxruntime.ai/docs/execution-providers/MIGraphX-ExecutionProvider.html))\n\n```\n\nIf no package is installed, the default `numpy` will be used (neural calculations performed on CPU)\nAny failure conditions will print to the console and we fall back to default `numpy`\nDetection should happen automatically. ONNX SUPPORT IS NEW AND EXPERIMENTAL\n```\n\n-------------------------------\n\nThe Brain Tool Network Tab displays which backend is being used in (top right)"
},
{
"path": "Docs/neural-network/Experience-Buffer.md",
"content": "\nThe Experience Buffer is a core component in the system's learning and [neurogenesis](../neural-network/Neurogenesis.md) (neuron creation) module that functions as a memory for recent, significant events. It maintains a time-ordered log of the squid's context and uses this data to identify recurring patterns, which helps the system decide when and how to create new, functionally specialized neurons.\n\n#### How the Experience Buffer Works\nThe experience buffer is technically implemented as the `ExperienceBuffer` class, which operates in two main ways: maintaining a rolling log and tracking pattern recurrence.\n\n1. Rolling Log (deque): The buffer uses a deque (double-ended queue) to store a fixed, limited number of recent experiences (default maximum is 50 experiences). When a new experience is added, the oldest one is automatically discarded, ensuring the buffer only contains the latest, most relevant context.\n\n2. Pattern Tracking: When an experience is added, it is processed to generate three levels of **pattern signatures**, which are counted to track how often similar events occur:\n\n* **Specific Pattern**: The most detailed signature, identifying a precise combination of `trigger`, `outcome`, and primary motivational neuron state.\n\n* **Parent Pattern**: A broader pattern used for hierarchical grouping.\n\n* **Core Pattern**: A minimal pattern used for \"fuzzy matching\" or identifying basic event categories.\n\nThe system analyses these counts to determine if a situation is a novel event or a recurring pattern, which heavily influences whether a new neuron is created, or if an existing neuron is strengthened.\n\n\n\n----------------\n\n#### Example Experiences (ExperienceContext)\n\n\n\nEach recorded experience is captured as an ExperienceContext object, which is a snapshot of the squid's state and environment at the moment a significant event (the trigger) occurs.\n\n* `trigger_type` - The general category of the event: `novelty`, `stress`, or `reward`.\n* `outcome`\t- The result of the experience: `positive`, `negative`, or `neutral`.\n* `active_neurons`\tA dictionary of all current neuron activations (e.g., {`hunger`: 20, `anxiety`: 85}).\n* `recent_actions`\tA list of recent actions taken by the squid (e.g., [`approach_plant`, `hide`]).\n* `environmental_state`\tKey external facts at the time (e.g., {`food_count`: 0, `has_rock`: True}).\n\n\n"
},
{
"path": "Docs/neural-network/Hebbian-Learning.md",
"content": "The neural network in Dosidicus does not use traditional backpropagation for training. Instead, it employs a form of Hebbian learning, a biologically-inspired principle summarized as \"neurons that fire together, wire together.\" This method allows the network to learn associations and patterns organically based on the squid's concurrent states, without requiring a separate training phase. The entire process is managed within the perform_hebbian_learning and update\\_connection methods.
1. The Learning Cycle
Learning is not continuous but occurs in discrete cycles to ensure stability and reduce computational load.
Timed Trigger: The learning cycle is initiated by a timer. The interval for this timer is configurable in config.ini under the \\[Hebbian\\] section's learning_interval parameter (default every 30000 milliseconds).
Pre-Pruning: Before each learning cycle begins, a pruning function is called to remove extremely weak and old connections from the network. This helps maintain network efficiency by clearing out irrelevant pathways before new learning occurs.
2. The Core Learning Process
The perform_hebbian_learning method executes a precise sequence of steps to update the network's weights.
Identify Active Neurons: The system first scans all neurons in the brain. Any neuron whose activation value is above the active_threshold defined in the configuration is considered \"active\" for this learning cycle. System-level neurons (e.g., is_eating, direction) are excluded from this process.
Random Pair Sampling: If fewer than two neurons are active, the learning cycle is aborted. If there are enough active neurons, the system does not update all possible pairs. Instead, it randomly samples a small number of pairs (e.g., two) from the pool of active neurons. This stochastic approach introduces variability and prevents the network from over-stabilizing into rigid patterns.
Update Connection Weight: For each selected pair, the update_connection method is called. This is where the core weight calculation happens:
Base Hebbian Rule: The fundamental change in weight is calculated by multiplying the two neurons' normalized activation values by a learning rate. This reinforces the connection between them.
Dynamic Learning Rate: The learning rate is not static. If one of the neurons in the pair was recently created via neurogenesis, the learning rate is temporarily boosted (e.g., by a factor of 2.0). This allows new, specialized neurons to integrate into the network more quickly and form meaningful connections.
Weight Decay: To prevent runaway weight growth and to help the network \"forget\" insignificant associations, a small decay factor is applied during the update. This factor, configured via weight_decay in config.ini, slightly reduces the magnitude of the connection's weight during each update.
Clamping: The final calculated weight is always clamped to a range of \\[-1.0, 1.0\\] to keep it normalized and prevent extreme values from destabilizing the network.
3. Visual Feedback
The learning process is tied directly to the application's user interface to provide clear, real-time feedback.
Activity Log: In the \"Learning\" tab of the Brain Tool, a log entry is created for each learning event, explicitly stating which neuron pair had its connection strengthened or weakened and by how much.
Network Animation: In the \"Network\" tab, the connection line between the learning pair will briefly glow or pulse. The color of the pulse indicates whether the weight increased (positive reinforcement) or decreased (negative reinforcement), providing an immediate visual cue of the learning event.
"
},
{
"path": "Docs/neural-network/Neurogenesis.md",
"content": "`neurogenesis.py` is the brains’ stem-cell layer: it decides when, why, and how new neurons appear, makes sure they are immediately functional, keeps the network within size & specialization limits, and cleans up the least useful ones—all through a single, auditable pipeline.\n\n#### Unified neuron creation\n* `create_neuron()` – the only public entry-point used by the UI, BrainWorker, save-load, etc.\n* `create_functional_neuron()` – internal helper that always produces a FunctionalNeuron.\n* All neurons are converted into FunctionalNeuron objects\n\n#### Context-aware experience tracking\n* `ExperienceContext` – a snapshot of why the neuron is being made (trigger type, brain state, environment, outcome, recent actions).\n* `ExperienceBuffer` – rolling FIFO buffer (≈ 50 experiences) that counts how often each specific / parent / core pattern recurs; used to decide when a neuron should actually be spawned.\n* `NeurogenesisTriggerSystem` – state-delta detection (novelty spikes, stress surges, reward rebounds).\n\n#### Functional specialization & wiring\n* Every neuron gets a specialization string (feeding_satisfaction, filth_avoidance, object_investigation, …) derived from the context.\n* `get_functional_connections()` – returns a weighted connection list to existing neurons so the new cell is immediately useful instead of random.\n* `_make_reciprocal_connections()` – guarantees that any outgoing connection ≥ 0.2 gets a matching incoming link so the new neuron can activate/be activated.\n\n#### Placement & visuals\n* `_calculate_functional_position()` – places the neuron near the neurons it will influence, not at random.\n* `_set_neuron_appearance()` – shape (diamond / square / triangle) and color palette encode type and specialization so users can “read” the brain at a glance.\n\n#### Soft & hard limits\n* Per-type caps (max_per_type) – e.g. max 3 stress, 5 novelty, 4 reward.\n* Per-specialization caps (max_per_specialization) – prevents 20 identical “hunger_stress_response” clones.\n* Global neuron cap (max_neurons) – total network size ceiling.\n* Cooldown – minimum seconds between any creation event.\n* Pattern-recurrence thresholds – neuron spawns only after a pattern has repeated 2–5× (depending on specificity).\n\n#### Strengthening instead of duplication\nIf a cap is hit, the system boosts an existing neuron (strength_multiplier, utility_score) rather than creating a redundant one.\n\n#### Pruning & housekeeping\n* `intelligent_pruning()` – removes the lowest-utility neuron that is > 5 min old, considering activation recency, uniqueness of specialization, and total synaptic weight.\n* `_rebuild_new_neurons_details_for_lab()` – guarantees the Laboratory “newest neurogenesis neurons” card always has origin data.\n\n#### State integration & runtime updates\n* `update_neuron_activations()` – every tick, functional neurons compute their value from incoming weights; stress neurons collectively suppress anxiety (bi-directional feedback).\n* Emits pulse animations for weights ≥ 0.15 (can be disabled).\n\n#### Persistence & save/load\n* `to_dict()` / `from_dict()` – serializes the entire `ExperienceBuffer`, every `FunctionalNeuron`, counters, and creation history.\n* `ensure_all_neurons_functional()` – on load, converts any legacy neurons discovered in [brain_widget](../source-reference/brain_widget.py.md) into FunctionalNeuron instances so the system stays unified.\n\n#### Achievement hooks\n`set_achievement_callbacks()` – lets the Achievements module receive “neuron created” and “neuron leveled” events for trophies."
},
{
"path": "Docs/neural-network/Personality.md",
"content": "Personality affects squid needs and behaviour. A random personality is assigned every time a new squid is born, and could be thought of as a sort of \"difficulty level\" with 'Lazy' being the easiest and 'Stubborn' being hardest.\n\nThere are seven different squid personalities that affect their needs and how they behave: \n\n* `Timid`: Higher chance of becoming anxious \n* `Adventurous`: Increased curiosity and exploration \n* `Lazy`: Slower movement and energy consumption \n* `Energetic`: Faster movement and higher activity levels \n* `Introvert`: Prefers solitude and quiet environments \n* `Greedy`: More focused on food and resources\n* `Stubborn`: Fussy and difficult \n\nOne of these is randomly chosen at launch\n\nA personality type can be forced at launch using the `-p` flag followed by the personality name above (example: `main.py -p lazy`) \n\nEach personality type presents unique challenges and requirements for the player to manage. Understanding and accommodating the specific needs and behaviors of each personality type is crucial for the player's success in caring for the squid and maintaining its well-being.\n\nHere's a description of the different personality types and their corresponding behaviors in the game:\n\n### `Timid` Personality:\n\n* Tendency to become anxious, especially when not near plants.\n* Moves slowly and prefers quiet, solitary environments.\n* Curiosity level is lower than other personalities.\n* Has a higher chance of becoming startled by decorations or other environmental factors.\n\n\n### `Adventurous` Personality:\n\n* Curious and exploratory, with a higher chance of entering the \"curious\" state.\n* Moves faster and is more active compared to other personalities.\n* Curiosity level is higher, leading to increased exploration and interaction with the environment.\n\n\n### `Lazy` Personality:\n\n* Moves and consumes energy at a slower pace.\n* Takes more time to fulfill their needs, such as eating and sleeping.\n* May be less responsive to environmental changes or stimuli.\n\n\n### `Energetic` Personality:\n\n* Moves and acts at a faster pace.\n* Tends to have higher activity levels and may expend energy more quickly.\n* May be more prone to restlessness or agitation.\n\n\n### `Introvert` Personality:\n\n* Prefers solitary environments and is content when alone.\n* May become unhappy or anxious when forced to interact with the environment or decorations.\n* Curiosity level is balanced, not too high or too low.\n\n\n### `Greedy` Personality:\n\n* Highly focused on food and resources, becoming anxious and hungry when those needs are not met.\n* Curiosity level may be higher, leading to more exploration, but this is primarily driven by the desire for food.\n* May become more aggressive or assertive in obtaining food or resources.\n\n\n### `Stubborn` Personality:\n\n* Only eats its favorite food (sushi), often refusing to consume any other type of food (cheese).\n* Displays the message \"Fussy squid does not like that type of food!\" when presented with non-favorite food.\n* Has a chance of refusing to sleep when its sleepiness is high, instead moving randomly.\n* Moves slowly and stubbornly when not actively searching for its favorite food.\n* Prioritizes sushi over cheese in its vision cone when searching for food.\n"
},
{
"path": "Docs/neural-network/STDP.md",
"content": "### Spike‐Timing‐Dependent Plasticity (STDP)\n\n_As of version 2.6.2.0_ this page has moved to the Wiki [[HERE]](https://github.com/ViciousSquid/Dosidicus/wiki/Spike%E2%80%90Timing%E2%80%90Dependent-Plasticity-(STDP))\n"
},
{
"path": "Docs/neural-network/Technical-Overview.md",
"content": "
Neural Network Technical Overview
\n\n\n\n
The system's neural network is a unique, single-layer, fully-connected network architecture that dynamically grows through a process of neurogenesis.\n\nTraditional backpropagation is not used for learning, instead relying on a pure Hebbian model (../neural-network/Hebbian-Learning.md)\n\n...\n\n
1. Core Architecture
The network starts as a single-layer perceptron with 7 core, named neurons. These neurons represent the fundamental emotional and physical states of the squid:\n\n* Circular (Basic Needs): hunger, happiness, cleanliness, sleepiness\n* Square (Complex States): satisfaction, anxiety, curiosity\n\nEach neuron's activation value ranges from 0-100.\n\n Unlike a typical deep learning model, this network is not structured into distinct input, hidden, and output layers. Instead, all neurons exist on a single plane and are fully interconnected. Each connection between two neurons has a weight, initialized with a random value between -1 and 1, which represents the strength and nature (excitatory or inhibitory) of their relationship.
2. Learning Mechanism: Hebbian Learning
The network updates its connection weights using a Hebbian learning rule, which follows the principle \"neurons that fire together, wire together.\"
Learning Cycle: The learning process is not continuous but occurs in discrete cycles, triggered by a timer (by default, every 30 seconds).
Activation: During a learning cycle, any neuron whose activation value exceeds a predefined threshold (e.g., > 50) is considered \"active.\".
Weight Update: The system randomly selects a few pairs of currently active neurons. The weight between these pairs is then adjusted according to the Hebbian rule: the change in weight is proportional to the product of the two neurons' activation values multiplied by a learning rate. This strengthens the connection between neurons that are concurrently active.
Weight Decay: To ensure network stability and prevent weights from growing indefinitely, a small weight decay is applied over time, gradually weakening all connections.
3. Dynamic Architecture: Neurogenesis
The network's most advanced feature is its ability to create new neurons, a process called neurogenesis. This allows the brain's architecture to grow and adapt based on the squid's experiences.
Triggers: Neurogenesis is initiated by one of three counters exceeding a set threshold:
Novelty: Increases when the squid encounters new objects or experiences.
Stress: Increases during stressful events.
Reward: Increases when the squid experiences a positive outcome.
Creation Process: When a counter surpasses its threshold and a cooldown period has passed, a new neuron is created.
The neuron is named based on its trigger (e.g., novel\\_0, stress\\_0).
It is positioned visually on the network graph near other currently active neurons.
Crucially, it is immediately connected to the existing network with a set of default weights. For example, a new 'reward' neuron automatically forms a strong positive connection to 'satisfaction' and 'happiness'.
Dynamic Thresholds: The thresholds required to trigger neurogenesis are not static. They scale upwards as the network grows in size, preventing runaway neuron creation and promoting stability in a mature network.
4. Network Stability and Pruning
To manage the complexity of a dynamically growing network, the system employs pruning mechanisms to remove inefficient or irrelevant components. This feature is critical for long-term network health and is enabled by default.
Connection Pruning: The system can periodically remove connections whose absolute weight falls below a very low threshold, cleaning up insignificant links.
Neuron Pruning: When the network approaches its configured maximum neuron limit, it can trigger the pruning of entire neurons. This process targets newly created (non-core) neurons that have failed to form strong connections or remain largely inactive.
The squid's ability to \"see\" and react to his environment is not based on simple proximity but on a simulated line-of-sight mechanic. This system is composed of two main parts: the View Cone, which is an attribute of the squid itself and represents his field of view, and the Vision Window (from vision.py), which is a debug tool that provides a first-person visualization of what the squid is currently perceiving.\n\n\n\n\n
1. The View Cone: The Mechanism of Sight
The core of the vision system is the \"View Cone.\" This is not a visual effect but an invisible geometric shape (specifically, a QPolygonF) that is mathematically projected from the squid's current position and orientation.
Dynamic and Directional: The View Cone is not static. It is recalculated every frame to match the squid's state. When the squid moves, the cone moves with it. More importantly, when the squid turns to face left, right, or up, the cone rotates accordingly. This ensures the squid can only perceive objects that are genuinely in his line of sight.
Object Detection via Intersection: The system determines what the squid \"sees\" by performing a continuous series of geometric intersection tests. The logic iterates through every object in the environment (decorations, food, poop, etc.) and checks if that object's bounding box intersects with the squid's View Cone polygon.
Informing the Brain: If an intersection is detected, the object is officially considered \"seen.\" This information is critical as it is fed directly into the squid's Decision Engine. For example, if \"food\" is seen, the desire to \"eat\" will likely increase. This allows the squid to make intelligent, context-aware decisions based on his immediate surroundings. The `has_food_visible` and `plant_proximity` inputs feed this system.
The Vision Window is a powerful debugging tool that renders the output of the View Cone, allowing you to see the world from the squid's perspective.
How It Works
The update_vision() method is the heart of this window and performs the following steps on each refresh:
Clear the Scene: It first clears its own display to ensure no leftover artifacts from the previous frame.
Get the View Cone: It fetches the squid's current View Cone polygon from the main game logic.
Draw the Cone: It draws a visual representation of the cone shape itself within its window, so you can see the precise boundaries of the squid's perception.
Render Seen Objects: It then performs the same intersection logic as the main decision engine. For every object whose bounding box intersects with the View Cone, it creates a copy of that object's pixmap and draws it inside the Vision Window. It also draws the bounding box of the seen object for clarity.
"
},
{
"path": "Docs/source-reference/brain_neuron_hooks.py.md",
"content": "#### brain_neuron_hooks.py\nThe **sensory input** system that bridges game events to neuron activations. It maintains a registry of handler functions that calculate activation values for input neurons based on the current game state. This is where environmental awareness enters the neural network—when the squid sees food, gets startled, or detects a nearby plant, these hooks translate those game conditions into numerical activations that propagate through the network.\n\n#### Handler Registry:\n\n* Maps neuron names to calculation functions\n* Built-in handlers for: `external_stimulus`, `can_see_food`, `plant_proximity`, `threat_level`, `is_eating`, `is_sleeping`, `is_fleeing`, `is_startled`, `pursuing_food`, `is_sick`\n\n#### Plugin Integration:\n\n* `register_handler(name, callable)` — allows plugins to add custom input neurons\n* `unregister_handler(name)` — removes custom handlers (built-ins protected)\n* Merges plugin handlers with built-in ones at runtime\n\n#### Event Tracking:\n\n* Maintains `event_tracker` dictionary for temporal calculations\n* Tracks window resizes, object spawns, user interactions with decay over time\n* `update_decay()` — decays event intensities each simulation tick\n\n#### Key Method:\n\n* `get_input_neuron_values()` — returns current activation values for all registered input sensors"
},
{
"path": "Docs/source-reference/brain_neuron_outputs.py.md",
"content": "#### brain_neuron_outputs.py\n**output system** that bridges neuron activations to game behaviours (bindings)\n\nWhen neurons fire above configurable thresholds, this system triggers corresponding game actions (hooks) like fleeing, seeking food, or changing colour. It completes the sensorimotor loop—inputs flow in through hooks, propagate through the network, and outputs emerge here to drive the squid's behaviour.\n\n#### NeuronOutputBinding Dataclass:\n\n* Binds a neuron to an output hook with threshold, trigger mode, and cooldown\n* Trigger modes: `THRESHOLD_RISING`, `THRESHOLD_FALLING`, `THRESHOLD_ABOVE`, `THRESHOLD_BELOW`, `ON_CHANGE`\nSerializable to/from dict for save/load support\n\n#### Standard Output Hooks:\n\n* Movement: `flee`, `seek_food`, `seek_plant`, `approach_rock`, `wander`\n* Actions: `throw_rock`, `pick_up_rock`, `ink_cloud`, `eat`, `change_color`\n* State Changes: `sleep`, `wake`, `startle`, `calm`\n* Stat Modifications: `boost_happiness`, `boost_curiosity`, `reduce_anxiety`\n\n#### NeuronOutputMonitor Class:\n\n* `monitor(activations)` — checks all bindings against current values, fires those meeting conditions\n* Respects cooldown timers to prevent rapid-fire triggering\n* Integrates with plugin system's hook dispatcher\n* Includes floating `NeuronLogWindow` for debugging fired outputs"
},
{
"path": "Docs/source-reference/brain_render_worker.py.md",
"content": "_Not to be confused with [brain_worker.py](../source-reference/brain_worker.py.md)_\n\n#### brain_render_worker.py (938 lines)\nAn offscreen rendering engine running in its own QThread that paints the entire brain visualization to a QImage buffer. The main thread simply blits this cached image during paintEvent, dramatically improving UI responsiveness. The worker receives immutable state snapshots and handles all the complex drawing logic—connections with animated pulses, neurons with various shapes, localized labels, and visual effects for learning events.\n\n#### RenderState Dataclass:\n\n* Immutable snapshot containing positions, states, colors, weights, and animation parameters\n* Created on main thread via `create_render_state_from_widget()` helper\n* Includes pre-calculated localized neuron labels to avoid i18n lookups during render\n\n#### Rendering Pipeline:\n\n`request_render(state)` — throttled to 10 FPS\n* Draws and animates neurons and connections\n"
},
{
"path": "Docs/source-reference/brain_tool.py.md",
"content": "#### Responsibilities\n\n* Builds the multi-tab window (Network, Learning, Memory, Decisions, Statistics, …).\n* Hosts the [BrainWidget](../source-reference/brain_widget.py.md) in the “Network” tab.\n* Exposes buttons, sliders, tables to stimulate neurons, export data, change learning rate, force a learning cycle, etc.\n* Persists / loads the whole brain state (weights, positions, neurogenesis history) to JSON.\n* Owns the [BrainWorker](../source-reference/brain_worker.py.md) thread instance (wraps the one inside BrainWidget) and restarts it if it crashes.\n* Bridges between the squid logic ([tamagotchi_logic](../source-reference/tamagotchi_logic.py.md)) and the brain widget:\n\n\n – every few seconds it copies the squid’s current `hunger`, `happiness`, `anxiety`… into the widget’s state so the network mirrors the squid.\n\n – when the network learns new weights, the squid can query them for [decision-making](../engine/Decision-Engine.md).\n\n\n\n#### Key internal objects\n\n* `self.brain_widget` – canvas widget ([brain_widget.py](../source-reference/brain_widget.py.md))\n* `self.tabs` – QTabWidget with all the inspector tabs\n* `self.config_manager` – central place for thresholds, intervals, colours, etc.\n* `self.tamagotchi_logic` – reference to the actual pet simulation (runs in the main game loop)"
},
{
"path": "Docs/source-reference/brain_widget.py.md",
"content": "### brain_widget.py\nThis is the main neural network visualization and coordination hub. It serves as the central controller that owns the authoritative brain state, coordinates background worker threads, and integrates all the subsystems that make the neural network function. Everything flows through this widget—stat updates from the game, rendering requests, learning signals, and neurogenesis events all converge here before being dispatched to the appropriate handlers.\n\n#### Core State Management:\n\n* Maintains the authoritative `state` dictionary with all neuron activations (hunger, happiness, anxiety, etc.)\n* Manages `weights` dictionary for connection strengths between neurons\n* Tracks `neuron_positions` for [visualization](../brain-tool/Network-Tab.md) layout\n\n#### Worker Coordination:\n\n* Receives an external [`BrainWorker`](../source-reference/brain_worker.py.md) via `set_brain_worker()` (avoids duplicate thread creation)\n* Owns a [`BrainRenderWorker`](../source-reference/brain_render_worker.py.md) for offscreen rendering\n* Coordinates signal/slot connections between workers and UI\n\n#### Subsystems Integrated:\n\n* [`EnhancedNeurogenesis`](../neural-network/Neurogenesis.md) for dynamic neuron creation\n* [`ExperienceBuffer`](../neural-network/Experience-Buffer.md) for tracking learning experiences\n* `EnhancedBrainTooltips` for hover information\n* Theming with animation styles (Vibrant, Subtle, etc.)\n* Brain state bridge for [designer](../brain-tool/Brain-Designer.md) synchronization\n\n#### Key Methods:\n\n* `update_brain_state(stats_dict)` — main entry point for stat updates from the game\n* `set_brain_worker()` — accepts external [worker](../source-reference/brain_worker.py.md) instance\n* `export_brain_state_for_designer()` — syncs state with the Brain Designer tool"
},
{
"path": "Docs/source-reference/brain_worker.py.md",
"content": "_Not to be confused with [brain_render_worker.py](../source-reference/brain_render_worker.py.md)_\n\n#### brain_worker.py\nA background QThread dedicated to handling computationally expensive brain logic that would otherwise block the UI. It operates on cached snapshots of brain state, processes tasks from a thread-safe queue, and emits results back to the main thread via signals. This separation keeps the simulation responsive even during complex Hebbian learning calculations or neurogenesis evaluations.\n\n#### Task Queue System:\n\n* Uses thread-safe `Queue` for task dispatch\n* Processes three task types: [`neurogenesis`](../neural-network/Neurogenesis.md), [`hebbian`](../neural-network/Hebbian-Learning.md), `state_update`\n* Supports pause/resume for game state changes\n\n#### Neurogenesis Checks:\n\n* Evaluates stress/novelty/reward triggers against configurable thresholds\n* Emits `neurogenesis_result` signal with creation recommendations\n* Handles emergency stress neuron creation when anxiety exceeds 90\n\n#### Hebbian Learning:\n\n* Selects top-k neuron pairs based on co-activation scores\n* Includes anti-loop mechanisms (randomization, cooldown penalties on recently-used pairs)\n* Can create new connections between previously unconnected co-active neurons\n* Emits weight updates back to main thread for application\n\n#### State Decay Processing:\n\n* Applies temporal decay toward baseline for non-input neurons\n* Adds small random noise for organic feel\n* Propagates connection effects through the network"
},
{
"path": "Docs/source-reference/custom_brain_loader.py.md",
"content": " #### custom_brain_loader.py\nThe brain architecture import/export system that allows custom neural network designs from the Brain Designer tool to be loaded into the live simulation. It handles parsing various brain file formats, applying the architecture to the running BrainWidget, and integrating with the save/load system so custom brains persist across game sessions. This is what makes the Brain Designer's output actually playable.\n\n#### Global State Tracking:\n\n* Tracks currently loaded custom brain name, definition, and source file path\n* `has_custom_brain()` / `get_custom_brain_name()` — API for querying current state\n\n#### BrainLoader Class:\n\n* `show_dialog()` — opens brain selection UI\n* `_parse(raw_data)` — normalizes different brain file formats into consistent structure\n* `_apply(parsed_brain)` — applies positions, weights, and output bindings to live BrainWidget\n* `reset_positions_to_default()` — restores original layout while preserving network structure\n\n#### Save/Load Integration:\n\n* `get_custom_brain_save_data()` — packages custom brain definition for game saves\n* `restore_custom_brain_from_save()` — restores custom brain when loading a save\n* `validate_custom_brain_save()` — checks if a save file's custom brain can be loaded\n* `show_custom_brain_load_warning()` — warns user when loading saves with custom brains\n\n#### BrainSelectDialog:\n\n* File browser UI for .json brain files in the brains folder\n* Shows metadata preview (neuron count, connection count, description)\n* Supports browsing to external files or opening the brains folder"
},
{
"path": "Docs/source-reference/designer_window.py.md",
"content": "#### designer_window.py\nThis is the primary application shell for the neural network Designer.\n\n#### Core Responsibilities:\n* **Application Orchestration**: Manages the main window, menus, toolbars, and the splitter layout containing the canvas and property panels.\n* **State Management**: Holds the active `BrainDesign` instance and coordinates \"Undo/Redo\" style refreshes across all sub-panels.\n* **Live Game Bridge**: If the game is running, it allows the user to \"Sync from Game\" (import the current brain) or \"Push to Game\" (export the design to the live squid).\n* **Network Generation**: Provides entry points for \"Chaos Mode\" or preset-based automated network generation using the `SparseNetworkGenerator`.\n\n#### Key Functions:\n\n* `setup_ui()` - Initializes the `BrainCanvas` and the vertical tabbed panels (Layers, Sensors, Properties, Connections, Outputs).\n* `push_to_game()` - Converts the visual design into a format the game understands and sends it via the `brain_state_bridge`.\n* `instant_random_generate()` - Triggers an instant \"Chaos\" shuffle of neuron positions and randomizes connections.\n* `load_from_brain_widget_state()` - Allows the editor to be opened mid-game by importing the current state of the squid's brain.\n\n#### Key internal objects:\n`ScrollingTicker`: A specialized UI widget that scrolls rich-text help messages and shortcuts.\n`BrainDesignerWindow`: The `QMainWindow` class that coordinates the canvas, side panels, and the bridge to the live game."
},
{
"path": "Docs/source-reference/main.py.md",
"content": "### The Simulation Loop (main.py)\nThe simulation loop is driven by a QTimer from the PyQt5 framework, which \"ticks\" at a consistent rate. Each tick represents one frame of the simulation.\n\nThe loop has two key responsibilities:\n\n**State Update**: On each tick, it calls the `update_game_state()` method. This function is responsible for everything that changes over time without direct user input. This includes:\n\n* Decrementing the squid's needs (hunger, cleanliness, etc.).\n\n* Calling the neural network to get the squid's next autonomous action.\n\n* Executing the squid's chosen action (e.g., moving, interacting with an object).\n\n* Updating animations.\n\n**Rendering**: After the state has been updated, the loop tells the GUI to repaint itself, ensuring that the user always sees the most current state of the simulation."
},
{
"path": "Docs/source-reference/memory_manager.py.md",
"content": "`MemoryManager` is designed to simulate a simple cognitive memory system with two main components:\n\n#### Data Persistence and Initialization\n* File Storage: Memory is persisted in two JSON files within a _memory directory: `ShortTerm.json` and `LongTerm.json`.\n\n* `__init__` Method: Initializes memory paths, loads existing memory using _load_and_convert_timestamps, and sets operational limits:\n\n* `self.short_term_limit` = 50: Maximum number of items in short-term memory (STM).\n\n* `self.short_term_duration` = 300 (5 minutes): The lifespan for a short-term memory item before it's considered for cleanup or transfer.\n\n* `_load_and_convert_timestamps`: A crucial helper method that handles loading memory from JSON. It's robust, attempting to convert string-based _ISO 8601_ timestamps (used for storage) into floating-point Unix timestamps (used for internal operations) to enable easy time-based comparisons.\n* `save_memory`: The counterpart to the loading function. It takes the in-memory list and converts the internal float timestamps back to _ISO 8601_ strings before saving to the JSON file with indentation (indent=4).\n\n-------------------------------\n\n#### Short-Term Memory (STM) Management\nSTM is dynamic, time-limited, and its items have calculated metrics to determine their longevity.\n\n`add_short_term_memory`: Adds a new memory item. If an item with the same category and key already exists, it reinforces the memory by increasing its importance by 0.5 and updating its timestamp.\n\nIt checks for immediate promotion: if importance reaches 3.0, it calls `transfer_to_long_term_memory`.\n\nIt enforces the `self.short_term_limit` by dropping the oldest memory (`pop(0)`) when the limit is exceeded (FIFO - First In, First Out).\n\n`get_short_term_memory`: Retrieves a memory by category and key. It verifies the memory is still within the `self.short_term_duration`. A successful access increases the memory's `access_count`.\n\n`cleanup_short_term_memory`: Removes expired memories (older than `self.short_term_duration`). If the list is still over the limit, it prunes based on a combined score of importance and access_count.\n\n`get_active_memories_data`: Retrieves and formats memories that are still valid, sorting them by a combination of importance and access_count in descending order.\n\n---------------------\n\n#### Long-Term Memory (LTM) Management\nLTM is for permanent or reinforced memories and is primarily concerned with deduplication.\n\n`add_long_term_memory`: Adds a memory. It checks for duplicates based on category and key. If a memory already exists, it is not duplicated; instead, its timestamp is updated to reflect the reinforcement.\n\n`get_all_long_term_memories`: Retrieves all LTM items, with an optional filter by category.\n\n---------------\n\n\n#### Transfer and Review Logic\nThis section defines the \"learning\" or \"consolidation\" process where temporary memories become permanent.\n\n* `review_and_transfer_memories`: The core decay and promotion loop. It iterates through expired STM items.\n\n* If an expired item meets the criteria in `should_transfer_to_long_term`, it's promoted using `transfer_to_long_term_memory`.\n\n* Otherwise, the expired memory is simply removed from the STM.\n\n* `periodic_memory_management`: A simple rate limiter that calls review_and_transfer_memories only if 30 seconds have passed since the last cleanup.\n\n* `should_transfer_to_long_term`: Defines the promotion criteria:\n\n1. importance >= 7 OR\n\n1. access_count >= 3 OR\n\n1. (importance >= 5 AND access_count >= 2)\n\n* `transfer_to_long_term_memory`: Moves a memory from STM to LTM (using `add_long_term_memory` to handle LTM deduplication) and then removes it from the STM.\n\n\n-------------------\n\n#### Utility and Formatting\n* `clear_short_term_memory` / `clear_all_memories`: Provides methods to reset one or both memory stores.\n\n* `update_memory_importance`: Allows external logic to manually adjust the importance of an STM item.\n\n* `format_memory`: A presentation method that takes a memory dictionary and returns an HTML-formatted string, color-coding the memory's interaction type (Positive/Negative/Neutral) based on its raw_value or category/key."
},
{
"path": "Docs/source-reference/neurogenesis_show.py.md",
"content": "`neurogenesis_show.py` is the **“showman” layer** that wraps the real `EnhancedNeurogenesis` engine and adds **player-facing spectacle** without touching any of the underlying biology, caps, or cooldown logic. The wrapper is enabled by default (via config.ini) and is meant to make neurogenesis more fun/game-like versus biologically accurate. \n\nDisable the wrapper and neurogenesis will behave in a **more scientifically accurate way** (better suited for actual biological/neuro experiments)\n\n#### 1. Guarantee the player *sees* a neuron\n\n- If the real engine **would** create a neuron, this wrapper **always lets it spawn** (respects the same caps/cooldowns). \n- If the real engine **would NOT** create one, the showman can still **force an extra “dramatic” neuron** when something cool happens—**but only if showmanship is enabled in config**.\n\n\n#### 2. Detect “cool moments”\n\n`NeurogenesisEvent` enum + `_detect_dramatic_moment()` \nMonitors every experience context for **visually obvious milestones**:\n\n| Event | Typical Threshold |\n|---|---|\n| `ANXIETY_SPIKE` | anxiety ≥ 70 |\n| `CURIOSITY_EXPLOSION` | curiosity ≥ 75 |\n| `HUNGER_SATISFIED` | reward trigger + eating action |\n| `MAX_HAPPINESS` | happiness ≥ 85 |\n| `SPOTLESS_TANK` | cleanliness ≥ 90 |\n| `FIRST_DECORATION_PUSH` | “decoration” or “push” in recent actions |\n\nThese are **intentionally permissive**—the goal is “player smiles,” not “perfect biology.”\n\n\n#### 3. Manual event triggers (achievement integration)\n\n`trigger_event(NeurogenesisEvent.FOO)` \nLets **external systems** (achievements, tutorials, Easter-egg code) **request** a showman neuron. \nReturns `True` if one was actually spawned (respects cooldown & config flag).\n\n\n#### 4. Cosmetic upgrades\n\n- **_rename_for_drama()** – replaces auto-generated names like `stress_anxiety_regulation_3` with cinematic ones: \n `trauma`, `wonder_trigger`, `satisfaction_burst`, `discovery_rush`, … \n- **_burst_color()** – gives the newborn neuron a **10-second gold/crimson/mint “super-pulse”** instead of the normal 5-second blink. \n- **_migrate_neuron()** – atomically renames **every dictionary key, animation tracker, visible set, weight tuple, etc.** so the new pretty name is safe everywhere.\n\n\n#### 5. Achievement callbacks\n\n`set_callbacks(on_dramatic_neuron=…, on_event_triggered=…)` \nFires when: \n- a showman neuron is actually spawned, or \n- any `NeurogenesisEvent` is recorded\n\n#### 6. Config-aware passthrough\n\n- Reads `[Neurogenesis] showmanship = True/False` **each time** (hot-switchable). \n- When disabled the class becomes a **transparent proxy**: every call falls straight through to the real engine with zero overhead. \n- Public API surface **mirrors** `EnhancedNeurogenesis` (`create_neuron`, `should_create_neuron`, `get_global_cooldown_remaining`, …) so the rest of the codebase never knows a wrapper exists.\n\n\n#### 7. Bookkeeping\n\n- `last_showman_creation` – 15-second **cosmetic cooldown** (independent of the real engine’s 60-second biological cooldown). \n- `_triggered_events` set – prevents **exact duplicate** “first” events within the same session. \n- `reset_events()` – clears history for **new game** or **load save**.\n\n\n### TL;DR\n`neurogenesis_show.py` is the **marketing department** of the neuron factory: it **sprinkles confetti** (dramatic names, longer pulses, extra neurons on cool moments) while **never overruling** the real biologist downstairs—unless the player explicitly turns off the show, in which case it **vanishes silently**."
},
{
"path": "Docs/source-reference/squid.py.md",
"content": "`squid.py` file defines the Squid class, integrating various functionalities to simulate a living creature. It handles its own visual rendering and animation, calculates its movement, makes decisions based on its internal states and personality, and interacts with objects like food and decorations.\n\n#### Core Responsibilities:\n\n* **Physical Simulation**: Handles movement, animation frames, collision with boundaries, and \"Inking\" behaviors.\n* **Internal State**: Tracks \"Needs\" (Hunger, Happiness, etc.) and \"Goal Neurons\" (Satisfaction, Anxiety, Curiosity).\n* **Interaction Engine**: Manages picking up/throwing rocks, eating food, and reacting to other squids in a multiplayer environment.\n* **Perception**: Acts as the primary interface for the VisionWorker, translating raw geometric vision data into behavioral triggers.\n\n#### Key Functions:\n\n* `update_view_direction()` - Makes the squid \"scan\" the tank; includes a \"Hunger Bias\" that forces it to look toward food.\n* `eat()` - Processes food consumption, applies stat changes, and starts the \"Poop Timer\".\n* `check_boundary_exit()` - Detects if the squid has swum off-screen to transition to a neighbour's tank in multiplayer mode.\n* `startle_awake()` - Handles the logic for a rude awakening, including anxiety spikes and potential ink cloud creation.\n\n#### Key internal objects:\n* `self.mental_state_manager` – boolean flags + cooldowns\n* `self.memory_manager` – short-term & long-term memory lists\n* `self._decision_engine` – Q-learning / weight-based action picker\n* `self.statistics` – personal lifetime counters (age, food eaten, rocks thrown…)"
},
{
"path": "Docs/source-reference/tamagotchi_logic.py.md",
"content": "View source: [tamagotchi_logic.py](https://github.com/ViciousSquid/Dosidicus/blob/2.6.1.2_LatestVersion/src/tamagotchi_logic.py) version 2.6.1.2\n\nA **god-object** serving as the central game logic controller. Its primary purpose is to manage the core simulation loop, handle the squid's behaviour and needs, facilitate interactions with the environment, and integrate various game systems, including the neural network, memory, and save/load functionalities.\n\n\n#### Responsibilities\n* Owns the live pet simulation loop (`hunger`, `happiness`, `sickness`, `sleep`, etc.).\n* Spawns and manages world objects: food, poop, decorations, rocks.\n* Runs every-frame update (movement, collisions, timers, cooldowns).\n* Handles user actions: feed, clean, medicine, speed changes, window resize.\n* Coordinates save / load of the entire game state (squid, memories, decorations, brain).\n* Hosts the [plugin](../engine/Plugin-System.md) system (achievements, multiplayer, etc.) and fires hooks.\n* Owns statistics & scoring (distance swam, food eaten, startles, ink clouds…).\n* Bridges pet ← → brain:\n1. – copies squid stats into the neural network so the network mirrors the pet.\n2. – reads learned weights back from the network to influence future decisions.\n\n\n#### Key internal objects\n* `self.squid` – the pet instance ([squid.py](../source-reference/squid.py.md))\n* `self.brain_window` – the debug UI ([brain_tool.py](../source-reference/brain_tool.py.md))\n* `self.food_items` / `poop_items` / `rock_items` – lists of QGraphicsItems\n* `self.neurogenesis_triggers` – counters that tell the brain when to grow new neurons\n* `self.plugin_manager` – loads & runs plugins (multiplayer, achievements, …)\n\n\n----------------------------------\n\n* `TamagotchiLogic.__init__()` constructs the Squid and keeps a reference.\n* Squid receives a back-reference (`self.tamagotchi_logic`) so it can:\n1. – ask for nearby decorations / food\n2. – tell the logic when it threw a rock (for RL reward)\n3. – trigger plugin hooks\n\n#### Data flow every frame:\n* `TamagotchiLogic.update_simulation`()\n* → calls `squid.move_squid`()\n* → copies `squid.hunger` / `happiness` / `anxiety` … into a dict\n* → sends dict to `brain_window.update_brain`() (neural network)\n* Neural network learns, may create new neurons, returns updated weights.\n* `TamagotchiLogic` reads those weights and/or calls `squid.make_decision`() which uses them.\n* Save / load\n* `TamagotchiLogic.save_game`() asks `squid.save_state`() for the pet slice, then bundles it with brain data, memories, decorations, achievements.\nOn load the reverse happens; afterwards `sync_state_from_squid`() is called so the squid remains the single source of truth for core stats.\n\n#### Plugin hooks:\nAny time a Squid property changes (via its setters) it fires tamagotchi_logic.plugin_manager.trigger_hook(\"on_hunger_change\", …)\nso plugins (achievements, multiplayer, etc.) can react."
},
{
"path": "Docs/source-reference/vision_worker.py.md",
"content": "#### vision_worker.py\nThis is the computational engine of the squid's perception. It runs as a background thread (QThread) to ensure that geometric calculations do not \"freeze\" the main game animations.\n\n#### Core Responsibilities:\n* **Asynchronous Calculation**: Performs vision cone and proximity checks at a fixed frequency (20Hz) **independently of the main game loop**.\n* **Vision Cone Logic**: Determines if objects (food, rocks, plants) are within the squid's 80-degree field of view by calculating the angular difference between the squid's gaze and the object's position.\n* **Proximity Sensing**: Calculates \"tactile\" proximity to plants. Unlike the vision cone, this uses bounding-box edge distances to detect if the squid is touching or near a plant (0–100 range).\n* **Change Detection**: It monitors the environment and only \"alerts\" the squid via signals when something meaningful changes (e.g., food just appeared in view).\n\n#### Key Functions:\n\n* `_calculate_visibility()` - The math core; checks every scene object against the vision cone and calculates distances.\n* `update_squid_state()` - Receives the squid's current X/Y and gaze angle from the main thread.\n* `update_scene_objects()` - Receives a lightweight list of all items currently in the tank.\n* `_check_and_emit_changes()` - Fires signals like `food_visibility_changed` or `plant_proximity_changed` only when state shifts.\n\n#### Key internal objects\n\n* `SquidVisionState`: A data class containing a snapshot of the squid's position, size, and gaze angle.\n* `SceneObject`: A lightweight representation of a world object (food, plant, rock) used for visibility checks.\n* `VisionResult`: A container for the output of a vision cycle, listing visible items and proximity values.\n* `VisionWorker`: The QThread subclass that constantly calculates what is inside the vision cone.\n\n\n----------------------\n\n#### \"Producer-Consumer\" model:\n\n1. **Input**: [`Squid.py`](../source-reference/squid.py.md) periodically sends its position to the `VisionWorker`.\n2. **Processing**: `VisionWorker` (in the background) identifies what is visible and sends a `VisionResult` back to the Squid.\n3. **Behaviour**: The Squid uses that result to decide if it should chase food or feel calm near a plant.\n4. **Display**: If the VisionWindow is open, it reads those same results to display the \"Visible Objects\" list to the user.\n\n* **Note:** The VisionWorker includes a \"Circuit Breaker\" logic to prevent the squid from chasing \"ghost food\" that was just eaten but hasn't been cleared from the background thread's cache yet."
},
{
"path": "LICENSE",
"content": " GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundation, Inc.,\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicense is intended to guarantee your freedom to share and change free\nsoftware--to make sure the software is free for all its users. This\nGeneral Public License applies to most of the Free Software\nFoundation's software and to any other program whose authors commit to\nusing it. (Some other Free Software Foundation software is covered by\nthe GNU Lesser General Public License instead.) You can apply it to\nyour programs, too.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthis service if you wish), that you receive source code or can get it\nif you want it, that you can change the software or use pieces of it\nin new free programs; and that you know you can do these things.\n\n To protect your rights, we need to make restrictions that forbid\nanyone to deny you these rights or to ask you to surrender the rights.\nThese restrictions translate to certain responsibilities for you if you\ndistribute copies of the software, or if you modify it.\n\n For example, if you distribute copies of such a program, whether\ngratis or for a fee, you must give the recipients all the rights that\nyou have. You must make sure that they, too, receive or can get the\nsource code. And you must show them these terms so they know their\nrights.\n\n We protect your rights with two steps: (1) copyright the software, and\n(2) offer you this license which gives you legal permission to copy,\ndistribute and/or modify the software.\n\n Also, for each author's protection and ours, we want to make certain\nthat everyone understands that there is no warranty for this free\nsoftware. If the software is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original, so\nthat any problems introduced by others will not reflect on the original\nauthors' reputations.\n\n Finally, any free program is threatened constantly by software\npatents. We wish to avoid the danger that redistributors of a free\nprogram will individually obtain patent licenses, in effect making the\nprogram proprietary. To prevent this, we have made it clear that any\npatent must be licensed for everyone's free use or not licensed at all.\n\n The precise terms and conditions for copying, distribution and\nmodification follow.\n\n GNU GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License applies to any program or other work which contains\na notice placed by the copyright holder saying it may be distributed\nunder the terms of this General Public License. The \"Program\", below,\nrefers to any such program or work, and a \"work based on the Program\"\nmeans either the Program or any derivative work under copyright law:\nthat is to say, a work containing the Program or a portion of it,\neither verbatim or with modifications and/or translated into another\nlanguage. (Hereinafter, translation is included without limitation in\nthe term \"modification\".) Each licensee is addressed as \"you\".\n\nActivities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning the Program is not restricted, and the output from the Program\nis covered only if its contents constitute a work based on the\nProgram (independent of having been made by running the Program).\nWhether that is true depends on what the Program does.\n\n 1. You may copy and distribute verbatim copies of the Program's\nsource code as you receive it, in any medium, provided that you\nconspicuously and appropriately publish on each copy an appropriate\ncopyright notice and disclaimer of warranty; keep intact all the\nnotices that refer to this License and to the absence of any warranty;\nand give any other recipients of the Program a copy of this License\nalong with the Program.\n\nYou may charge a fee for the physical act of transferring a copy, and\nyou may at your option offer warranty protection in exchange for a fee.\n\n 2. You may modify your copy or copies of the Program or any portion\nof it, thus forming a work based on the Program, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any\n part thereof, to be licensed as a whole at no charge to all third\n parties under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a\n notice that there is no warranty (or else, saying that you provide\n a warranty) and that users may redistribute the program under\n these conditions, and telling the user how to view a copy of this\n License. (Exception: if the Program itself is interactive but\n does not normally print such an announcement, your work based on\n the Program is not required to print an announcement.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Program,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Program, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote it.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Program.\n\nIn addition, mere aggregation of another work not based on the Program\nwith the Program (or with a work based on the Program) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may copy and distribute the Program (or a work based on it,\nunder Section 2) in object code or executable form under the terms of\nSections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections\n 1 and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your\n cost of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer\n to distribute corresponding source code. (This alternative is\n allowed only for noncommercial distribution and only if you\n received the program in object code or executable form with such\n an offer, in accord with Subsection b above.)\n\nThe source code for a work means the preferred form of the work for\nmaking modifications to it. For an executable work, complete source\ncode means all the source code for all modules it contains, plus any\nassociated interface definition files, plus the scripts used to\ncontrol compilation and installation of the executable. However, as a\nspecial exception, the source code distributed need not include\nanything that is normally distributed (in either source or binary\nform) with the major components (compiler, kernel, and so on) of the\noperating system on which the executable runs, unless that component\nitself accompanies the executable.\n\nIf distribution of executable or object code is made by offering\naccess to copy from a designated place, then offering equivalent\naccess to copy the source code from the same place counts as\ndistribution of the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 4. You may not copy, modify, sublicense, or distribute the Program\nexcept as expressly provided under this License. Any attempt\notherwise to copy, modify, sublicense or distribute the Program is\nvoid, and will automatically terminate your rights under this License.\nHowever, parties who have received copies, or rights, from you under\nthis License will not have their licenses terminated so long as such\nparties remain in full compliance.\n\n 5. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Program or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Program (or any work based on the\nProgram), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Program or works based on it.\n\n 6. Each time you redistribute the Program (or any work based on the\nProgram), the recipient automatically receives a license from the\noriginal licensor to copy, distribute or modify the Program subject to\nthese terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties to\nthis License.\n\n 7. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Program at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Program by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Program.\n\nIf any portion of this section is held invalid or unenforceable under\nany particular circumstance, the balance of the section is intended to\napply and the section as a whole is intended to apply in other\ncircumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system, which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 8. If the distribution and/or use of the Program is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Program under this License\nmay add an explicit geographical distribution limitation excluding\nthose countries, so that distribution is permitted only in or among\ncountries not thus excluded. In such case, this License incorporates\nthe limitation as if written in the body of this License.\n\n 9. The Free Software Foundation may publish revised and/or new versions\nof the General Public License from time to time. Such new versions will\nbe similar in spirit to the present version, but may differ in detail to\naddress new problems or concerns.\n\nEach version is given a distinguishing version number. If the Program\nspecifies a version number of this License which applies to it and \"any\nlater version\", you have the option of following the terms and conditions\neither of that version or of any later version published by the Free\nSoftware Foundation. If the Program does not specify a version number of\nthis License, you may choose any version ever published by the Free Software\nFoundation.\n\n 10. If you wish to incorporate parts of the Program into other free\nprograms whose distribution conditions are different, write to the author\nto ask for permission. For software which is copyrighted by the Free\nSoftware Foundation, write to the Free Software Foundation; we sometimes\nmake exceptions for this. Our decision will be guided by the two goals\nof preserving the free status of all derivatives of our free software and\nof promoting the sharing and reuse of software generally.\n\n NO WARRANTY\n\n 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\nFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\nOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\nPROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\nOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\nTO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\nPROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\nREPAIR OR CORRECTION.\n\n 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\nREDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\nINCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\nOUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\nTO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\nYOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\nPROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\nPOSSIBILITY OF SUCH DAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Programs\n\n If you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\n To do so, attach the following notices to the program. It is safest\nto attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least\nthe \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License along\n with this program; if not, write to the Free Software Foundation, Inc.,\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this\nwhen it starts in an interactive mode:\n\n Gnomovision version 69, Copyright (C) year name of author\n Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n This is free software, and you are welcome to redistribute it\n under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate\nparts of the General Public License. Of course, the commands you use may\nbe called something other than `show w' and `show c'; they could even be\nmouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the program, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n `Gnomovision' (which makes passes at compilers) written by James Hacker.\n\n , 1 April 1989\n Ty Coon, President of Vice\n\nThis General Public License does not permit incorporating your program into\nproprietary programs. If your program is a subroutine library, you may\nconsider it more useful to permit linking proprietary applications with the\nlibrary. If this is what you want to do, use the GNU Lesser General\nPublic License instead of this License.\n"
},
{
"path": "README.md",
"content": "\n_\"What if a Tamagotchi had a neural network and could learn stuff?\"_ - [Gigazine](https://gigazine.net/gsc_news/en/20250505-dosidicus-electronicae/) , [Hackaday](https://hackaday.com/2025/04/26/digital-squids-behavior-shaped-by-neural-network/)\n\n
\n );\n}\n"
},
{
"path": "headless/README.md",
"content": "## Headless Brain Trainer\nA standalone training system for Dosidicus neural network brains that runs without GUI overhead, enabling fast accelerated training of custom brain architectures.\n\n\n## Features\n\n- **Headless Operation**: No GUI required, runs purely on CPU\n- **Accelerated Time**: Runs 25,000-35,000+ ticks per second (vs ~1 tick/second in real-time)\n- **Custom Brain Loading**: Load brain architectures from JSON files\n- **Neurogenesis**: Automatic creation of new neurons based on stress/novelty/reward triggers\n- **Hebbian Learning**: Continuous weight updates based on co-activation\n- **Training Scenarios**: Predefined scenarios for different training goals\n- **Export Trained Brains**: Save trained brains back to JSON for use in the main game\n\n## Installation\n\n**No additional dependencies required** beyond Python 3.6+. The trainer is self-contained.\n\n```bash\n# Make executable (optional)\nchmod +x headless_trainer.py\n```\n\n## Quick Start\n\n```bash\n# Train with default brain for 10,000 ticks\npython headless_trainer.py --ticks 10000 --output my_trained_brain.json\n\n# Train a custom brain\npython headless_trainer.py --brain my_custom_brain.json --ticks 20000 --output trained.json\n\n# Use a predefined scenario\npython headless_trainer.py --brain my_brain.json --scenario stress_test --output stress_trained.json\n\n# List available scenarios\npython headless_trainer.py --list-scenarios\n```\n\n## Command Line Options\n\n| Option | Short | Description |\n|--------|-------|-------------|\n| `--brain FILE` | `-b` | Path to brain JSON file to load |\n| `--output FILE` | `-o` | Path to save trained brain (auto-generated if not specified) |\n| `--ticks N` | `-t` | Number of simulation ticks (default: 10000) |\n| `--scenario NAME` | `-s` | Use a predefined training scenario |\n| `--list-scenarios` | | List available training scenarios |\n| `--progress N` | `-p` | Progress report interval (default: 500, 0=quiet) |\n| `--quiet` | `-q` | Minimal output |\n| `--learning-rate F` | | Override Hebbian learning rate |\n| `--neurogenesis BOOL` | | Enable/disable neurogenesis |\n| `--max-neurons N` | | Maximum neurons allowed |\n\n## Training Scenarios\n\n### `balanced`\nStandard balanced training with normal event rates. Good for general-purpose brain development.\n\n### `stress_test`\nHigh anxiety/stress conditions to develop resilience neurons. Includes:\n- Reduced food availability\n- Increased startle events\n- Scripted high-anxiety events\n\n### `reward_rich`\nFrequent positive outcomes to develop reward pathways. Includes:\n- High food spawn rate\n- Reduced negative events\n- Scripted feeding events\n\n### `novelty_exploration`\nHigh curiosity environment with new objects. Good for developing exploration behaviors.\n\n### `endurance`\nLong-duration (50,000 ticks) training with varied conditions.\n\n## Brain JSON Format\n\nBrains are stored as JSON files with the following structure:\n\n```json\n{\n \"metadata\": {\n \"name\": \"My Brain\",\n \"description\": \"Description of the brain\"\n },\n \"positions\": {\n \"hunger\": {\"x\": 127, \"y\": 81, \"is_custom\": false},\n \"custom_neuron\": {\"x\": 450, \"y\": 250, \"is_custom\": true}\n },\n \"weights\": {\n \"hunger,satisfaction\": -0.3,\n \"happiness,satisfaction\": 0.4\n },\n \"neuron_shapes\": {\n \"custom_neuron\": \"pentagon\"\n },\n \"output_bindings\": []\n}\n```\n\n### Core Neurons (cannot be removed)\n- `hunger`, `happiness`, `cleanliness`, `sleepiness`\n- `satisfaction`, `anxiety`, `curiosity`\n\n### Input Sensors\n- `can_see_food`, `plant_proximity`, `external_stimulus`\n- `is_eating`, `is_sleeping`, `is_sick`, `is_fleeing`, `is_startled`, `pursuing_food`\n\n### Custom Neurons\nAny neuron not in the core/sensor lists is treated as a custom neuron and will participate in Hebbian learning with boosted rates.\n\n## Example Workflow\n\n### 1. Create a custom brain in the Brain Designer\nUse the [Brain Designer](https://github.com/ViciousSquid/Dosidicus/wiki/Brain-Designer) to create your architecture, then export it as JSON.\n\n### 2. Train the brain headlessly\n```bash\n# Quick training\npython headless_trainer.py -b my_design.json -t 50000 -o trained_v1.json\n\n# Or with a scenario\npython headless_trainer.py -b my_design.json -s stress_test -o stress_trained.json\n```\n\n### 3. Load the trained brain back into Dosidicus\nUse the \"Load Brain\" button in the [Network tab](https://github.com/ViciousSquid/Dosidicus/wiki/Network-Tab) to load your trained brain.\n\n## Training Tips\n\n1. **Start with balanced training** to establish baseline connections\n2. **Use stress_test** if you want resilience neurons for anxiety handling\n3. **Use reward_rich** if you want strong satisfaction/happiness pathways\n4. **Long training (50k+ ticks)** allows more sophisticated weight patterns to develop\n5. **Multiple training rounds** with different scenarios can create well-rounded brains\n\n## Performance\n\nOn modern hardware, expect:\n- ~25,000-35,000 ticks/second\n- A 50,000 tick training session completes in ~2 seconds\n- A 1,000,000 tick session completes in ~30 seconds\n\n\n## Integration with Dosidicus-2\n\nThe trained brain JSON files are fully compatible with:\n- Brain Designer (import/export)\n- Main game's \"Load Brain\" feature\n- Save game custom brain storage\n\n## License\n\nPart of Dosidicus-2 project. [GPL-2.0 license](https://github.com/ViciousSquid/Dosidicus/blob/v2.6.1.0__b1218_LatestVersion/LICENSE)\n"
},
{
"path": "headless/headless_launcher.html",
"content": "\n\n\n \n \n Dosidicus-2 Headless Trainer Launcher\n \n\n\n
\n \n
🦑 Dosidicus-2 Headless Trainer
\n
Configure and launch accelerated brain training sessions
\n \n\n \n
\n
Brain Configuration
\n
\n
\n \n
\n \n \n \n
\n Leave empty to use default brain architecture\n
\n
\n \n \n Auto-generated if not specified\n
\n
\n \n \n
\n
\n 🧠 Brain Name\n \n
\n
\n
\n 0\n Neurons\n
\n
\n 0\n Connections\n
\n
\n 0\n Custom\n
\n
\n \n
\n \n \n
\n
\n 📂 Drop brain.json here or click to browse\n
\n
\n
\n\n \n
\n
Training Parameters
\n
\n
\n \n \n Number of simulation steps (≈30k ticks/sec)\n
\n
\n \n \n Report frequency (0 = quiet mode)\n
\n
\n\n
\n
\n
0.3s
\n
Estimated Time
\n
\n
\n
~5-20
\n
New Neurons
\n
\n
\n
~334
\n
Hebbian Updates
\n
\n
\n
\n\n \n
\n
Training Scenario
\n
\n Select a predefined scenario or use custom settings\n
\n
\n
\n
⚙️ Custom
\n
Use manual settings without predefined events
\n
\n
\n
⚖️ Balanced
\n
Standard training with normal event rates
\n
10,000 ticks
\n
\n
\n
😰 Stress Test
\n
High anxiety to develop resilience neurons
\n
5,000 ticks
\n
\n
\n
🎁 Reward Rich
\n
Frequent positive outcomes for reward pathways
\n
8,000 ticks
\n
\n
\n
🔍 Novelty
\n
High curiosity with new object encounters
\n
6,000 ticks
\n
\n
\n
🏃 Endurance
\n
Long-duration training session
\n
50,000 ticks
\n
\n
\n
\n\n \n
\n
Advanced Options
\n
\n
\n \n \n Hebbian learning rate (default: 0.1)\n
\n
\n \n \n Maximum neurons allowed (default: 100)\n
\n
\n
\n \n \n
\n
\n \n \n
\n
\n\n \n
\n
Generated Command
\n
\n python headless_trainer.py --ticks10000\n
\n
\n \n \n \n \n
\n \n
\n\n \n
\n
Quick Reference
\n
\n
Performance: ~25,000-35,000 ticks/second on modern hardware
\n
Neurogenesis: Creates stress/novelty/reward neurons based on squid state
\n
Hebbian Learning: Updates connection weights every 30 ticks
\n
Output: Compatible with Brain Designer and main game \"Load Brain\" feature
\n
\n
\n\n \n
\n\n \n\n\n"
},
{
"path": "headless/headless_trainer.py",
"content": "#!/usr/bin/env python3\n\"\"\"\nDosidicus-2 Headless Brain Trainer\n\nAllows training custom neural network brains without GUI overhead.\nSupports accelerated time, custom brain loading, and state persistence.\n\nUsage:\n python headless_trainer.py --brain custom_brain.json --ticks 10000 --output trained_brain.json\n python headless_trainer.py --brain custom_brain.json --duration 3600 --speed 100\n python headless_trainer.py --list-scenarios\n python headless_trainer.py --brain my_brain.json --scenario stress_test\n\nAuthor: Headless training system for Dosidicus-2\n\"\"\"\n\nimport argparse\nimport json\nimport math\nimport os\nimport random\nimport sys\nimport time\nfrom collections import deque\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom pathlib import Path\nfrom typing import Dict, List, Optional, Set, Tuple, Any\nfrom heapq import nlargest\n\n\n# ============================================================================\n# CONSTANTS (from brain_worker.py and brain_constants.py)\n# ============================================================================\n\nPURE_INPUTS = {\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\",\n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\",\n \"plant_proximity\"\n}\n\nCORE_NEURONS = {\n \"hunger\", \"happiness\", \"cleanliness\", \"sleepiness\",\n \"satisfaction\", \"anxiety\", \"curiosity\"\n}\n\nINPUT_SENSORS = {\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\",\n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\",\n \"plant_proximity\"\n}\n\n\nclass Personality(Enum):\n \"\"\"Squid personality types\"\"\"\n TIMID = \"timid\"\n ADVENTUROUS = \"adventurous\"\n GREEDY = \"greedy\"\n STUBBORN = \"stubborn\"\n ENERGETIC = \"energetic\"\n\n\n# ============================================================================\n# CONFIGURATION\n# ============================================================================\n\n@dataclass\nclass TrainingConfig:\n \"\"\"Configuration for headless training\"\"\"\n # Learning parameters\n learning_rate: float = 0.1\n weight_decay: float = 0.01\n max_hebbian_pairs: int = 2\n hebbian_interval: int = 30 # ticks between hebbian updates\n \n # Neurogenesis parameters\n neurogenesis_enabled: bool = True\n neurogenesis_cooldown: int = 60 # ticks\n max_neurons: int = 100\n novelty_threshold: float = 3.0\n stress_threshold: float = 1.2\n reward_threshold: float = 3.5\n \n # Simulation parameters\n decay_rate: float = 0.95\n noise_range: float = 0.5\n \n # Scenarios\n food_spawn_chance: float = 0.02\n poop_spawn_chance: float = 0.01\n startle_chance: float = 0.005\n \n @classmethod\n def from_dict(cls, data: Dict) -> 'TrainingConfig':\n return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})\n\n\n@dataclass\nclass TrainingScenario:\n \"\"\"Predefined training scenarios\"\"\"\n name: str\n description: str\n duration_ticks: int\n config_overrides: Dict = field(default_factory=dict)\n events: List[Dict] = field(default_factory=list)\n\n\nTRAINING_SCENARIOS = {\n \"balanced\": TrainingScenario(\n name=\"Balanced Training\",\n description=\"Standard balanced training with normal event rates\",\n duration_ticks=10000,\n config_overrides={},\n events=[]\n ),\n \"stress_test\": TrainingScenario(\n name=\"Stress Test\",\n description=\"High anxiety/stress conditions to develop resilience neurons\",\n duration_ticks=5000,\n config_overrides={\n \"startle_chance\": 0.02,\n \"food_spawn_chance\": 0.005,\n },\n events=[\n {\"tick\": 100, \"type\": \"set_state\", \"state\": {\"anxiety\": 80}},\n {\"tick\": 500, \"type\": \"startle\"},\n {\"tick\": 1000, \"type\": \"set_state\", \"state\": {\"hunger\": 90}},\n ]\n ),\n \"reward_rich\": TrainingScenario(\n name=\"Reward-Rich Environment\",\n description=\"Frequent positive outcomes to develop reward pathways\",\n duration_ticks=8000,\n config_overrides={\n \"food_spawn_chance\": 0.08,\n \"poop_spawn_chance\": 0.001,\n },\n events=[\n {\"tick\": 200, \"type\": \"feed\"},\n {\"tick\": 600, \"type\": \"feed\"},\n {\"tick\": 1200, \"type\": \"feed\"},\n ]\n ),\n \"novelty_exploration\": TrainingScenario(\n name=\"Novelty Exploration\",\n description=\"High curiosity environment with new objects\",\n duration_ticks=6000,\n config_overrides={\n \"startle_chance\": 0.001,\n },\n events=[\n {\"tick\": 100, \"type\": \"set_state\", \"state\": {\"curiosity\": 85}},\n {\"tick\": 300, \"type\": \"new_object\"},\n {\"tick\": 800, \"type\": \"new_object\"},\n {\"tick\": 1500, \"type\": \"new_object\"},\n ]\n ),\n \"endurance\": TrainingScenario(\n name=\"Endurance Training\",\n description=\"Long-duration training with varied conditions\",\n duration_ticks=50000,\n config_overrides={},\n events=[]\n ),\n}\n\n\n# ============================================================================\n# HEADLESS SQUID (minimal state tracking)\n# ============================================================================\n\nclass HeadlessSquid:\n \"\"\"Minimal squid implementation for headless training\"\"\"\n \n def __init__(self, personality: Personality = None):\n self.personality = personality or random.choice(list(Personality))\n \n # Core stats (0-100)\n self.hunger = 50.0\n self.happiness = 50.0\n self.cleanliness = 80.0\n self.sleepiness = 20.0\n self.health = 100.0\n \n # Goal neurons\n self.satisfaction = 50.0\n self.anxiety = 10.0\n self.curiosity = 55.0\n \n # Boolean states\n self.is_sick = False\n self.is_sleeping = False\n self.is_eating = False\n self.is_fleeing = False\n self.is_startled = False\n self.pursuing_food = False\n \n # Position (normalized 0-1)\n self.x = 0.5\n self.y = 0.5\n self.direction = \"right\"\n \n # Status\n self.status = \"roaming\"\n \n # Tracking\n self.food_visible = False\n self.plant_nearby = False\n self.time_since_ate = 0\n self.time_since_slept = 0\n \n def get_state_dict(self) -> Dict[str, Any]:\n \"\"\"Get current state as dictionary for brain updates\"\"\"\n return {\n \"hunger\": self.hunger,\n \"happiness\": self.happiness,\n \"cleanliness\": self.cleanliness,\n \"sleepiness\": self.sleepiness,\n \"satisfaction\": self.satisfaction,\n \"anxiety\": self.anxiety,\n \"curiosity\": self.curiosity,\n \"is_sick\": self.is_sick,\n \"is_sleeping\": self.is_sleeping,\n \"is_eating\": self.is_eating,\n \"pursuing_food\": self.pursuing_food,\n \"is_fleeing\": self.is_fleeing,\n \"is_startled\": self.is_startled,\n \"can_see_food\": 100.0 if self.food_visible else 0.0,\n \"plant_proximity\": 100.0 if self.plant_nearby else 0.0,\n \"external_stimulus\": 0.0,\n \"direction\": self.direction,\n \"position\": (self.x, self.y),\n \"personality\": self.personality.value,\n \"status\": self.status,\n }\n \n def update(self, dt: float = 1.0):\n \"\"\"Update squid state for one tick\"\"\"\n # Natural stat changes\n self.hunger = min(100, self.hunger + 0.1 * dt)\n self.sleepiness = min(100, self.sleepiness + 0.05 * dt)\n self.cleanliness = max(0, self.cleanliness - 0.02 * dt)\n \n # Update time trackers\n self.time_since_ate += dt\n if not self.is_sleeping:\n self.time_since_slept += dt\n \n # Personality effects\n if self.personality == Personality.GREEDY:\n self.hunger = min(100, self.hunger + 0.05 * dt)\n elif self.personality == Personality.ENERGETIC:\n self.sleepiness = max(0, self.sleepiness - 0.02 * dt)\n elif self.personality == Personality.TIMID:\n if self.plant_nearby:\n self.anxiety = max(0, self.anxiety - 0.1 * dt)\n \n # Anxiety from needs\n if self.hunger > 70:\n self.anxiety = min(100, self.anxiety + 0.1 * dt)\n if self.cleanliness < 30:\n self.anxiety = min(100, self.anxiety + 0.05 * dt)\n \n # Satisfaction from good states\n if self.hunger < 30 and self.cleanliness > 70:\n self.satisfaction = min(100, self.satisfaction + 0.1 * dt)\n else:\n self.satisfaction = max(0, self.satisfaction - 0.02 * dt)\n \n # Happiness dynamics\n if self.anxiety > 50:\n self.happiness = max(0, self.happiness - 0.1 * dt)\n elif self.satisfaction > 60:\n self.happiness = min(100, self.happiness + 0.05 * dt)\n \n # Curiosity wanders\n self.curiosity += random.uniform(-0.5, 0.5) * dt\n self.curiosity = max(0, min(100, self.curiosity))\n \n # Clear temporary states\n if self.is_startled:\n if random.random() < 0.1:\n self.is_startled = False\n self.is_fleeing = False\n \n if self.is_eating:\n if random.random() < 0.2:\n self.is_eating = False\n self.pursuing_food = False\n \n # Sleep behavior\n if self.sleepiness > 90 and not self.is_sleeping:\n self.is_sleeping = True\n self.status = \"sleeping\"\n elif self.is_sleeping and self.sleepiness < 20:\n self.is_sleeping = False\n self.time_since_slept = 0\n self.status = \"roaming\"\n \n # Movement simulation\n if not self.is_sleeping and not self.is_eating:\n self.x += random.uniform(-0.02, 0.02)\n self.y += random.uniform(-0.02, 0.02)\n self.x = max(0, min(1, self.x))\n self.y = max(0, min(1, self.y))\n \n def feed(self):\n \"\"\"Feed the squid\"\"\"\n self.hunger = max(0, self.hunger - 30)\n self.happiness = min(100, self.happiness + 10)\n self.satisfaction = min(100, self.satisfaction + 15)\n self.is_eating = True\n self.time_since_ate = 0\n self.status = \"eating\"\n \n def startle(self):\n \"\"\"Startle the squid\"\"\"\n self.is_startled = True\n self.is_fleeing = True\n self.anxiety = min(100, self.anxiety + 20)\n self.happiness = max(0, self.happiness - 10)\n self.status = \"fleeing!\"\n \n def clean(self):\n \"\"\"Clean the environment\"\"\"\n self.cleanliness = min(100, self.cleanliness + 40)\n self.anxiety = max(0, self.anxiety - 5)\n\n\n# ============================================================================\n# HEADLESS BRAIN\n# ============================================================================\n\nclass HeadlessBrain:\n \"\"\"\n Neural network brain without GUI dependencies.\n Handles state updates, Hebbian learning, and neurogenesis.\n \"\"\"\n \n def __init__(self, config: TrainingConfig = None):\n self.config = config or TrainingConfig()\n \n # Neural state\n self.state: Dict[str, float] = {}\n self.weights: Dict[Tuple[str, str], float] = {}\n self.positions: Dict[str, Tuple[float, float]] = {}\n self.neuron_shapes: Dict[str, str] = {}\n \n # Custom neurons tracking\n self.custom_neurons: Set[str] = set()\n self.new_neurons: Set[str] = set()\n self.connector_neurons: Set[str] = set()\n \n # Learning tracking\n self.last_hebbian_pairs: List[Tuple[str, str]] = []\n self.weight_history: List[Dict] = []\n \n # Neurogenesis tracking\n self.neurogenesis_data = {\n 'new_neurons': [],\n 'last_neuron_time': 0,\n 'neurons_created': 0,\n 'functional_neurons': {},\n }\n self.last_neurogenesis_tick = 0\n self.stress_neuron_count = 0\n self.novelty_neuron_count = 0\n self.reward_neuron_count = 0\n \n # Output bindings (for behaviors)\n self.output_bindings: List[Dict] = []\n \n # Initialize default state\n self._initialize_default_state()\n \n def _initialize_default_state(self):\n \"\"\"Initialize with default neuron structure\"\"\"\n default_positions = {\n \"can_see_food\": (50, 200),\n \"hunger\": (127, 81),\n \"happiness\": (361, 81),\n \"cleanliness\": (627, 81),\n \"sleepiness\": (840, 81),\n \"satisfaction\": (271, 380),\n \"anxiety\": (491, 389),\n \"curiosity\": (701, 386),\n }\n \n for name, pos in default_positions.items():\n self.positions[name] = pos\n if name in CORE_NEURONS:\n self.state[name] = 50.0\n elif name in INPUT_SENSORS:\n self.state[name] = 0.0\n else:\n self.state[name] = 50.0\n \n # Default connections\n default_connections = [\n (\"hunger\", \"satisfaction\", -0.3),\n (\"happiness\", \"satisfaction\", 0.4),\n (\"anxiety\", \"satisfaction\", -0.35),\n (\"cleanliness\", \"happiness\", 0.2),\n (\"sleepiness\", \"happiness\", -0.15),\n (\"curiosity\", \"happiness\", 0.25),\n ]\n \n for src, dst, weight in default_connections:\n self.weights[(src, dst)] = weight\n \n def load_brain(self, brain_data: Dict) -> bool:\n \"\"\"Load a brain from dictionary (JSON structure)\"\"\"\n try:\n # Clear existing\n self.state.clear()\n self.weights.clear()\n self.positions.clear()\n self.custom_neurons.clear()\n \n # Load positions/neurons — accept both 'positions' (headless export)\n # and 'neurons' (Designer / game format).\n positions_raw = brain_data.get('positions', brain_data.get('neurons', {}))\n for name, pos in positions_raw.items():\n if isinstance(pos, dict):\n # Designer format: {'position': [x, y], 'is_custom': bool}\n # Headless export format: {'x': float, 'y': float, 'is_custom': bool}\n if 'position' in pos:\n p = pos['position']\n self.positions[name] = (float(p[0]), float(p[1]))\n elif 'x' in pos and 'y' in pos:\n self.positions[name] = (float(pos['x']), float(pos['y']))\n else:\n self.positions[name] = (0.0, 0.0)\n if pos.get('is_custom', False):\n self.custom_neurons.add(name)\n elif isinstance(pos, (list, tuple)) and len(pos) >= 2:\n self.positions[name] = (float(pos[0]), float(pos[1]))\n else:\n # Fallback: unknown shape — park at origin rather than\n # storing a raw unsupported value.\n self.positions[name] = (0.0, 0.0)\n \n # Initialize state\n if name in CORE_NEURONS:\n self.state[name] = 50.0\n elif name in INPUT_SENSORS:\n self.state[name] = 0.0\n else:\n self.state[name] = 50.0\n self.custom_neurons.add(name)\n \n # Load weights/connections\n # Accept list format (Designer) and dict format (headless export).\n weights_data = brain_data.get('weights', brain_data.get('connections', {}))\n if isinstance(weights_data, dict):\n for key, weight in weights_data.items():\n # Handle string keys like \"hunger,satisfaction\" or \"hunger->satisfaction\"\n if isinstance(key, str):\n if '->' in key:\n parts = key.split('->')\n else:\n parts = key.replace('(', '').replace(')', '').replace(\"'\", \"\").split(',')\n if len(parts) >= 2:\n src = parts[0].strip()\n dst = parts[1].strip()\n self.weights[(src, dst)] = float(weight)\n else:\n self.weights[tuple(key)] = float(weight)\n elif isinstance(weights_data, list):\n for conn in weights_data:\n if isinstance(conn, dict):\n src = conn.get('source', conn.get('from', ''))\n dst = conn.get('target', conn.get('to', ''))\n w = conn.get('weight', 0.5)\n if src and dst:\n self.weights[(src, dst)] = float(w)\n elif isinstance(conn, (list, tuple)) and len(conn) >= 2:\n self.weights[(conn[0], conn[1])] = float(conn[2]) if len(conn) > 2 else 0.5\n \n # Load shapes\n self.neuron_shapes = brain_data.get('neuron_shapes', {})\n \n # Load output bindings\n self.output_bindings = brain_data.get('output_bindings', [])\n \n # Load neurogenesis data if present\n if 'neurogenesis_data' in brain_data:\n self.neurogenesis_data.update(brain_data['neurogenesis_data'])\n \n print(f\"✓ Loaded brain: {len(self.positions)} neurons, {len(self.weights)} connections\")\n return True\n \n except Exception as e:\n print(f\"✗ Error loading brain: {e}\")\n return False\n \n def load_brain_file(self, filepath: str) -> bool:\n \"\"\"Load brain from JSON file\"\"\"\n try:\n with open(filepath, 'r') as f:\n brain_data = json.load(f)\n return self.load_brain(brain_data)\n except Exception as e:\n print(f\"✗ Error loading brain file: {e}\")\n return False\n \n def export_brain(self) -> Dict:\n \"\"\"\n Export brain in the Designer/game format understood by\n custom_brain_loader.BrainLoader._parse() (Format 2: neurons dict +\n connections list). This ensures trained brains can be loaded\n straight back into the game without any manual conversion.\n \"\"\"\n # neurons dict — position as list, is_custom flag\n neurons = {}\n for name, pos in self.positions.items():\n neurons[name] = {\n 'position': [pos[0], pos[1]],\n 'is_custom': name in self.custom_neurons,\n }\n\n # connections as a list of {source, target, weight} dicts\n # (BrainLoader._parse() Format 2 expects this exact structure)\n connections = []\n for (src, dst), w in self.weights.items():\n connections.append({'source': src, 'target': dst, 'weight': float(w)})\n\n return {\n 'metadata': {\n 'exported_at': time.strftime('%Y-%m-%d %H:%M:%S'),\n 'exported_by': 'headless_trainer',\n 'neuron_count': len(self.positions),\n 'connection_count': len(self.weights),\n 'custom_neuron_count': len(self.custom_neurons),\n },\n # ── game-loader-compatible keys ──────────────────────────────────\n 'neurons': neurons, # _parse() checks for 'neurons' key\n 'connections': connections, # _parse() Format 2: list of dicts\n # ────────────────────────────────────────────────────────────────\n 'neuron_shapes': dict(self.neuron_shapes),\n 'output_bindings': self.output_bindings,\n 'state': {k: v for k, v in self.state.items()},\n 'neurogenesis_data': {\n 'neurons_created': self.neurogenesis_data.get('neurons_created', 0),\n 'stress_neurons': self.stress_neuron_count,\n 'novelty_neurons': self.novelty_neuron_count,\n 'reward_neurons': self.reward_neuron_count,\n },\n }\n \n def save_brain(self, filepath: str) -> bool:\n \"\"\"Save brain to JSON file\"\"\"\n try:\n brain_data = self.export_brain()\n with open(filepath, 'w') as f:\n json.dump(brain_data, f, indent=2)\n print(f\"✓ Saved brain to {filepath}\")\n return True\n except Exception as e:\n print(f\"✗ Error saving brain: {e}\")\n return False\n \n def update_state(self, squid_state: Dict[str, Any]):\n \"\"\"Update brain state from squid state\"\"\"\n for key, value in squid_state.items():\n if key in self.positions or key in self.state:\n if isinstance(value, bool):\n self.state[key] = 100.0 if value else 0.0\n elif isinstance(value, (int, float)):\n self.state[key] = float(value)\n \n def propagate(self):\n \"\"\"Propagate activations through connections\"\"\"\n updates = {}\n \n for (src, dst), weight in self.weights.items():\n if src in self.state and dst in self.state:\n if dst in PURE_INPUTS:\n continue\n \n src_val = self.state[src]\n effect = src_val * weight * 0.1\n updates[dst] = updates.get(dst, 0) + effect\n \n # Apply updates with decay\n for neuron, delta in updates.items():\n if neuron in self.state and neuron not in PURE_INPUTS:\n old_val = self.state[neuron]\n new_val = old_val * self.config.decay_rate + delta\n new_val += random.uniform(-self.config.noise_range, self.config.noise_range)\n self.state[neuron] = max(-100, min(100, new_val))\n \n def perform_hebbian_learning(self) -> List[Tuple[str, str]]:\n \"\"\"Perform Hebbian learning update\"\"\"\n # Get learning candidates\n excluded = set(PURE_INPUTS) | self.connector_neurons\n candidates = [n for n in self.positions.keys() if n not in excluded]\n \n if len(candidates) < 2:\n return []\n \n # Score pairs\n scored_pairs = []\n for i, n1 in enumerate(candidates):\n for n2 in candidates[i+1:]:\n v1 = self._get_neuron_value(self.state.get(n1, 50))\n v2 = self._get_neuron_value(self.state.get(n2, 50))\n score = v1 + v2 + random.uniform(0, 40)\n \n # Penalize recent pairs\n pair_key = tuple(sorted((n1, n2)))\n if pair_key in self.last_hebbian_pairs:\n score -= 500\n \n # Boost custom neurons\n if n1 in self.custom_neurons or n2 in self.custom_neurons:\n score += 15\n \n scored_pairs.append((score, n1, n2, v1, v2))\n \n # Select top pairs\n top_pairs = nlargest(self.config.max_hebbian_pairs, scored_pairs)\n self.last_hebbian_pairs = [tuple(sorted((n1, n2))) for _, n1, n2, _, _ in top_pairs]\n \n updated_pairs = []\n for _, n1, n2, v1, v2 in top_pairs:\n pair = (n1, n2)\n reverse_pair = (n2, n1)\n \n # Find existing connection\n if pair in self.weights:\n use_pair = pair\n elif reverse_pair in self.weights:\n use_pair = reverse_pair\n else:\n use_pair = pair\n self.weights[use_pair] = 0.0\n \n old_w = self.weights[use_pair]\n \n # Calculate learning rate with boosts\n lr = self.config.learning_rate\n if n1 in self.new_neurons or n2 in self.new_neurons:\n lr *= 2.0\n if n1 in self.custom_neurons or n2 in self.custom_neurons:\n lr *= 1.5\n \n # Hebbian update\n delta = lr * (v1 / 100.0) * (v2 / 100.0)\n new_w = old_w + delta - (old_w * self.config.weight_decay)\n new_w = max(-1.0, min(1.0, new_w))\n \n self.weights[use_pair] = new_w\n updated_pairs.append(use_pair)\n \n # Track history\n self.weight_history.append({\n 'pair': use_pair,\n 'old': old_w,\n 'new': new_w,\n 'tick': time.time()\n })\n \n return updated_pairs\n \n def check_neurogenesis(self, squid_state: Dict, tick: int) -> Optional[str]:\n \"\"\"Check if neurogenesis should occur\"\"\"\n if not self.config.neurogenesis_enabled:\n return None\n \n if tick - self.last_neurogenesis_tick < self.config.neurogenesis_cooldown:\n return None\n \n if len(self.positions) >= self.config.max_neurons:\n return None\n \n # Check triggers\n anxiety = squid_state.get('anxiety', 50)\n curiosity = squid_state.get('curiosity', 50)\n happiness = squid_state.get('happiness', 50)\n satisfaction = squid_state.get('satisfaction', 50)\n \n trigger_type = None\n \n # Stress trigger\n if anxiety > 70 or (anxiety > 50 and squid_state.get('is_fleeing', False)):\n if self.stress_neuron_count < 5: # Cap stress neurons\n trigger_type = 'stress'\n \n # Novelty trigger\n elif curiosity > 75:\n trigger_type = 'novelty'\n \n # Reward trigger\n elif happiness > 80 and satisfaction > 70:\n trigger_type = 'reward'\n \n if trigger_type:\n neuron_name = self._create_neuron(trigger_type, squid_state)\n self.last_neurogenesis_tick = tick\n return neuron_name\n \n return None\n \n def _create_neuron(self, neuron_type: str, context: Dict) -> str:\n \"\"\"Create a new neuron\"\"\"\n # Generate unique name\n count = self.neurogenesis_data.get('neurons_created', 0) + 1\n self.neurogenesis_data['neurons_created'] = count\n \n neuron_name = f\"{neuron_type}_{count}\"\n \n # Find position (spread from existing neurons)\n existing_positions = list(self.positions.values())\n if existing_positions:\n avg_x = sum(p[0] for p in existing_positions) / len(existing_positions)\n avg_y = sum(p[1] for p in existing_positions) / len(existing_positions)\n \n # Add some randomness\n new_x = avg_x + random.uniform(-100, 100)\n new_y = avg_y + random.uniform(-100, 100)\n else:\n new_x = random.uniform(100, 800)\n new_y = random.uniform(100, 400)\n \n self.positions[neuron_name] = (new_x, new_y)\n self.state[neuron_name] = 50.0\n self.custom_neurons.add(neuron_name)\n self.new_neurons.add(neuron_name)\n \n # Set shape based on type\n shape_map = {'stress': 'hexagon', 'novelty': 'triangle', 'reward': 'circle'}\n self.neuron_shapes[neuron_name] = shape_map.get(neuron_type, 'circle')\n \n # Create connections based on type\n if neuron_type == 'stress':\n self.stress_neuron_count += 1\n self.weights[(neuron_name, 'anxiety')] = -0.3\n self.weights[('anxiety', neuron_name)] = 0.4\n \n elif neuron_type == 'novelty':\n self.novelty_neuron_count += 1\n self.weights[(neuron_name, 'curiosity')] = 0.3\n self.weights[('curiosity', neuron_name)] = 0.3\n \n elif neuron_type == 'reward':\n self.reward_neuron_count += 1\n self.weights[(neuron_name, 'satisfaction')] = 0.35\n self.weights[(neuron_name, 'happiness')] = 0.25\n \n self.neurogenesis_data['new_neurons'].append(neuron_name)\n \n return neuron_name\n \n def _get_neuron_value(self, val) -> float:\n \"\"\"Convert value to float for calculations\"\"\"\n if isinstance(val, bool):\n return 100.0 if val else 0.0\n if isinstance(val, (int, float)):\n return float(val)\n return 0.0\n \n def get_statistics(self) -> Dict:\n \"\"\"Get brain statistics\"\"\"\n return {\n 'total_neurons': len(self.positions),\n 'total_connections': len(self.weights),\n 'custom_neurons': len(self.custom_neurons),\n 'stress_neurons': self.stress_neuron_count,\n 'novelty_neurons': self.novelty_neuron_count,\n 'reward_neurons': self.reward_neuron_count,\n 'weight_updates': len(self.weight_history),\n 'avg_weight': sum(self.weights.values()) / len(self.weights) if self.weights else 0,\n }\n\n\n# ============================================================================\n# HEADLESS SIMULATION\n# ============================================================================\n\nclass HeadlessSimulation:\n \"\"\"\n Headless simulation runner for brain training.\n Runs the simulation loop without GUI, with accelerated time.\n \"\"\"\n \n def __init__(self, config: TrainingConfig = None):\n self.config = config or TrainingConfig()\n self.brain = HeadlessBrain(config)\n self.squid = HeadlessSquid()\n \n # Simulation state\n self.tick = 0\n self.running = False\n \n # Environment\n self.food_items: List[Dict] = []\n self.poop_items: List[Dict] = []\n \n # Statistics\n self.stats = {\n 'ticks_completed': 0,\n 'neurons_created': 0,\n 'hebbian_updates': 0,\n 'food_eaten': 0,\n 'startles': 0,\n 'peak_anxiety': 0,\n 'peak_happiness': 0,\n }\n \n # Event queue (for scenarios)\n self.event_queue: List[Dict] = []\n \n # Progress callback\n self.progress_callback = None\n \n def load_brain(self, filepath: str) -> bool:\n \"\"\"Load a brain from file\"\"\"\n return self.brain.load_brain_file(filepath)\n \n def load_scenario(self, scenario_name: str) -> bool:\n \"\"\"Load a predefined training scenario\"\"\"\n if scenario_name not in TRAINING_SCENARIOS:\n print(f\"✗ Unknown scenario: {scenario_name}\")\n print(f\" Available: {list(TRAINING_SCENARIOS.keys())}\")\n return False\n \n scenario = TRAINING_SCENARIOS[scenario_name]\n print(f\"✓ Loading scenario: {scenario.name}\")\n print(f\" Description: {scenario.description}\")\n print(f\" Duration: {scenario.duration_ticks} ticks\")\n \n # Apply config overrides\n for key, value in scenario.config_overrides.items():\n if hasattr(self.config, key):\n setattr(self.config, key, value)\n \n # Queue events\n self.event_queue = list(scenario.events)\n \n return True\n \n def run(self, ticks: int = 1000, progress_interval: int = 100) -> Dict:\n \"\"\"\n Run the simulation for specified number of ticks.\n \n Args:\n ticks: Number of simulation ticks to run\n progress_interval: How often to report progress\n \n Returns:\n Dictionary with final statistics\n \"\"\"\n self.running = True\n start_time = time.time()\n \n print(f\"\\n🚀 Starting headless training: {ticks} ticks\")\n print(f\" Brain: {len(self.brain.positions)} neurons, {len(self.brain.weights)} connections\")\n print()\n \n for self.tick in range(ticks):\n if not self.running:\n break\n \n # Process queued events\n self._process_events()\n \n # Simulation step\n self._simulation_step()\n \n # Progress report\n if progress_interval > 0 and (self.tick + 1) % progress_interval == 0:\n elapsed = time.time() - start_time\n tps = (self.tick + 1) / elapsed if elapsed > 0 else 0\n self._report_progress(tps)\n \n # Final statistics\n elapsed = time.time() - start_time\n self.stats['ticks_completed'] = self.tick + 1\n self.stats['elapsed_seconds'] = elapsed\n self.stats['ticks_per_second'] = (self.tick + 1) / elapsed if elapsed > 0 else 0\n \n print(f\"\\n✓ Training complete!\")\n print(f\" Ticks: {self.stats['ticks_completed']}\")\n print(f\" Time: {elapsed:.2f}s ({self.stats['ticks_per_second']:.1f} ticks/sec)\")\n print(f\" Neurons created: {self.stats['neurons_created']}\")\n print(f\" Hebbian updates: {self.stats['hebbian_updates']}\")\n \n brain_stats = self.brain.get_statistics()\n print(f\"\\n Brain Statistics:\")\n print(f\" Total neurons: {brain_stats['total_neurons']}\")\n print(f\" Connections: {brain_stats['total_connections']}\")\n print(f\" Custom neurons: {brain_stats['custom_neurons']}\")\n \n return {**self.stats, **brain_stats}\n \n def _simulation_step(self):\n \"\"\"Execute one simulation tick\"\"\"\n # 1. Update squid state\n self.squid.update()\n \n # 2. Environment events\n self._update_environment()\n \n # 3. Update brain with squid state\n squid_state = self.squid.get_state_dict()\n self.brain.update_state(squid_state)\n \n # 4. Propagate brain activations\n self.brain.propagate()\n \n # 5. Hebbian learning (periodic)\n if self.tick % self.config.hebbian_interval == 0:\n updated = self.brain.perform_hebbian_learning()\n if updated:\n self.stats['hebbian_updates'] += len(updated)\n \n # 6. Neurogenesis check\n new_neuron = self.brain.check_neurogenesis(squid_state, self.tick)\n if new_neuron:\n self.stats['neurons_created'] += 1\n print(f\" 🧠 Tick {self.tick}: Created neuron '{new_neuron}'\")\n \n # 7. Track statistics\n self.stats['peak_anxiety'] = max(self.stats['peak_anxiety'], self.squid.anxiety)\n self.stats['peak_happiness'] = max(self.stats['peak_happiness'], self.squid.happiness)\n \n def _update_environment(self):\n \"\"\"Update environment (spawn/despawn items, random events)\"\"\"\n # Food spawning\n if random.random() < self.config.food_spawn_chance:\n self.food_items.append({'x': random.random(), 'y': random.random()})\n self.squid.food_visible = True\n \n # Food consumption\n if self.squid.food_visible and random.random() < 0.1:\n self.squid.feed()\n self.stats['food_eaten'] += 1\n if self.food_items:\n self.food_items.pop(0)\n self.squid.food_visible = len(self.food_items) > 0\n \n # Poop spawning\n if random.random() < self.config.poop_spawn_chance:\n self.poop_items.append({'x': random.random(), 'y': random.random()})\n self.squid.cleanliness = max(0, self.squid.cleanliness - 5)\n \n # Random startle\n if random.random() < self.config.startle_chance:\n self.squid.startle()\n self.stats['startles'] += 1\n \n # Plant proximity (random for now)\n self.squid.plant_nearby = random.random() < 0.2\n \n def _process_events(self):\n \"\"\"Process queued scenario events\"\"\"\n events_to_remove = []\n \n for event in self.event_queue:\n if event.get('tick', 0) == self.tick:\n self._execute_event(event)\n events_to_remove.append(event)\n \n for event in events_to_remove:\n self.event_queue.remove(event)\n \n def _execute_event(self, event: Dict):\n \"\"\"Execute a scenario event\"\"\"\n event_type = event.get('type', '')\n \n if event_type == 'set_state':\n state = event.get('state', {})\n for key, value in state.items():\n if hasattr(self.squid, key):\n setattr(self.squid, key, value)\n print(f\" 📋 Tick {self.tick}: Set state {state}\")\n \n elif event_type == 'feed':\n self.squid.feed()\n self.stats['food_eaten'] += 1\n print(f\" 🍕 Tick {self.tick}: Fed squid\")\n \n elif event_type == 'startle':\n self.squid.startle()\n self.stats['startles'] += 1\n print(f\" ⚡ Tick {self.tick}: Startled squid\")\n \n elif event_type == 'clean':\n self.squid.clean()\n print(f\" 🧹 Tick {self.tick}: Cleaned environment\")\n \n elif event_type == 'new_object':\n self.squid.curiosity = min(100, self.squid.curiosity + 20)\n print(f\" 🆕 Tick {self.tick}: New object encountered\")\n \n def _report_progress(self, tps: float):\n \"\"\"Report training progress\"\"\"\n stats = self.brain.get_statistics()\n squid = self.squid\n \n progress_pct = (self.tick + 1) / max(1, self.stats.get('target_ticks', self.tick + 1)) * 100\n \n print(f\" [{self.tick+1:6d}] {tps:6.1f} t/s | \"\n f\"Neurons: {stats['total_neurons']:2d} | \"\n f\"H:{squid.hunger:5.1f} A:{squid.anxiety:5.1f} S:{squid.satisfaction:5.1f} | \"\n f\"Created: {self.stats['neurons_created']}\")\n \n def stop(self):\n \"\"\"Stop the simulation\"\"\"\n self.running = False\n\n\n# ============================================================================\n# COMMAND LINE INTERFACE\n# ============================================================================\n\ndef main():\n parser = argparse.ArgumentParser(\n description='Dosidicus-2 Headless Brain Trainer',\n formatter_class=argparse.RawDescriptionHelpFormatter,\n epilog=\"\"\"\nExamples:\n Train a brain for 10000 ticks:\n python headless_trainer.py --brain my_brain.json --ticks 10000 --output trained.json\n \n Run a stress test scenario:\n python headless_trainer.py --brain my_brain.json --scenario stress_test --output stress_trained.json\n \n List available scenarios:\n python headless_trainer.py --list-scenarios\n \n Quick training with default brain:\n python headless_trainer.py --ticks 5000 --output quick_trained.json\n \"\"\"\n )\n \n parser.add_argument('--brain', '-b', type=str, help='Path to brain JSON file to load')\n parser.add_argument('--output', '-o', type=str, help='Path to save trained brain')\n parser.add_argument('--ticks', '-t', type=int, default=10000, help='Number of ticks to train (default: 10000)')\n parser.add_argument('--scenario', '-s', type=str, help='Training scenario to use')\n parser.add_argument('--list-scenarios', action='store_true', help='List available training scenarios')\n parser.add_argument('--progress', '-p', type=int, default=500, help='Progress report interval (default: 500)')\n parser.add_argument('--quiet', '-q', action='store_true', help='Minimal output')\n \n # Config overrides\n parser.add_argument('--learning-rate', type=float, help='Hebbian learning rate')\n parser.add_argument('--neurogenesis', type=bool, help='Enable neurogenesis')\n parser.add_argument('--max-neurons', type=int, help='Maximum neurons allowed')\n \n args = parser.parse_args()\n \n # List scenarios\n if args.list_scenarios:\n print(\"\\nAvailable Training Scenarios:\")\n print(\"-\" * 60)\n for name, scenario in TRAINING_SCENARIOS.items():\n print(f\"\\n {name}:\")\n print(f\" {scenario.description}\")\n print(f\" Duration: {scenario.duration_ticks} ticks\")\n if scenario.config_overrides:\n print(f\" Config overrides: {scenario.config_overrides}\")\n print()\n return\n \n # Build config\n config = TrainingConfig()\n if args.learning_rate:\n config.learning_rate = args.learning_rate\n if args.neurogenesis is not None:\n config.neurogenesis_enabled = args.neurogenesis\n if args.max_neurons:\n config.max_neurons = args.max_neurons\n \n # Create simulation\n sim = HeadlessSimulation(config)\n \n # Load brain\n if args.brain:\n if not os.path.exists(args.brain):\n print(f\"✗ Brain file not found: {args.brain}\")\n sys.exit(1)\n if not sim.load_brain(args.brain):\n sys.exit(1)\n else:\n print(\"ℹ Using default brain architecture\")\n \n # Load scenario\n ticks = args.ticks\n if args.scenario:\n if not sim.load_scenario(args.scenario):\n sys.exit(1)\n # Use scenario duration if longer\n scenario = TRAINING_SCENARIOS.get(args.scenario)\n if scenario and scenario.duration_ticks > ticks:\n ticks = scenario.duration_ticks\n \n # Run training\n progress = 0 if args.quiet else args.progress\n sim.stats['target_ticks'] = ticks\n \n try:\n stats = sim.run(ticks=ticks, progress_interval=progress)\n except KeyboardInterrupt:\n print(\"\\n\\n⚠ Training interrupted by user\")\n sim.stop()\n stats = sim.stats\n \n # Save output\n if args.output:\n sim.brain.save_brain(args.output)\n else:\n # Default output name\n timestamp = time.strftime('%Y%m%d_%H%M%S')\n output_name = f\"trained_brain_{timestamp}.json\"\n sim.brain.save_brain(output_name)\n \n print(\"\\n✓ Done!\")\n\n\nif __name__ == '__main__':\n main()\n"
},
{
"path": "images/decoration/DecorationsFolder",
"content": "\n"
},
{
"path": "linux_setup.sh",
"content": "#!/usr/bin/env bash\n# =============================================================\n# Dosidicus - Linux Setup & Launch Script\n# https://github.com/ViciousSquid/Dosidicus\n# =============================================================\n#\n# If you hit a Qt platform error like `could not load the Qt platform plugin \"xcb\", run the following:\n# sudo apt install libxcb-xinerama0 libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-xkb1 libxkbcommon-x11-0\n\nset -e\n\nREPO_URL=\"https://github.com/ViciousSquid/Dosidicus.git\"\n# Use the current directory where the script lives\nINSTALL_DIR=\"$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\"\nVENV_DIR=\"$INSTALL_DIR/.venv\"\n\n# ── Colours ──────────────────────────────────────────────────\nRED='\\033[0;31m'; GREEN='\\033[0;32m'; YELLOW='\\033[1;33m'\nCYAN='\\033[0;36m'; BOLD='\\033[1m'; NC='\\033[0m'\n\ninfo() { echo -e \"${CYAN}▸ $*${NC}\"; }\nsuccess() { echo -e \"${GREEN}✔ $*${NC}\"; }\nwarn() { echo -e \"${YELLOW}⚠ $*${NC}\"; }\nerror() { echo -e \"${RED}✖ $*${NC}\"; exit 1; }\n\necho -e \"${BOLD}\"\necho \" DOSIDICUS by ViciousSquid\"\necho -e \"${NC}\"\necho -e \" ${BOLD}A cognitive sandbox for raising digital squids${NC}\"\necho \" ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\"\necho \"\"\n\n# ── 1. Check Python ───────────────────────────────────────────\ninfo \"Checking Python version...\"\nif ! command -v python3 &>/dev/null; then\n error \"python3 not found. Install it with: sudo apt install python3\"\nfi\n\nPY_VER=$(python3 -c 'import sys; print(f\"{sys.version_info.major}.{sys.version_info.minor}\")')\nPY_MAJOR=$(echo \"$PY_VER\" | cut -d. -f1)\nPY_MINOR=$(echo \"$PY_VER\" | cut -d. -f2)\n\nif [[ \"$PY_MAJOR\" -lt 3 || (\"$PY_MAJOR\" -eq 3 && \"$PY_MINOR\" -lt 9) ]]; then\n error \"Python 3.9+ required. Found: $PY_VER\"\nfi\nsuccess \"Python $PY_VER found\"\n\n# ── 2. Check / install system deps ───────────────────────────\ninfo \"Checking system dependencies...\"\n\nMISSING_PKGS=()\nfor pkg in git python3-venv python3-dev; do\n if ! dpkg -s \"$pkg\" &>/dev/null 2>&1; then\n MISSING_PKGS+=(\"$pkg\")\n fi\ndone\n\n# PyQt5 often needs these on Linux\nfor pkg in libxcb-xinerama0 libxcb-cursor0 libgl1 libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-xkb1 libxkbcommon-x11-0; do\n if ! dpkg -s \"$pkg\" &>/dev/null 2>&1; then\n MISSING_PKGS+=(\"$pkg\")\n fi\ndone\n\nif [[ ${#MISSING_PKGS[@]} -gt 0 ]]; then\n warn \"Missing packages: ${MISSING_PKGS[*]}\"\n echo -e \" Installing with sudo...\"\n sudo apt-get update -qq\n sudo apt-get install -y -qq \"${MISSING_PKGS[@]}\"\n success \"System packages installed\"\nelse\n success \"All system packages present\"\nfi\n\n# ── 3. Clone or update repo ───────────────────────────────────\n# If we are already inside a git repo, just pull.\nif [[ -d \"$INSTALL_DIR/.git\" ]]; then\n info \"Repo already exists at $INSTALL_DIR — pulling latest...\"\n git -C \"$INSTALL_DIR\" pull --ff-only\n success \"Updated to latest\"\nelif [[ ! -f \"$INSTALL_DIR/main.py\" ]]; then\n info \"Cloning Dosidicus into $INSTALL_DIR...\"\n git clone \"$REPO_URL\" \"$INSTALL_DIR\"\n success \"Cloned successfully\"\nfi\n\ncd \"$INSTALL_DIR\"\n\n# ── 4. Create virtualenv ──────────────────────────────────────\nif [[ ! -d \"$VENV_DIR\" ]]; then\n info \"Creating Python virtual environment...\"\n python3 -m venv \"$VENV_DIR\"\n success \"Virtual environment created\"\nelse\n success \"Virtual environment already exists\"\nfi\n\n# Activate\n# shellcheck disable=SC1091\nsource \"$VENV_DIR/bin/activate\"\n\n# ── 5. Install Python dependencies ───────────────────────────\ninfo \"Installing Python dependencies...\"\npip install --upgrade pip --quiet\n\nif [[ -f \"requirements.txt\" ]]; then\n pip install -r requirements.txt --quiet\nelse\n pip install --quiet \"PyQt5>=5.15\" \"numpy>=1.21\"\nfi\n\n# Optional but recommended for PyQt5\npip install --quiet \"pyqt5-sip\" 2>/dev/null || true\n\nsuccess \"Python packages installed\"\n\n# ── 6. Create launcher script ─────────────────────────────────\nLAUNCHER=\"$INSTALL_DIR/run.sh\"\ncat > \"$LAUNCHER\" << LAUNCH\n#!/usr/bin/env bash\nDIR=\"\\$(cd \"\\$(dirname \"\\${BASH_SOURCE[0]}\")\" && pwd)\"\nsource \"\\$DIR/.venv/bin/activate\"\n\n# Fix for Qt/XCB issues on some Linux setups\nexport QT_QPA_PLATFORM=\"\\${QT_QPA_PLATFORM:-xcb}\"\n# Crucial: This ensures main.py can find the 'src' folder\nexport PYTHONPATH=\"\\$DIR:\\$PYTHONPATH\"\n\ncd \"\\$DIR\"\nexec python3 main.py \"\\$@\"\nLAUNCH\nchmod +x \"$LAUNCHER\"\nsuccess \"Launcher script created: $LAUNCHER\"\n\n# ── 7. Create desktop shortcut (optional) ────────────────────\nDESKTOP_FILE=\"$HOME/.local/share/applications/dosidicus.desktop\"\nmkdir -p \"$(dirname \"$DESKTOP_FILE\")\"\ncat > \"$DESKTOP_FILE\" << DESKTOP\n[Desktop Entry]\nName=Dosidicus\nComment=A cognitive sandbox for raising digital squids\nExec=$LAUNCHER\nIcon=$INSTALL_DIR/images/icon.png\nTerminal=false\nType=Application\nCategories=Game;Simulation;\nDESKTOP\nsuccess \"Desktop shortcut created\"\n\n# ── 8. Done! ──────────────────────────────────────────────────\necho \"\"\necho -e \"${GREEN}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\"\necho -e \" Setup complete!\"\necho -e \"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}\"\necho \"\"\necho -e \" ${BOLD}To launch Dosidicus:${NC}\"\necho -e \" ${CYAN}$LAUNCHER${NC}\"\necho \"\"\necho -e \" ${BOLD}Or from any terminal:${NC}\"\necho -e \" ${CYAN}cd $INSTALL_DIR && source .venv/bin/activate && python3 main.py${NC}\"\necho \"\"\necho -e \" ${BOLD}Headless/training mode:${NC}\"\necho -e \" ${CYAN}cd $INSTALL_DIR && source .venv/bin/activate && python3 headless/headless_trainer.py${NC}\"\necho \"\"\n\n# ── 9. Offer to launch now ────────────────────────────────────\nread -rp \" Launch Dosidicus now? [y/N] \" REPLY\nif [[ \"$REPLY\" =~ ^[Yy]$ ]]; then\n info \"Launching...\"\n exec \"$LAUNCHER\"\nfi\n"
},
{
"path": "main.py",
"content": "# Dosidicus - a digital pet with a neural network | 2.1.2.0 March 2026\n# main.py Entrypoint \nfrom PyQt5 import QtWidgets, QtCore, QtGui\nimport sys\nimport os\n\n# BOOTSTRAP: Add the current directory and src directory to sys.path\n# This ensures \"from src.ui import Ui\" works even if launched from elsewhere.\nBASE_DIR = os.path.dirname(os.path.abspath(__file__))\nif BASE_DIR not in sys.path:\n sys.path.insert(0, BASE_DIR)\n\nimport time\nimport sys\nimport json\nimport os\nimport shutil\nimport traceback\nimport multiprocessing\nimport logging\nfrom PyQt5 import QtWidgets, QtCore\nimport random\nimport argparse\nfrom src.ui import Ui\nfrom src.tamagotchi_logic import TamagotchiLogic\nfrom src.squid import Squid, Personality\nfrom src.splash_screen import SplashScreen\nfrom src.save_manager import SaveManager\nfrom src.brain_tool import SquidBrainWindow\nfrom src.display_scaling import DisplayScaling\nfrom src.learning import LearningConfig\nfrom src.plugin_manager import PluginManager\nfrom src.brain_worker import BrainWorker\nfrom src.config_manager import ConfigManager\nfrom src.localisation import Localisation\n\ndef launch_brain_designer_process():\n \"\"\"Entry point for Brain Designer in a separate process\"\"\"\n from src.brain_designer_launcher import launch_brain_designer_process as _launch\n _launch()\n\ndef setup_logging_configuration():\n \"\"\"Initialize logging configuration\"\"\"\n os.environ['QT_LOGGING_RULES'] = '*.debug=false;qt.qpa.*=false;qt.style.*=false'\n os.makedirs('logs', exist_ok=True)\n\n logging.basicConfig(\n filename='logs/dosidicus_log.txt',\n level=logging.ERROR,\n format='%(asctime)s - %(levelname)s - %(message)s'\n )\n\ndef perform_cleanup_and_exit():\n \"\"\"Recursively delete __pycache__ and logs directories.\"\"\"\n print(\"🧹 Cleaning environment...\")\n root_dir = os.path.dirname(os.path.abspath(__file__))\n \n deleted_count = 0\n \n for root, dirs, files in os.walk(root_dir, topdown=True):\n # Filter and remove specific directories\n # We iterate over a copy of dirs so we can modify the original list safely\n for name in list(dirs):\n if name in ['__pycache__', 'logs']:\n path = os.path.join(root, name)\n try:\n shutil.rmtree(path)\n print(f\" Deleted: {path}\")\n dirs.remove(name) # Prevent os.walk from trying to enter this dir\n deleted_count += 1\n except Exception as e:\n print(f\" ❌ Failed to delete {path}: {e}\")\n \n print(f\"✨ Cleanup complete. Removed {deleted_count} directories.\")\n\ndef global_exception_handler(exctype, value, tb):\n \"\"\"Global exception handler to log unhandled exceptions\"\"\"\n error_message = ''.join(traceback.format_exception(exctype, value, tb))\n logging.error(\"Unhandled exception:\\n%s\", error_message)\n QtWidgets.QMessageBox.critical(None, \"Error\", \n \"An unexpected error occurred. Please check dosidicus_log.txt for details.\")\n\n\nclass TeeStream:\n \"\"\"Duplicate output to both console and file\"\"\"\n def __init__(self, original_stream, file_stream):\n self.original_stream = original_stream\n self.file_stream = file_stream\n\n def write(self, data):\n self.original_stream.write(data)\n self.file_stream.write(data)\n self.file_stream.flush()\n\n def flush(self):\n self.original_stream.flush()\n self.file_stream.flush()\n\nclass TimedMessageBox(QtWidgets.QDialog):\n \"\"\"A message box that auto-closes after a timeout with a default choice\"\"\"\n def __init__(self, parent, title, message, timeout_seconds=5):\n super().__init__(parent)\n self.setWindowTitle(title)\n self.timeout_seconds = timeout_seconds\n self.remaining_seconds = timeout_seconds\n self.result_value = QtWidgets.QMessageBox.No # Default to No\n self.loc = Localisation.instance()\n \n # Setup UI\n layout = QtWidgets.QVBoxLayout()\n \n self.message_label = QtWidgets.QLabel(message)\n self.message_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(13)}pt;\")\n layout.addWidget(self.message_label)\n \n # Auto-decline message\n self.timer_label = QtWidgets.QLabel(self.loc.get(\"auto_decline\", seconds=self.remaining_seconds))\n self.timer_label.setStyleSheet(f\"color: gray; font-size: {DisplayScaling.font_size(11)}pt;\")\n layout.addWidget(self.timer_label)\n \n # Buttons\n self.button_box = QtWidgets.QDialogButtonBox(\n QtWidgets.QDialogButtonBox.Yes | QtWidgets.QDialogButtonBox.No\n )\n # Localise buttons manually since we use a custom dict system\n self.button_box.button(QtWidgets.QDialogButtonBox.Yes).setText(self.loc.get(\"yes\"))\n self.button_box.button(QtWidgets.QDialogButtonBox.No).setText(self.loc.get(\"no\"))\n\n self.button_box.accepted.connect(self.accept_yes)\n self.button_box.rejected.connect(self.reject_no)\n layout.addWidget(self.button_box)\n \n self.setLayout(layout)\n \n # Setup timer\n self.timer = QtCore.QTimer(self)\n self.timer.timeout.connect(self.update_countdown)\n self.timer.start(1000) # Update every second\n\n\n \n def update_countdown(self):\n \"\"\"Update the countdown and auto-close when time runs out\"\"\"\n self.remaining_seconds -= 1\n self.timer_label.setText(self.loc.get(\"auto_decline\", seconds=self.remaining_seconds))\n \n if self.remaining_seconds <= 0:\n self.timer.stop()\n self.reject_no() # Auto-close with No\n \n def accept_yes(self):\n \"\"\"User clicked Yes\"\"\"\n self.timer.stop()\n self.result_value = QtWidgets.QMessageBox.Yes\n self.accept()\n \n def reject_no(self):\n \"\"\"User clicked No or timeout occurred\"\"\"\n self.timer.stop()\n self.result_value = QtWidgets.QMessageBox.No\n self.reject()\n \n def get_result(self):\n \"\"\"Get the result after dialog closes\"\"\"\n return self.result_value\n \n\n\nclass MainWindow(QtWidgets.QMainWindow):\n def __init__(self, specified_personality=None, debug_mode=False, neuro_cooldown=None):\n super().__init__()\n \n # Apply configured language from config.ini\n config_manager = ConfigManager()\n language = config_manager.get_language()\n Localisation.instance().set_language(language)\n print(f\"📄 Applied language from config: {language}\")\n \n # Initialize configuration\n self.config = LearningConfig()\n if neuro_cooldown is not None:\n self.config.neurogenesis['cooldown'] = neuro_cooldown\n \n # Add initialization tracking flag\n self._initialization_complete = False\n \n # Set up debugging\n self.debug_mode = debug_mode\n if self.debug_mode:\n self.setup_logging()\n \n # Initialize UI first\n logging.debug(\"Initializing UI\")\n self.user_interface = Ui(self, debug_mode=self.debug_mode)\n\n # Initialize SquidBrainWindow with config\n logging.debug(\"Initializing SquidBrainWindow\")\n self.brain_window = SquidBrainWindow(None, self.debug_mode, self.config)\n \n # Store the original window reference to prevent garbage collection\n self._brain_window_ref = self.brain_window\n \n # Explicitly force creation of all tab contents\n QtCore.QTimer.singleShot(100, self.preload_brain_window_tabs)\n \n # Continue with normal initialization\n self.brain_window.set_tamagotchi_logic(None) # Placeholder to ensure initialization\n self.user_interface.squid_brain_window = self.brain_window\n \n # Initialize plugin manager after UI and brain window\n logging.debug(\"Initializing PluginManager\")\n self.plugin_manager = PluginManager()\n print(f\"> Plugin manager initialized: {self.plugin_manager}\")\n \n self.specified_personality = specified_personality\n self.neuro_cooldown = neuro_cooldown\n self.squid = None\n \n # Check for existing save data\n self.save_manager = SaveManager(\"saves\")\n \n # Track whether we want to show tutorial\n self.show_tutorial = False\n\n # ===== PERFORMANCE FIX: Single BrainWorker managed by brain_tool =====\n # Don't create another worker here - SquidBrainWindow creates and shares it\n # Access via self.brain_window.brain_worker if needed\n self.brain_worker = None\n print(\"ℹ️ BrainWorker managed by SquidBrainWindow\")\n \n # Initialize the game\n logging.debug(\"Initializing game\")\n self.initialize_game()\n \n # Now that tamagotchi_logic is created, set it in plugin_manager and brain_window\n logging.debug(\"Setting tamagotchi_logic references\")\n self.plugin_manager.tamagotchi_logic = self.tamagotchi_logic\n self.tamagotchi_logic.plugin_manager = self.plugin_manager\n self.brain_window.set_tamagotchi_logic(self.tamagotchi_logic)\n\n # New in 2.4.5.0 : Create a unique personality starter neuron\n squid = self.tamagotchi_logic.squid\n brain_widget = self.brain_window.brain_widget\n if (squid and squid.personality and\n brain_widget and hasattr(brain_widget, 'enhanced_neurogenesis')):\n\n if not squid._has_personality_starter_neuron():\n neuron = brain_widget.enhanced_neurogenesis.create_personality_starter_neuron(\n squid.personality.value,\n brain_widget.state\n )\n if neuron:\n print(f\"🧬 Personality starter neuron created: {neuron}\")\n \n # Load and initialize plugins after core components\n logging.debug(\"Loading plugins\")\n plugin_results = self.plugin_manager.load_all_plugins()\n \n # Setup plugins with tamagotchi_logic reference\n for plugin_name, plugin_data in self.plugin_manager.plugins.items():\n instance = plugin_data.get('instance')\n if instance and hasattr(instance, 'setup') and not plugin_data.get('is_setup', False):\n try:\n instance.setup(self.plugin_manager, self.tamagotchi_logic)\n plugin_data['is_setup'] = True\n except Exception as e:\n print(f\"Error setting up plugin {plugin_name}: {e}\")\n \n # CRITICAL FIX: Re-load achievement data since plugin instances were replaced\n # during load_all_plugins(), discarding any data loaded earlier\n if self.save_manager.save_exists():\n save_data = self.save_manager.load_game()\n if save_data and 'achievements' in save_data:\n self._restore_achievements_data(save_data['achievements'])\n \n # Update status bar with plugin information\n if hasattr(self.user_interface, 'status_bar'):\n self.user_interface.status_bar.update_plugins_status(self.plugin_manager)\n \n # Connect signals\n self.user_interface.new_game_action.triggered.connect(self.start_new_game)\n self.user_interface.load_action.triggered.connect(self.load_game)\n self.user_interface.save_action.triggered.connect(self.save_game)\n self.user_interface.decorations_action.triggered.connect(self.user_interface.toggle_decoration_window)\n \n # Initialize plugin menu - do this AFTER loading plugins\n self.user_interface.apply_plugin_menu_registrations(self.plugin_manager)\n \n # Position window 300 pixels to the left of default position\n desktop = QtWidgets.QApplication.desktop()\n screen_rect = desktop.screenGeometry()\n window_rect = self.geometry()\n center_x = screen_rect.center().x()\n window_x = center_x - (window_rect.width() // 2) # Default centered X position\n \n # Move 300 pixels to the left\n self.move(window_x - 300, self.y())\n \n if self.debug_mode:\n print(f\"DEBUG MODE ENABLED: Console output is being logged to console.txt\")\n\n self.setup_facts_timer()\n\n def preload_brain_window_tabs(self):\n \"\"\"Force creation of all tab contents to prevent crashes during tutorial\"\"\"\n print(\"Pre-loading brain window tabs...\")\n if not hasattr(self, 'brain_window') or not self.brain_window:\n print(\"⚠️ Brain window not initialized, cannot preload\")\n return\n \n try:\n # Force the window to process events and initialize all tabs\n if hasattr(self.brain_window, 'tabs'):\n # Visit each tab to ensure it's loaded\n tab_count = self.brain_window.tabs.count()\n \n # Initialize tabs array to prevent garbage collection\n if not hasattr(self, '_preloaded_tabs'):\n self._preloaded_tabs = []\n \n # Remember if window was visible before we started\n was_visible = self.brain_window.isVisible()\n #print(f\"📋 Brain window was_visible before preload: {was_visible}\")\n \n # Temporarily show the window off-screen to force loading\n original_pos = self.brain_window.pos()\n self.brain_window.move(-10000, -10000) # Move off-screen\n self.brain_window.show()\n \n # Force each tab to be displayed at least once\n for i in range(tab_count):\n self.brain_window.tabs.setCurrentIndex(i)\n QtWidgets.QApplication.processEvents()\n \n # Get and store references to tab widgets\n widget = self.brain_window.tabs.widget(i)\n if widget:\n self._preloaded_tabs.append(widget)\n #print(f\" ✓ Preloaded tab {i}: {self.brain_window.tabs.tabText(i)}\")\n \n # Return to first tab (Network/Brain tab)\n self.brain_window.tabs.setCurrentIndex(0)\n QtWidgets.QApplication.processEvents()\n #print(f\"📋 Reset to first tab: {self.brain_window.tabs.tabText(0)}\")\n \n # Restore original position\n self.brain_window.move(original_pos)\n \n # Only hide if it wasn't visible before (don't hide if user is viewing it)\n if not was_visible:\n self.brain_window.hide()\n print(\"📋 Brain window hidden after preload (was not visible before)\")\n else:\n print(\"📋 Brain window kept visible after preload (was visible before)\")\n \n print(f\"✅ Successfully preloaded {len(self._preloaded_tabs)} tabs\")\n except Exception as e:\n print(f\"❌ Error preloading tabs: {e}\")\n import traceback\n traceback.print_exc()\n\n def setup_logging(self):\n \"\"\"Set up console logging to file\"\"\"\n if not hasattr(sys, '_original_stdout'):\n sys._original_stdout = sys.stdout\n sys._original_stderr = sys.stderr\n \n console_log = open('console.txt', 'w', encoding='utf-8')\n sys.stdout = TeeStream(sys._original_stdout, console_log)\n sys.stderr = TeeStream(sys._original_stderr, console_log)\n\n def setup_facts_timer(self):\n \"\"\"Rare ocean-blue Humboldt squid facts every 5 minutes\"\"\"\n config_manager = ConfigManager()\n if not config_manager.get_facts_enabled():\n return\n self.fact_timer = QtCore.QTimer(self)\n self.fact_timer.timeout.connect(self.show_random_squid_fact)\n self.fact_timer.start(config_manager.get_fact_interval_ms())\n\n def show_random_squid_fact(self):\n \"\"\"Show one short Humboldt squid fact – big, bright blue, always visible\"\"\"\n try:\n from src.squid_facts import get_random_fact\n fact = get_random_fact()\n if not fact:\n return\n\n msg = f\"🌊 Humboldt Fact: {fact}\"\n\n # Preferred: status bar (works everywhere, supports color)\n if hasattr(self.user_interface, 'status_bar') and self.user_interface.status_bar:\n colored_msg = f'{msg}'\n self.user_interface.status_bar.showMessage(colored_msg, 8000) # 8 seconds\n else:\n # Fallback: plain message\n self.user_interface.show_message(msg)\n\n print(f\"[Facts] DISPLAYED: {fact[:80]}...\") # helpful console confirmation\n\n except Exception as e:\n print(f\"[Facts] Error showing fact: {e}\")\n\n def initialize_game(self):\n if hasattr(self.save_manager, 'cleanup_duplicate_saves'):\n self.save_manager.cleanup_duplicate_saves()\n \n if self.save_manager.save_exists() and self.specified_personality is None:\n print(\"\\x1b[32mExisting save data found and will be loaded\\x1b[0m\")\n self.squid = Squid(self.user_interface, None, None)\n self.tamagotchi_logic = TamagotchiLogic(self.user_interface, self.squid, self.brain_window)\n\n self.squid.tamagotchi_logic = self.tamagotchi_logic\n self.user_interface.tamagotchi_logic = self.tamagotchi_logic\n self.brain_window.tamagotchi_logic = self.tamagotchi_logic\n if hasattr(self.brain_window, 'set_tamagotchi_logic'):\n self.brain_window.set_tamagotchi_logic(self.tamagotchi_logic)\n\n self.load_game()\n\n if hasattr(self.tamagotchi_logic, 'statistics_window'):\n self.tamagotchi_logic.statistics_window.update_statistics()\n\n brain_widget = self.brain_window.brain_widget\n\n for name in brain_widget.original_neurons:\n brain_widget.visible_neurons.add(name)\n if hasattr(brain_widget, 'neurogenesis_data'):\n for name in brain_widget.neurogenesis_data.get('new_neurons_details', {}):\n brain_widget.visible_neurons.add(name)\n\n core = brain_widget.original_neurons\n for idx, name in enumerate(core):\n QtCore.QTimer.singleShot(idx * 500, lambda n=name: brain_widget.reveal_neuron(n))\n\n self.brain_window.show()\n self.user_interface.brain_action.setChecked(True)\n else:\n print(\"\\x1b[92m-------------- STARTING A NEW SIMULATION --------------\\x1b[0m\")\n\n self.create_new_game(self.specified_personality)\n self.tamagotchi_logic = TamagotchiLogic(self.user_interface, self.squid, self.brain_window)\n\n self.squid.tamagotchi_logic = self.tamagotchi_logic\n self.user_interface.tamagotchi_logic = self.tamagotchi_logic\n self.brain_window.tamagotchi_logic = self.tamagotchi_logic\n if hasattr(self.brain_window, 'set_tamagotchi_logic'):\n self.brain_window.set_tamagotchi_logic(self.tamagotchi_logic)\n\n if not self.save_manager.save_exists():\n QtCore.QTimer.singleShot(500, self.delayed_tutorial_check)\n\n self._initialization_complete = True\n\n def delayed_tutorial_check(self):\n \"\"\"Check if the user wants to see the tutorial after UI is responsive\"\"\"\n # Process pending events to ensure UI is responsive\n QtWidgets.QApplication.processEvents()\n \n # Now check tutorial preference\n self.check_tutorial_preference()\n \n # If tutorial was chosen, schedule it for later\n if self.show_tutorial:\n # We'll show tutorial when the game starts\n pass\n else:\n # Just open initial windows if no tutorial\n QtCore.QTimer.singleShot(500, self.open_initial_windows)\n\n def create_new_game(self, specified_personality=None):\n \"\"\"Create a new game instance\"\"\"\n # Delete any existing save to ensure clean start\n if self.save_manager.save_exists():\n self.save_manager.delete_save()\n \n # Choose personality randomly if not specified\n if specified_personality is None:\n personality = random.choice(list(Personality))\n else:\n personality = specified_personality\n \n # Create new squid with chosen personality\n self.squid = Squid(\n user_interface=self.user_interface,\n tamagotchi_logic=None,\n personality=personality,\n neuro_cooldown=self.neuro_cooldown\n )\n \n print(f\" \")\n print(f\">> Generated squid personality: {self.squid.personality.value}\")\n print(f\" \")\n if self.neuro_cooldown:\n print(f\"\\x1b[43m Neurogenesis cooldown:\\033[0m {self.neuro_cooldown}\")\n \n self.squid.memory_manager.clear_all_memories()\n self.show_splash_screen()\n\n def check_tutorial_preference(self):\n \"\"\"Show a dialog asking if the user wants to see the tutorial with 5-second timeout\"\"\"\n # Don't ask about tutorial if save data exists\n if self.save_manager.save_exists():\n self.show_tutorial = False\n return\n \n # Show timed dialog\n dialog = TimedMessageBox(\n self,\n Localisation.instance().get(\"startup\"),\n Localisation.instance().get(\"show_tutorial_q\"),\n timeout_seconds=5\n )\n dialog.exec_()\n \n # Set flag based on user's choice (defaults to No if timeout)\n self.show_tutorial = (dialog.get_result() == QtWidgets.QMessageBox.Yes)\n \n def position_and_show_decoration_window(self):\n \"\"\"Position the decoration window in the bottom right and show it\"\"\"\n if hasattr(self.user_interface, 'decoration_window') and self.user_interface.decoration_window:\n # Get screen geometry\n screen_geometry = QtWidgets.QApplication.desktop().availableGeometry()\n \n # Position window in bottom right\n decoration_window = self.user_interface.decoration_window\n decoration_window.move(\n screen_geometry.right() - decoration_window.width() - 20,\n screen_geometry.bottom() - decoration_window.height() - 20\n )\n decoration_window.show()\n self.user_interface.decorations_action.setChecked(True)\n\n def start_new_game(self):\n \"\"\"Start a new game, deleting any existing save\"\"\"\n # First, ask for confirmation with a timed dialog\n confirm_dialog = TimedMessageBox(\n self,\n \"Confirm New Game\",\n \"Are you sure you want to start a new game? This will delete all current progress and save data.\",\n timeout_seconds=10\n )\n confirm_dialog.exec_()\n \n # If user declined or let it timeout, abort\n if confirm_dialog.get_result() != QtWidgets.QMessageBox.Yes:\n print(\"New game cancelled by user\")\n return\n \n print(\"Starting new game...\")\n \n # Ask about tutorial\n tutorial_dialog = TimedMessageBox(\n self,\n Localisation.instance().get(\"tutorial_title\"),\n Localisation.instance().get(\"tutorial_query\"),\n timeout_seconds=5\n )\n tutorial_dialog.exec_()\n self.show_tutorial = (tutorial_dialog.get_result() == QtWidgets.QMessageBox.Yes)\n \n # Stop current simulation if running\n if hasattr(self, 'tamagotchi_logic'):\n self.tamagotchi_logic.stop()\n # Stop autosave timer if it exists\n if hasattr(self.tamagotchi_logic, 'autosave_timer'):\n self.tamagotchi_logic.autosave_timer.stop()\n \n # Delete all save files (both autosave and manual save)\n if self.save_manager.save_exists():\n self.save_manager.delete_save(is_autosave=True) # Delete autosave\n self.save_manager.delete_save(is_autosave=False) # Delete manual save\n print(\"All save files deleted\")\n \n # Clear memory files\n memory_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), '_memory')\n if os.path.exists(memory_dir):\n import shutil\n shutil.rmtree(memory_dir)\n print(\"Memory directory cleared\")\n \n # Clear all neurons and state from brain window\n if hasattr(self, 'brain_window') and hasattr(self.brain_window, 'brain_widget'):\n brain_widget = self.brain_window.brain_widget\n \n # Clear visible neurons\n brain_widget.visible_neurons = set()\n \n # Clear neurogenesis data\n if hasattr(brain_widget, 'neurogenesis_data'):\n brain_widget.neurogenesis_data = {\n 'new_neurons': [],\n 'new_neurons_details': {},\n 'new_synapses': []\n }\n \n # Clear enhanced neurogenesis tracking\n if hasattr(brain_widget, 'enhanced_neurogenesis'):\n brain_widget.enhanced_neurogenesis.reset_state()\n \n # Reset brain widget state\n if hasattr(brain_widget, 'state'):\n brain_widget.state = brain_widget.create_initial_state()\n \n # Clear hebbian learning state\n if hasattr(brain_widget, 'hebbian'):\n brain_widget.hebbian.reset()\n \n print(\"Brain state cleared\")\n \n # Clear all decorations and items from the scene\n if hasattr(self, 'user_interface') and hasattr(self.user_interface, 'scene'):\n # Remove all items except the background (if it exists)\n items_to_remove = []\n background_item = getattr(self.user_interface, 'background', None)\n \n for item in self.user_interface.scene.items():\n # Keep the background (if it exists) and remove everything else\n if background_item is None or item != background_item:\n items_to_remove.append(item)\n \n for item in items_to_remove:\n self.user_interface.scene.removeItem(item)\n \n # Clear decoration tracking\n if hasattr(self.user_interface, 'awarded_decorations'):\n self.user_interface.awarded_decorations = set()\n \n print(\"Scene cleared\")\n \n # Create new game (creates squid but not tamagotchi_logic)\n self.create_new_game(self.specified_personality)\n \n # Create TamagotchiLogic\n self.tamagotchi_logic = TamagotchiLogic(self.user_interface, self.squid, self.brain_window)\n \n # Update references\n self.squid.tamagotchi_logic = self.tamagotchi_logic\n self.user_interface.tamagotchi_logic = self.tamagotchi_logic\n self.brain_window.tamagotchi_logic = self.tamagotchi_logic\n if hasattr(self.brain_window, 'set_tamagotchi_logic'):\n self.brain_window.set_tamagotchi_logic(self.tamagotchi_logic)\n \n self.plugin_manager.tamagotchi_logic = self.tamagotchi_logic\n self.tamagotchi_logic.plugin_manager = self.plugin_manager\n \n # Create personality starter neuron if needed\n squid = self.tamagotchi_logic.squid\n brain_widget = self.brain_window.brain_widget\n if (squid and squid.personality and\n brain_widget and hasattr(brain_widget, 'enhanced_neurogenesis')):\n if not squid._has_personality_starter_neuron():\n neuron = brain_widget.enhanced_neurogenesis.create_personality_starter_neuron(\n squid.personality.value,\n brain_widget.state\n )\n if neuron:\n print(f\"🧬 Personality starter neuron created: {neuron}\")\n \n # Reload plugins to ensure they get the new tamagotchi_logic\n self.plugin_manager.reload_all_plugins()\n \n print(\"New game created successfully!\")\n\n def load_game(self):\n \"\"\"Delegate to tamagotchi_logic\"\"\"\n self.tamagotchi_logic.load_game()\n\n def save_game(self):\n \"\"\"Delegate to tamagotchi_logic\"\"\"\n if self.squid and self.tamagotchi_logic:\n self.tamagotchi_logic.save_game()\n\n def _restore_achievements_data(self, achievements_data):\n \"\"\"Restore achievement data to the achievements plugin after plugin reload.\n \n This is needed because plugin instances get replaced during initialization,\n discarding any previously loaded save data.\n \"\"\"\n if not achievements_data:\n return\n try:\n if 'achievements' in self.plugin_manager.plugins:\n plugin_info = self.plugin_manager.plugins['achievements']\n instance = plugin_info.get('instance')\n if instance and hasattr(instance, 'load_save_data'):\n instance.load_save_data(achievements_data)\n unlocked_count = len(achievements_data.get('unlocked', {}))\n print(f\"✓ Restored {unlocked_count} achievements\")\n except Exception as e:\n print(f\"[Warning] Could not restore achievements: {e}\")\n\n def closeEvent(self, event):\n \"\"\"Handle window close event\"\"\"\n # Save game before closing\n if hasattr(self, 'tamagotchi_logic') and self.tamagotchi_logic:\n self.save_game()\n \n # Stop the tamagotchi logic if it has a stop method\n if hasattr(self, 'tamagotchi_logic') and self.tamagotchi_logic:\n if hasattr(self.tamagotchi_logic, 'stop'):\n self.tamagotchi_logic.stop()\n # Stop the timer if it exists\n elif hasattr(self.tamagotchi_logic, 'timer') and self.tamagotchi_logic.timer:\n self.tamagotchi_logic.timer.stop()\n \n # Clean up brain state bridge for designer sync\n if hasattr(self, 'brain_window') and self.brain_window:\n if hasattr(self.brain_window, 'brain_widget') and self.brain_window.brain_widget:\n if hasattr(self.brain_window.brain_widget, 'cleanup_brain_bridge'):\n self.brain_window.brain_widget.cleanup_brain_bridge()\n \n # Close brain window\n if hasattr(self, 'brain_window') and self.brain_window:\n self.brain_window.close()\n \n event.accept()\n\n def show_splash_screen(self):\n \"\"\"Display splash screen animation with synchronized neuron reveal\"\"\"\n self.splash = SplashScreen(self)\n self.splash.finished.connect(self.start_simulation)\n self.splash.finished.connect(lambda: self.tamagotchi_logic.statistics_window.award(1000))\n self.splash.second_frame.connect(self.show_hatching_notification)\n\n # NEW: award 1000 points the instant the splash ends\n self.splash.finished.connect(\n lambda: self.tamagotchi_logic.statistics_window.award(1000)\n )\n\n # After splash ends, wait 3 s then show the normal feeding hint\n self.splash.finished.connect(lambda: QtCore.QTimer.singleShot(3000, self.show_feeding_hint))\n\n # Check if this is a brand new game (no save exists)\n is_new_game = not self.save_manager.save_exists()\n print(f\"🎮 show_splash_screen: is_new_game={is_new_game}, save_exists={self.save_manager.save_exists()}\")\n\n if is_new_game:\n # Ensure brain widget starts empty\n if hasattr(self.brain_window, 'brain_widget') and hasattr(self.brain_window.brain_widget, 'visible_neurons'):\n self.brain_window.brain_widget.visible_neurons = set()\n \n # Show brain window first\n self.brain_window.show()\n self.user_interface.brain_action.setChecked(True)\n \n # Force immediate processing to ensure brain window is painted\n QtWidgets.QApplication.processEvents()\n \n # Give the brain window time to fully render (longer delay)\n QtCore.QTimer.singleShot(1500, lambda: self._start_splash_with_reveals())\n else:\n # For loaded games, show brain window with all neurons visible\n if hasattr(self.brain_window, 'brain_widget') and hasattr(self.brain_window.brain_widget, 'visible_neurons'):\n brain_widget = self.brain_window.brain_widget\n # Add all core neurons to visible set\n for neuron_name in brain_widget.original_neurons:\n brain_widget.visible_neurons.add(neuron_name)\n \n # Also add any neurogenesis neurons that exist\n if hasattr(brain_widget, 'neurogenesis_data') and 'new_neurons_details' in brain_widget.neurogenesis_data:\n for neuron_name in brain_widget.neurogenesis_data['new_neurons_details'].keys():\n brain_widget.visible_neurons.add(neuron_name)\n \n # Show brain window immediately for loaded games\n self.brain_window.show()\n self.user_interface.brain_action.setChecked(True)\n \n # Force immediate processing to ensure brain window is painted\n QtWidgets.QApplication.processEvents()\n \n # Show splash normally (no animated reveals needed for loaded games)\n self.splash.show()\n QtCore.QTimer.singleShot(1000, self.splash.start_animation)\n\n\n def show_feeding_hint(self):\n \"\"\"Use the same strip as every other message.\"\"\"\n self.user_interface.show_message(\"Press D to open the Decorations window\")\n \n def _start_splash_with_reveals(self):\n \"\"\"Start splash screen with neuron reveal synchronization (called after brain window is ready)\"\"\"\n print(\" 🥚 A squid is hatching...\")\n \n # Connect frame changes to neuron reveals\n self.splash.frame_changed.connect(self._reveal_neuron_for_frame)\n \n # Show and start the splash screen animation\n self.splash.show()\n QtCore.QTimer.singleShot(500, self.splash.start_animation) # Small delay for splash to show\n\n def _reveal_neuron_for_frame(self, frame_index):\n \"\"\"Reveal core neurons in sequence with animation frames\"\"\"\n if not hasattr(self.brain_window, 'brain_widget'):\n return\n \n brain_widget = self.brain_window.brain_widget\n core_neurons = brain_widget.original_neurons\n \n # Distribution: 1-2 neurons per frame. Now revised for 8 core neurons (indices 0-7)\n reveal_map = {\n 0: [0], # First frame\n 1: [1], # Second frame\n 2: [2], # Third frame\n 3: [3], # Fourth frame\n 4: [4, 5], # Fifth frame\n 5: [6, 7] # Sixth frame\n }\n \n # Reveal mapped neurons for this frame\n for neuron_idx in reveal_map.get(frame_index, []):\n if neuron_idx < len(core_neurons):\n neuron_name = core_neurons[neuron_idx]\n brain_widget.reveal_neuron(neuron_name)\n #print(f\"🧠 Revealed neuron: {neuron_name} (frame {frame_index})\")\n\n def show_hatching_notification(self):\n \"\"\"Display hatching message\"\"\"\n self.user_interface.show_message(\"Squid is hatching!\")\n\n def start_simulation(self):\n \"\"\"Begin the simulation - brain window is already visible for new games\"\"\"\n self.cleanup_duplicate_squids()\n self.tamagotchi_logic.set_simulation_speed(1)\n self.tamagotchi_logic.start_autosave()\n\n # Get brain widget reference\n brain_widget = self.brain_window.brain_widget\n\n # Show tutorial if enabled\n if self.show_tutorial:\n QtCore.QTimer.singleShot(1000, self.user_interface.show_tutorial_overlay)\n else:\n # === FIX START: Manual cleanup if tutorial is skipped ===\n if hasattr(brain_widget, 'is_tutorial_mode'):\n # Set the flag to False, which allows connections to draw\n brain_widget.is_tutorial_mode = False \n \n # OPTIONAL: If setting the flag doesn't immediately refresh the links,\n # you may need to force a repaint. If the links are set to show,\n # a simple repaint will usually draw them once the block is gone.\n brain_widget.update() # Force repaint\n # === FIX END ===\n\n # Only open decoration window automatically (brain window already visible for new games)\n QtCore.QTimer.singleShot(500, self.position_and_show_decoration_window)\n\n def show_tutorial_overlay(self):\n \"\"\"Delegate to UI layer and ensure no duplicates remain\"\"\"\n # First do one more duplicate cleanup\n self.cleanup_duplicate_squids()\n \n # Then show the tutorial via the UI\n if hasattr(self, 'user_interface') and self.user_interface:\n self.user_interface.show_tutorial_overlay()\n\n def open_initial_windows(self):\n \"\"\"Open brain window and decorations window\"\"\"\n # Open brain window\n if hasattr(self, 'brain_window'):\n self.brain_window.show()\n self.user_interface.brain_action.setChecked(True)\n\n # Open decorations window\n if hasattr(self.user_interface, 'decoration_window'):\n self.position_and_show_decoration_window()\n self.user_interface.decorations_action.setChecked(True)\n\n def cleanup_duplicate_squids(self):\n \"\"\"Remove any duplicate squid items from the scene\"\"\"\n if not hasattr(self, 'user_interface') or not self.user_interface:\n return\n \n if not hasattr(self, 'squid') or not self.squid:\n return\n \n try:\n # Get the reference to our genuine squid item\n main_squid_item = self.squid.squid_item\n \n # Get all items in the scene\n all_items = self.user_interface.scene.items()\n \n # Track how many items we find and remove\n found_count = 0\n \n # Look for graphics items that could be duplicate squids\n for item in all_items:\n # Skip our genuine squid item\n if item == main_squid_item:\n continue\n \n # Only check QGraphicsPixmapItems\n if isinstance(item, QtWidgets.QGraphicsPixmapItem):\n # Check if it has the same pixmap dimensions as our squid\n if (hasattr(item, 'pixmap') and item.pixmap() and main_squid_item.pixmap() and\n item.pixmap().width() == main_squid_item.pixmap().width() and\n item.pixmap().height() == main_squid_item.pixmap().height()):\n print(f\"Found potential duplicate squid item - removing\")\n self.user_interface.scene.removeItem(item)\n found_count += 1\n \n if found_count > 0:\n print(f\"Cleaned up {found_count} duplicate squid items\")\n # Force scene update\n self.user_interface.scene.update()\n \n except Exception as e:\n print(f\"Error during cleanup: {str(e)}\")\n\n def initialize_multiplayer_manually(self):\n \"\"\"Manually initialize multiplayer plugin if needed\"\"\"\n try:\n # Import the plugin module directly\n import sys\n import os\n plugin_path = os.path.join(os.path.dirname(__file__), 'plugins', 'multiplayer')\n if plugin_path not in sys.path:\n sys.path.insert(0, plugin_path)\n \n import main as multiplayer_main\n \n # Create plugin instance\n multiplayer_plugin = multiplayer_main.MultiplayerPlugin()\n \n # Find it in plugin_manager and add the instance\n for plugin_name, plugin_data in self.plugin_manager.plugins.items():\n if plugin_name.lower() == \"multiplayer\":\n plugin_data['instance'] = multiplayer_plugin\n print(f\"Manually added multiplayer plugin instance to {plugin_name}\")\n \n # Initialize the plugin\n if hasattr(multiplayer_plugin, 'setup'):\n multiplayer_plugin.setup(self.plugin_manager)\n \n # Register menu actions\n if hasattr(multiplayer_plugin, 'register_menu_actions'):\n multiplayer_plugin.register_menu_actions()\n \n break\n \n # Force the UI to refresh plugin menu\n self.user_interface.setup_plugin_menu(self.plugin_manager)\n \n #print(\"Manual multiplayer initialization complete\")\n return True\n \n except Exception as e:\n print(f\"Error in manual multiplayer initialization: {e}\")\n import traceback\n traceback.print_exc()\n return False\n\ndef main():\n \"\"\"Main entry point\"\"\"\n # CRITICAL for PyInstaller + multiprocessing on Windows\n multiprocessing.freeze_support()\n \n sys.excepthook = global_exception_handler\n\n parser = argparse.ArgumentParser(description=\"Dosidicus digital squid with a neural network\")\n parser.add_argument('-p', '--personality', type=str, \n choices=[p.value for p in Personality], \n help='Specify squid personality')\n parser.add_argument('-d', '--debug', action='store_true', \n help='Enable debug mode with console logging')\n parser.add_argument('-nc', '--neurocooldown', type=int, \n help='Set neurogenesis cooldown in seconds')\n parser.add_argument('-c', '--clean', action='store_true',\n help='Clean __pycache__ and logs folders before starting')\n parser.add_argument('-designer', '--designer', action='store_true',\n help='Launch Brain Designer standalone')\n args = parser.parse_args()\n\n # Perform cleanup if requested before logging setup\n if args.clean:\n perform_cleanup_and_exit()\n\n # Launch designer if flag is set\n if args.designer:\n print(\"Launching Brain Designer standalone...\")\n try:\n # Import and run designer's main function\n try:\n from src import brain_designer\n except ImportError:\n import brain_designer\n \n # brain_designer.main() will parse sys.argv and handle -d and -c flags automatically\n brain_designer.main()\n except ImportError as e:\n print(f\"Error: Could not import brain_designer module: {e}\")\n sys.exit(1)\n except Exception as e:\n print(f\"Error launching designer: {e}\")\n sys.exit(1)\n return # Exit after designer closes\n\n # Initialize logging (replaces previous global setup)\n setup_logging_configuration()\n \n print(f\" Personality: {args.personality}\")\n print(f\" Debug mode: {args.debug}\")\n print(f\" Cooldown {args.neurocooldown or 'will be loaded from config'}\")\n\n app = QtWidgets.QApplication(sys.argv)\n \n try:\n personality = Personality(args.personality) if args.personality else None\n main_window = MainWindow(personality, args.debug, args.neurocooldown)\n main_window.show()\n sys.exit(app.exec_())\n except Exception as e:\n logging.exception(\"Fatal error in main\")\n QtWidgets.QMessageBox.critical(None, \"Error\", \n f\"Critical error: {str(e)}\\nSee dosidicus_log.txt for details.\")\n\nif __name__ == '__main__':\n main()"
},
{
"path": "plugins/achievements/__init__.py",
"content": ""
},
{
"path": "plugins/achievements/achievements_data.py",
"content": "# File: achievements_data.py\n# All achievement definitions for the Achievements Plugin\n# Separated from main.py for cleaner organization\n\nfrom dataclasses import dataclass, asdict\nfrom typing import Dict\nfrom enum import Enum\n\n\n# =============================================================================\n# ENUMS AND DATA CLASSES\n# =============================================================================\n\nclass AchievementCategory(Enum):\n FEEDING = \"feeding\"\n NEUROGENESIS = \"neurogenesis\"\n SLEEP = \"sleep\"\n MILESTONES = \"milestones\"\n EXPLORATION = \"exploration\"\n CLEANING = \"cleaning\"\n HEALTH = \"health\"\n INTERACTION = \"interaction\"\n INK = \"ink\"\n MEMORY = \"memory\"\n EMOTIONAL = \"emotional\"\n SECRET = \"secret\"\n META = \"meta\"\n\n\n@dataclass\nclass Achievement:\n id: str\n name: str # Now stores the localisation KEY\n description: str # Now stores the localisation KEY\n icon: str = \"🏆\"\n category: str = \"milestones\"\n hidden: bool = False\n points: int = 10\n tier: int = 1\n target_count: int = 1\n\n def to_dict(self) -> dict:\n return asdict(self)\n\n\n@dataclass\nclass UnlockedAchievement:\n achievement_id: str\n unlocked_at: str\n progress: int = 0\n notified: bool = False\n\n def to_dict(self) -> dict:\n return asdict(self)\n\n @classmethod\n def from_dict(cls, data: dict) -> 'UnlockedAchievement':\n return cls(**data)\n\n\n# Tier colors for UI\nTIER_COLORS = {\n 1: \"#CD7F32\", # Bronze\n 2: \"#C0C0C0\", # Silver\n 3: \"#FFD700\", # Gold\n 4: \"#E5E4E2\", # Platinum\n 5: \"#B9F2FF\", # Diamond\n}\n\n\n# =============================================================================\n# ALL ACHIEVEMENT DEFINITIONS (50+ achievements)\n# =============================================================================\n\nACHIEVEMENT_DEFINITIONS: Dict[str, Achievement] = {\n \n # =========================================================================\n # FEEDING CATEGORY (5)\n # =========================================================================\n \"first_feeding\": Achievement(\n id=\"first_feeding\", \n name=\"ach_first_feeding_name\",\n description=\"ach_first_feeding_desc\",\n icon=\"🍽️\", category=\"feeding\", points=10, tier=1,\n ),\n \"fed_10_times\": Achievement(\n id=\"fed_10_times\", \n name=\"ach_fed_10_times_name\",\n description=\"ach_fed_10_times_desc\",\n icon=\"🥄\", category=\"feeding\", points=15, tier=1, target_count=10,\n ),\n \"fed_50_times\": Achievement(\n id=\"fed_50_times\", \n name=\"ach_fed_50_times_name\",\n description=\"ach_fed_50_times_desc\",\n icon=\"🍴\", category=\"feeding\", points=25, tier=2, target_count=50,\n ),\n \"fed_100_times\": Achievement(\n id=\"fed_100_times\", \n name=\"ach_fed_100_times_name\",\n description=\"ach_fed_100_times_desc\",\n icon=\"👨🍳\", category=\"feeding\", points=50, tier=3, target_count=100,\n ),\n \"fed_500_times\": Achievement(\n id=\"fed_500_times\", \n name=\"ach_fed_500_times_name\",\n description=\"ach_fed_500_times_desc\",\n icon=\"🌟\", category=\"feeding\", points=100, tier=4, target_count=500, hidden=True,\n ),\n\n # =========================================================================\n # NEUROGENESIS CATEGORY (6)\n # =========================================================================\n \"first_neuron\": Achievement(\n id=\"first_neuron\", \n name=\"ach_first_neuron_name\",\n description=\"ach_first_neuron_desc\",\n icon=\"🧠\", category=\"neurogenesis\", points=20, tier=1,\n ),\n \"neurons_10\": Achievement(\n id=\"neurons_10\", \n name=\"ach_neurons_10_name\",\n description=\"ach_neurons_10_desc\",\n icon=\"🔮\", category=\"neurogenesis\", points=30, tier=2, target_count=10,\n ),\n \"neurons_50\": Achievement(\n id=\"neurons_50\", \n name=\"ach_neurons_50_name\",\n description=\"ach_neurons_50_desc\",\n icon=\"💫\", category=\"neurogenesis\", points=50, tier=3, target_count=50,\n ),\n \"neurons_100\": Achievement(\n id=\"neurons_100\", \n name=\"ach_neurons_100_name\",\n description=\"ach_neurons_100_desc\",\n icon=\"🌌\", category=\"neurogenesis\", points=75, tier=4, target_count=100, hidden=True,\n ),\n \"first_neuron_levelup\": Achievement(\n id=\"first_neuron_levelup\", \n name=\"ach_first_neuron_levelup_name\",\n description=\"ach_first_neuron_levelup_desc\",\n icon=\"⚡\", category=\"neurogenesis\", points=15, tier=1,\n ),\n \"neuron_max_level\": Achievement(\n id=\"neuron_max_level\", \n name=\"ach_neuron_max_level_name\",\n description=\"ach_neuron_max_level_desc\",\n icon=\"🌠\", category=\"neurogenesis\", points=40, tier=3,\n ),\n\n # =========================================================================\n # SLEEP CATEGORY (3)\n # =========================================================================\n \"first_sleep\": Achievement(\n id=\"first_sleep\", \n name=\"ach_first_sleep_name\",\n description=\"ach_first_sleep_desc\",\n icon=\"😴\", category=\"sleep\", points=10, tier=1,\n ),\n \"slept_10_times\": Achievement(\n id=\"slept_10_times\", \n name=\"ach_slept_10_times_name\",\n description=\"ach_slept_10_times_desc\",\n icon=\"🛏️\", category=\"sleep\", points=20, tier=2, target_count=10,\n ),\n \"dream_state\": Achievement(\n id=\"dream_state\", \n name=\"ach_dream_state_name\",\n description=\"ach_dream_state_desc\",\n icon=\"💭\", category=\"sleep\", points=25, tier=2, hidden=True,\n ),\n\n # =========================================================================\n # MILESTONES CATEGORY (6)\n # =========================================================================\n \"age_1_hour\": Achievement(\n id=\"age_1_hour\", \n name=\"ach_age_1_hour_name\",\n description=\"ach_age_1_hour_desc\",\n icon=\"⏰\", category=\"milestones\", points=15, tier=1,\n ),\n \"age_10_hours\": Achievement(\n id=\"age_10_hours\", \n name=\"ach_age_10_hours_name\",\n description=\"ach_age_10_hours_desc\",\n icon=\"📅\", category=\"milestones\", points=30, tier=2,\n ),\n \"age_24_hours\": Achievement(\n id=\"age_24_hours\", \n name=\"ach_age_24_hours_name\",\n description=\"ach_age_24_hours_desc\",\n icon=\"🎂\", category=\"milestones\", points=50, tier=3,\n ),\n \"age_1_week\": Achievement(\n id=\"age_1_week\", \n name=\"ach_age_1_week_name\",\n description=\"ach_age_1_week_desc\",\n icon=\"🏅\", category=\"milestones\", points=100, tier=4, hidden=True,\n ),\n \"age_1_month\": Achievement(\n id=\"age_1_month\", \n name=\"ach_age_1_month_name\",\n description=\"ach_age_1_month_desc\",\n icon=\"🎖️\", category=\"milestones\", points=150, tier=5, hidden=True,\n ),\n \"happiness_100\": Achievement(\n id=\"happiness_100\", \n name=\"ach_happiness_100_name\",\n description=\"ach_happiness_100_desc\",\n icon=\"😄\", category=\"milestones\", points=20, tier=2,\n ),\n \"all_stats_high\": Achievement(\n id=\"all_stats_high\", \n name=\"ach_all_stats_high_name\",\n description=\"ach_all_stats_high_desc\",\n icon=\"⚖️\", category=\"milestones\", points=40, tier=3,\n ),\n\n # =========================================================================\n # CLEANING CATEGORY (3)\n # =========================================================================\n \"first_clean\": Achievement(\n id=\"first_clean\", \n name=\"ach_first_clean_name\",\n description=\"ach_first_clean_desc\",\n icon=\"🧼\", category=\"cleaning\", points=10, tier=1,\n ),\n \"cleaned_25_times\": Achievement(\n id=\"cleaned_25_times\", \n name=\"ach_cleaned_25_times_name\",\n description=\"ach_cleaned_25_times_desc\",\n icon=\"✨\", category=\"cleaning\", points=25, tier=2, target_count=25,\n ),\n \"germaphobe\": Achievement(\n id=\"germaphobe\", \n name=\"ach_germaphobe_name\",\n description=\"ach_germaphobe_desc\",\n icon=\"🧹\", category=\"cleaning\", points=30, tier=2,\n ),\n\n # =========================================================================\n # HEALTH CATEGORY (3)\n # =========================================================================\n \"first_medicine\": Achievement(\n id=\"first_medicine\", \n name=\"ach_first_medicine_name\",\n description=\"ach_first_medicine_desc\",\n icon=\"💊\", category=\"health\", points=10, tier=1,\n ),\n \"medicine_10_times\": Achievement(\n id=\"medicine_10_times\", \n name=\"ach_medicine_10_times_name\",\n description=\"ach_medicine_10_times_desc\",\n icon=\"🩺\", category=\"health\", points=20, tier=2, target_count=10,\n ),\n \"comeback_kid\": Achievement(\n id=\"comeback_kid\", \n name=\"ach_comeback_kid_name\",\n description=\"ach_comeback_kid_desc\",\n icon=\"💪\", category=\"health\", points=40, tier=3, hidden=True,\n ),\n\n # =========================================================================\n # INTERACTION - ROCKS (6)\n # =========================================================================\n \"first_rock_pickup\": Achievement(\n id=\"first_rock_pickup\", \n name=\"ach_first_rock_pickup_name\",\n description=\"ach_first_rock_pickup_desc\",\n icon=\"🪨\", category=\"interaction\", points=10, tier=1,\n ),\n \"rocks_picked_10\": Achievement(\n id=\"rocks_picked_10\", \n name=\"ach_rocks_picked_10_name\",\n description=\"ach_rocks_picked_10_desc\",\n icon=\"⛰️\", category=\"interaction\", points=15, tier=1, target_count=10,\n ),\n \"rocks_picked_50\": Achievement(\n id=\"rocks_picked_50\", \n name=\"ach_rocks_picked_50_name\",\n description=\"ach_rocks_picked_50_desc\",\n icon=\"🏔️\", category=\"interaction\", points=30, tier=2, target_count=50,\n ),\n \"first_rock_throw\": Achievement(\n id=\"first_rock_throw\", \n name=\"ach_first_rock_throw_name\",\n description=\"ach_first_rock_throw_desc\",\n icon=\"🎯\", category=\"interaction\", points=10, tier=1,\n ),\n \"rocks_thrown_25\": Achievement(\n id=\"rocks_thrown_25\", \n name=\"ach_rocks_thrown_25_name\",\n description=\"ach_rocks_thrown_25_desc\",\n icon=\"🚀\", category=\"interaction\", points=20, tier=2, target_count=25,\n ),\n \"rocks_thrown_100\": Achievement(\n id=\"rocks_thrown_100\", \n name=\"ach_rocks_thrown_100_name\",\n description=\"ach_rocks_thrown_100_desc\",\n icon=\"💨\", category=\"interaction\", points=40, tier=3, target_count=100, hidden=True,\n ),\n\n # =========================================================================\n # INTERACTION - PLANTS & DECORATIONS (8)\n # =========================================================================\n \"first_decoration_push\": Achievement(\n id=\"first_decoration_push\", \n name=\"ach_first_decoration_push_name\",\n description=\"ach_first_decoration_push_desc\",\n icon=\"🪴\", category=\"interaction\", points=10, tier=1,\n ),\n \"decorations_pushed_10\": Achievement(\n id=\"decorations_pushed_10\", \n name=\"ach_decorations_pushed_10_name\",\n description=\"ach_decorations_pushed_10_desc\",\n icon=\"🏠\", category=\"interaction\", points=15, tier=1, target_count=10,\n ),\n \"decorations_pushed_50\": Achievement(\n id=\"decorations_pushed_50\", \n name=\"ach_decorations_pushed_50_name\",\n description=\"ach_decorations_pushed_50_desc\",\n icon=\"🎨\", category=\"interaction\", points=30, tier=2, target_count=50,\n ),\n \"first_plant_interact\": Achievement(\n id=\"first_plant_interact\", \n name=\"ach_first_plant_interact_name\",\n description=\"ach_first_plant_interact_desc\",\n icon=\"🌱\", category=\"interaction\", points=10, tier=1,\n ),\n \"plants_interacted_10\": Achievement(\n id=\"plants_interacted_10\", \n name=\"ach_plants_interacted_10_name\",\n description=\"ach_plants_interacted_10_desc\",\n icon=\"🌿\", category=\"interaction\", points=15, tier=1, target_count=10,\n ),\n \"plants_interacted_50\": Achievement(\n id=\"plants_interacted_50\", \n name=\"ach_plants_interacted_50_name\",\n description=\"ach_plants_interacted_50_desc\",\n icon=\"🌳\", category=\"interaction\", points=30, tier=2, target_count=50,\n ),\n \"objects_investigated_25\": Achievement(\n id=\"objects_investigated_25\", \n name=\"ach_objects_investigated_25_name\",\n description=\"ach_objects_investigated_25_desc\",\n icon=\"🔍\", category=\"interaction\", points=25, tier=2, target_count=25,\n ),\n \"objects_investigated_100\": Achievement(\n id=\"objects_investigated_100\", \n name=\"ach_objects_investigated_100_name\",\n description=\"ach_objects_investigated_100_desc\",\n icon=\"🕵️\", category=\"interaction\", points=50, tier=3, target_count=100,\n ),\n\n # =========================================================================\n # EXPLORATION - POOP (1)\n # =========================================================================\n \"first_poop_throw\": Achievement(\n id=\"first_poop_throw\", \n name=\"ach_first_poop_throw_name\",\n description=\"ach_first_poop_throw_desc\",\n icon=\"💩\", category=\"exploration\", points=10, tier=1,\n ),\n\n # =========================================================================\n # INK CATEGORY (2)\n # =========================================================================\n \"first_ink_cloud\": Achievement(\n id=\"first_ink_cloud\", \n name=\"ach_first_ink_cloud_name\",\n description=\"ach_first_ink_cloud_desc\",\n icon=\"🖤\", category=\"ink\", points=15, tier=1,\n ),\n \"ink_clouds_20\": Achievement(\n id=\"ink_clouds_20\", \n name=\"ach_ink_clouds_20_name\",\n description=\"ach_ink_clouds_20_desc\",\n icon=\"🌫️\", category=\"ink\", points=25, tier=2, target_count=20,\n ),\n\n # =========================================================================\n # MEMORY CATEGORY (3)\n # =========================================================================\n \"first_memory\": Achievement(\n id=\"first_memory\", \n name=\"ach_first_memory_name\",\n description=\"ach_first_memory_desc\",\n icon=\"💾\", category=\"memory\", points=15, tier=1,\n ),\n \"memory_long_term\": Achievement(\n id=\"memory_long_term\", \n name=\"ach_memory_long_term_name\",\n description=\"ach_memory_long_term_desc\",\n icon=\"🗄️\", category=\"memory\", points=25, tier=2,\n ),\n \"memories_50\": Achievement(\n id=\"memories_50\", \n name=\"ach_memories_50_name\",\n description=\"ach_memories_50_desc\",\n icon=\"📚\", category=\"memory\", points=40, tier=3, target_count=50,\n ),\n\n # =========================================================================\n # EMOTIONAL CATEGORY (4)\n # =========================================================================\n \"curiosity_100\": Achievement(\n id=\"curiosity_100\", \n name=\"ach_curiosity_100_name\",\n description=\"ach_curiosity_100_desc\",\n icon=\"🤔\", category=\"emotional\", points=15, tier=1,\n ),\n \"zen_master\": Achievement(\n id=\"zen_master\", \n name=\"ach_zen_master_name\",\n description=\"ach_zen_master_desc\",\n icon=\"🧘\", category=\"emotional\", points=30, tier=2,\n ),\n \"first_startle\": Achievement(\n id=\"first_startle\", \n name=\"ach_first_startle_name\",\n description=\"ach_first_startle_desc\",\n icon=\"😱\", category=\"emotional\", points=10, tier=1,\n ),\n \"nervous_wreck\": Achievement(\n id=\"nervous_wreck\", \n name=\"ach_nervous_wreck_name\",\n description=\"ach_nervous_wreck_desc\",\n icon=\"😰\", category=\"emotional\", points=15, tier=2, hidden=True,\n ),\n\n # =========================================================================\n # SECRET CATEGORY (3)\n # =========================================================================\n \"night_owl\": Achievement(\n id=\"night_owl\", \n name=\"ach_night_owl_name\",\n description=\"ach_night_owl_desc\",\n icon=\"🦉\", category=\"secret\", points=15, tier=2, hidden=True,\n ),\n \"early_bird\": Achievement(\n id=\"early_bird\", \n name=\"ach_early_bird_name\",\n description=\"ach_early_bird_desc\",\n icon=\"🐦\", category=\"secret\", points=15, tier=2, hidden=True,\n ),\n \"weekend_warrior\": Achievement(\n id=\"weekend_warrior\", \n name=\"ach_weekend_warrior_name\",\n description=\"ach_weekend_warrior_desc\",\n icon=\"🗓️\", category=\"secret\", points=20, tier=2, hidden=True,\n ),\n\n # =========================================================================\n # META CATEGORY (2)\n # =========================================================================\n \"brain_surgeon\": Achievement(\n id=\"brain_surgeon\", \n name=\"ach_brain_surgeon_name\",\n description=\"ach_brain_surgeon_desc\",\n icon=\"🔬\", category=\"meta\", points=10, tier=1,\n ),\n \"speed_demon\": Achievement(\n id=\"speed_demon\", \n name=\"ach_speed_demon_name\",\n description=\"ach_speed_demon_desc\",\n icon=\"⏩\", category=\"meta\", points=15, tier=2,\n ),\n \"completionist\": Achievement(\n id=\"completionist\", \n name=\"ach_completionist_name\",\n description=\"ach_completionist_desc\",\n icon=\"🏆\", category=\"meta\", points=100, tier=4, hidden=True,\n ),\n}\n\n\n# =============================================================================\n# HELPER FUNCTIONS\n# =============================================================================\n\ndef get_achievement(achievement_id: str) -> Achievement | None:\n \"\"\"Get an achievement by ID\"\"\"\n return ACHIEVEMENT_DEFINITIONS.get(achievement_id)\n\n\ndef get_achievements_by_category(category: str) -> Dict[str, Achievement]:\n \"\"\"Get all achievements in a specific category\"\"\"\n return {\n aid: ach for aid, ach in ACHIEVEMENT_DEFINITIONS.items()\n if ach.category == category\n }\n\n\ndef get_visible_achievements() -> Dict[str, Achievement]:\n \"\"\"Get all non-hidden achievements\"\"\"\n return {\n aid: ach for aid, ach in ACHIEVEMENT_DEFINITIONS.items()\n if not ach.hidden\n }\n\n\ndef get_total_points() -> int:\n \"\"\"Get total possible points from all achievements\"\"\"\n return sum(ach.points for ach in ACHIEVEMENT_DEFINITIONS.values())\n\n\ndef get_achievement_count() -> int:\n \"\"\"Get total number of achievements\"\"\"\n return len(ACHIEVEMENT_DEFINITIONS)"
},
{
"path": "plugins/achievements/display_scaling.py",
"content": "\"\"\"\r\nPortable copy of DisplayScaling plugins.\r\nKeep this file in the same folder as main.py\r\n\"\"\"\r\n\r\nimport re\r\n\r\nclass DisplayScaling:\r\n \"\"\"\r\n Utility class that computes a single scale-factor from the current\r\n screen resolution versus the design resolution (2880 × 1920).\r\n All UI measurements are then multiplied by this factor.\r\n \"\"\"\r\n\r\n DESIGN_WIDTH = 2880\r\n DESIGN_HEIGHT = 1920\r\n _scale_factor = 1.0\r\n\r\n @classmethod\r\n def initialize(cls, current_width: int, current_height: int) -> None:\r\n \"\"\"Call once after we know the real screen size.\"\"\"\r\n width_ratio = current_width / cls.DESIGN_WIDTH\r\n height_ratio = current_height / cls.DESIGN_HEIGHT\r\n base_scale = min(width_ratio, height_ratio)\r\n\r\n # Slightly smaller UI on 1080p screens\r\n if current_width <= 1920 and current_height <= 1080:\r\n cls._scale_factor = base_scale * 0.85\r\n else:\r\n cls._scale_factor = base_scale\r\n\r\n @classmethod\r\n def scale(cls, value: int | float) -> int:\r\n \"\"\"Scale an integer or float pixel value.\"\"\"\r\n return int(value * cls._scale_factor)\r\n\r\n @classmethod\r\n def font_size(cls, size: int) -> int:\r\n \"\"\"Return a font size guaranteed to be at least 8 pt.\"\"\"\r\n return max(8, cls.scale(size))\r\n\r\n @classmethod\r\n def get_scale_factor(cls) -> float:\r\n return cls._scale_factor\r\n\r\n @classmethod\r\n def scale_css(cls, css_string: str) -> str:\r\n \"\"\"Replace font-size:Xpx with scaled value inside a CSS snippet.\"\"\"\r\n pattern = r'font-size:\\s*(\\d+)px'\r\n def _repl(m: re.Match) -> str:\r\n return f\"font-size:{cls.font_size(int(m.group(1)))}px\"\r\n return re.sub(pattern, _repl, css_string)"
},
{
"path": "plugins/achievements/main.py",
"content": "import os\nimport json\nimport time\nimport logging\nfrom datetime import datetime\nfrom typing import Dict, List, Any, Optional\nfrom pathlib import Path\n\nfrom PyQt5 import QtCore, QtWidgets, QtGui\n\n# Import the local copy of DisplayScaling\nfrom .display_scaling import DisplayScaling as _DS\n\n# Increase the *nominal* sizes by ~1.4× (tweak multiplier to taste)\n_FONT_BOOST = 1.4\n\ndef _scale_size(pt: int) -> int:\n \"\"\"Return a bigger base size before DisplayScaling does its job.\"\"\"\n return int(pt * _FONT_BOOST)\n\n# Monkey-patch the local DisplayScaling.font_size so every caller\n# automatically gets the boosted value.\n_DS.font_size = lambda pt: max(8, _DS.scale(_scale_size(pt)))\n# Re-export the (now patched) class under its original name so UI code can see it\nDisplayScaling = _DS\n\n# Import achievement definitions from separate file\nfrom .achievements_data import (\n Achievement,\n UnlockedAchievement,\n AchievementCategory,\n ACHIEVEMENT_DEFINITIONS,\n TIER_COLORS,\n get_achievement,\n)\n\n# Import localisation\nfrom src import localisation \n\n# Assign the core translation function 't' from the imported module\n_t = localisation.loc\n\n# =============================================================================\n# PLUGIN METADATA - Required by PluginManager\n# =============================================================================\n\nPLUGIN_NAME = \"achievements\"\nPLUGIN_VERSION = \"2.1.0\" # Version bump for localisation support\nPLUGIN_AUTHOR = \"ViciousSquid\"\nPLUGIN_DESCRIPTION = \"Track milestones and unlock achievements as your squid grows\"\nPLUGIN_REQUIRES = [] # No dependencies\n\n# Default language setting (can be changed via main menu or config)\nLANGUAGE = \"en\" # Options: \"en\", \"es\", \"fr\"\nlocalisation.CURRENT_LANGUAGE = LANGUAGE\n\n\n# =============================================================================\n# UI COMPONENTS\n# =============================================================================\n\nclass AchievementNotification(QtWidgets.QWidget):\n \"\"\"Toast notification for achievement unlocks - LARGER VERSION with description\"\"\"\n\n def __init__(self, achievement: Achievement, parent=None):\n super().__init__(parent)\n self.achievement = achievement\n self._setup_ui()\n self._setup_animation()\n\n def _setup_ui(self):\n self.setWindowFlags(\n QtCore.Qt.FramelessWindowHint |\n QtCore.Qt.WindowStaysOnTopHint |\n QtCore.Qt.Tool\n )\n self.setAttribute(QtCore.Qt.WA_TranslucentBackground)\n \n # LARGER toast to fit description - increased height significantly\n self.setFixedSize(DisplayScaling.scale(520), DisplayScaling.scale(160))\n\n container = QtWidgets.QFrame(self)\n container.setFixedSize(DisplayScaling.scale(490), DisplayScaling.scale(145))\n container.move(DisplayScaling.scale(15), DisplayScaling.scale(7))\n\n # Simple dark rectangle background\n tier_color = TIER_COLORS.get(self.achievement.tier, \"#CD7F32\")\n container.setStyleSheet(\"\"\"\n QFrame {\n background: rgb(30, 30, 35);\n border: none;\n border-radius: 8px;\n }\n \"\"\")\n\n layout = QtWidgets.QHBoxLayout(container)\n layout.setContentsMargins(\n DisplayScaling.scale(16),\n DisplayScaling.scale(12),\n DisplayScaling.scale(16),\n DisplayScaling.scale(12)\n )\n layout.setSpacing(DisplayScaling.scale(14))\n\n # Icon - larger\n icon_label = QtWidgets.QLabel(self.achievement.icon)\n icon_label.setStyleSheet(f\"\"\"\n font-size: {DisplayScaling.font_size(52)}px; \n background: transparent; \n color: white;\n \"\"\")\n icon_label.setFixedWidth(DisplayScaling.scale(80))\n icon_label.setAlignment(QtCore.Qt.AlignCenter)\n layout.addWidget(icon_label)\n\n # Text section\n text_layout = QtWidgets.QVBoxLayout()\n text_layout.setSpacing(DisplayScaling.scale(4))\n\n # Header \"Achievement Unlocked!\"\n header = QtWidgets.QLabel(_t(\"ui_achievement_unlocked\"))\n header.setStyleSheet(f\"\"\"\n color: {tier_color}; \n font-size: {DisplayScaling.font_size(14)}px; \n font-weight: bold; \n background: transparent;\n \"\"\")\n text_layout.addWidget(header)\n\n # Achievement name - Translated\n name_label = QtWidgets.QLabel(_t(self.achievement.name))\n name_label.setStyleSheet(f\"\"\"\n color: white; \n font-size: {DisplayScaling.font_size(22)}px; \n font-weight: bold; \n background: transparent;\n \"\"\")\n text_layout.addWidget(name_label)\n\n # Achievement DESCRIPTION - Translated\n desc_label = QtWidgets.QLabel(_t(self.achievement.description))\n desc_label.setStyleSheet(f\"\"\"\n color: #cccccc; \n font-size: {DisplayScaling.font_size(13)}px; \n background: transparent;\n \"\"\")\n desc_label.setWordWrap(True)\n desc_label.setMaximumWidth(DisplayScaling.scale(320))\n text_layout.addWidget(desc_label)\n\n # Points earned\n points_label = QtWidgets.QLabel(f\"+{self.achievement.points} {_t('ui_points_gained')}\")\n points_label.setStyleSheet(f\"\"\"\n color: {tier_color}; \n font-size: {DisplayScaling.font_size(12)}px; \n font-weight: bold;\n background: transparent;\n \"\"\")\n text_layout.addWidget(points_label)\n\n layout.addLayout(text_layout)\n layout.addStretch()\n\n def _setup_animation(self):\n self.opacity_effect = QtWidgets.QGraphicsOpacityEffect(self)\n self.setGraphicsEffect(self.opacity_effect)\n\n self.fade_in = QtCore.QPropertyAnimation(self.opacity_effect, b\"opacity\")\n self.fade_in.setDuration(300)\n self.fade_in.setStartValue(0)\n self.fade_in.setEndValue(1)\n\n self.fade_out = QtCore.QPropertyAnimation(self.opacity_effect, b\"opacity\")\n self.fade_out.setDuration(500)\n self.fade_out.setStartValue(1)\n self.fade_out.setEndValue(0)\n self.fade_out.finished.connect(self.close)\n\n self.display_timer = QtCore.QTimer(self)\n self.display_timer.setSingleShot(True)\n self.display_timer.timeout.connect(self.fade_out.start)\n\n def show_notification(self, duration_ms=4000):\n self.show()\n self.fade_in.start()\n self.display_timer.start(duration_ms)\n\n\nclass AchievementsWindow(QtWidgets.QDialog):\n \"\"\"Window displaying all achievements\"\"\"\n\n def __init__(self, plugin: 'AchievementsPlugin', parent=None):\n super().__init__(parent)\n self.plugin = plugin\n self.setWindowTitle(f\"🏆 {PLUGIN_NAME}\")\n self.setMinimumSize(DisplayScaling.scale(550), DisplayScaling.scale(650))\n self._setup_ui()\n\n def _setup_ui(self):\n layout = QtWidgets.QVBoxLayout(self)\n\n # Header\n header = QtWidgets.QFrame()\n header.setStyleSheet(\"\"\"\n QFrame {\n background: qlineargradient(x1:0, y1:0, x2:1, y2:0,\n stop:0 #2c3e50, stop:1 #3498db);\n border-radius: 8px; padding: 10px;\n }\n \"\"\")\n header_layout = QtWidgets.QHBoxLayout(header)\n\n total_points = self.plugin.get_total_points()\n total_unlocked = len(self.plugin.unlocked)\n total_available = len([a for a in ACHIEVEMENT_DEFINITIONS.values() if not a.hidden])\n\n points_label = QtWidgets.QLabel(f\"🏆 {total_points} {_t('ui_points')}\")\n points_label.setStyleSheet(f\"color: gold; \"\n f\"font-size: {DisplayScaling.font_size(18)}px; \"\n f\"font-weight: bold;\")\n header_layout.addWidget(points_label)\n header_layout.addStretch()\n\n progress_label = QtWidgets.QLabel(f\"📊 {total_unlocked}/{total_available} {_t('ui_unlocked')}\")\n progress_label.setStyleSheet(f\"color: white; \"\n f\"font-size: {DisplayScaling.font_size(14)}px;\")\n header_layout.addWidget(progress_label)\n\n layout.addWidget(header)\n\n # Tabs\n tabs = QtWidgets.QTabWidget()\n tabs.addTab(self._create_list(None), _t(\"ui_all\"))\n for cat in AchievementCategory:\n cat_achievements = [a for a in ACHIEVEMENT_DEFINITIONS.values() if a.category == cat.value]\n if cat_achievements: # Only add tab if category has achievements\n # Use translated category name\n tabs.addTab(self._create_list(cat.value), _t(f\"cat_{cat.value}\"))\n layout.addWidget(tabs)\n\n def _create_list(self, category_filter: Optional[str]) -> QtWidgets.QScrollArea:\n scroll = QtWidgets.QScrollArea()\n scroll.setWidgetResizable(True)\n container = QtWidgets.QWidget()\n layout = QtWidgets.QVBoxLayout(container)\n layout.setSpacing(DisplayScaling.scale(8))\n\n unlocked_ids = set(self.plugin.unlocked.keys())\n\n for ach_id, ach in ACHIEVEMENT_DEFINITIONS.items():\n if category_filter and ach.category != category_filter:\n continue\n is_unlocked = ach_id in unlocked_ids\n if ach.hidden and not is_unlocked:\n continue\n\n card = self._create_card(ach, is_unlocked, self.plugin.progress.get(ach_id, 0))\n layout.addWidget(card)\n\n layout.addStretch()\n scroll.setWidget(container)\n return scroll\n\n def _create_card(self, ach: Achievement, unlocked: bool, progress: int) -> QtWidgets.QFrame:\n card = QtWidgets.QFrame()\n \n # 🌟 NEW Lighter Colors 🌟\n # Use the tier color for unlocked, or a light gray for locked.\n border_color = TIER_COLORS.get(ach.tier, \"#CD7F32\") if unlocked else \"#AAA\"\n # Use a very light, semi-transparent background for both.\n bg = \"rgba(255, 255, 255, 230)\" if unlocked else \"rgba(230, 230, 235, 200)\"\n\n card.setStyleSheet(f\"QFrame {{ background: {bg}; border: 2px solid {border_color}; border-radius: 8px; }}\")\n\n layout = QtWidgets.QHBoxLayout(card)\n\n # Icon styling - remains largely the same, but will appear clearer on the lighter background.\n icon = QtWidgets.QLabel(ach.icon if unlocked else \"🔒\")\n icon.setStyleSheet(f\"font-size: {DisplayScaling.font_size(28)}px;\")\n icon.setFixedWidth(DisplayScaling.scale(50))\n layout.addWidget(icon)\n\n info = QtWidgets.QVBoxLayout()\n \n # 🌟 NEW Name Text Color 🌟\n # Black for unlocked, Dark Gray for locked (easier to read on light BG)\n name_color = '#000' if unlocked else '#555' \n \n # Translate the name key\n display_name = _t(ach.name) if unlocked or not ach.hidden else \"???\"\n \n name = QtWidgets.QLabel(display_name)\n name.setStyleSheet(f\"color: {name_color}; \"\n f\"font-size: {DisplayScaling.font_size(14)}px; \"\n f\"font-weight: bold;\")\n info.addWidget(name)\n\n # 🌟 NEW Description Text Color 🌟\n # Dark Gray for unlocked, Medium Gray for locked (easier to read on light BG)\n desc_color = '#333' if unlocked else '#777'\n \n # Translate the description key\n display_desc = _t(ach.description) if unlocked or not ach.hidden else _t(\"ui_hidden\")\n \n desc = QtWidgets.QLabel(display_desc)\n desc.setStyleSheet(f\"color: {desc_color}; \"\n f\"font-size: {DisplayScaling.font_size(11)}px;\")\n desc.setWordWrap(True)\n info.addWidget(desc)\n\n # Progress bar logic remains the same\n if ach.target_count > 1 and not unlocked:\n pbar = QtWidgets.QProgressBar()\n pbar.setMaximum(ach.target_count)\n pbar.setValue(min(progress, ach.target_count))\n pbar.setFormat(f\"{progress}/{ach.target_count}\")\n pbar.setFixedHeight(DisplayScaling.scale(16))\n info.addWidget(pbar)\n\n layout.addLayout(info, 1)\n\n # Points color remains the tier color, which will stand out well.\n pts = QtWidgets.QLabel(f\"+{ach.points}\")\n pts.setStyleSheet(f\"color: {TIER_COLORS.get(ach.tier, '#CD7F32')}; \"\n f\"font-size: {DisplayScaling.font_size(12)}px; \"\n f\"font-weight: bold;\")\n layout.addWidget(pts)\n\n return card\n\n\n# =============================================================================\n# MAIN PLUGIN CLASS\n# =============================================================================\n\nclass AchievementsPlugin:\n \"\"\"Main achievements plugin class\"\"\"\n\n def __init__(self):\n self.logger = None\n self.plugin_manager = None\n self.tamagotchi_logic = None\n self.squid = None\n\n self.unlocked: Dict[str, UnlockedAchievement] = {}\n self.progress: Dict[str, int] = {}\n self.statistics: Dict[str, int] = {}\n\n # Timers\n self.age_check_timer: Optional[QtCore.QTimer] = None\n self.stat_check_timer: Optional[QtCore.QTimer] = None\n self.notification_timer: Optional[QtCore.QTimer] = None\n self.notification_queue: List[Achievement] = []\n self.current_notification: Optional[AchievementNotification] = None\n\n # Tracking for timed achievements\n self.cleanliness_high_since: Optional[float] = None # For germaphobe\n self.anxiety_low_since: Optional[float] = None # For zen_master\n self.max_speed_since: Optional[float] = None # For speed_demon\n self.health_was_critical: bool = False # For comeback_kid\n self.weekend_saturday: bool = False # For weekend_warrior\n self.weekend_sunday: bool = False\n\n self.parent_window: Optional[QtWidgets.QMainWindow] = None\n self.is_setup = False\n self.debug_mode = False\n self._original_methods: Dict[str, Any] = {}\n\n # ----------------------------------------------------------\n # Write unlock to text file only\n # ----------------------------------------------------------\n def _log_unlock_to_text_file(self, ach: Achievement) -> None:\n \"\"\"Append 'ID | long-date | HHMMSS | name' to achievements_log.txt\"\"\"\n try:\n log_path = Path(self._get_save_path()).with_name(\"achievements_log.txt\")\n time_stamp = datetime.now().strftime(\"%A, %B %d, %Y @ %H%M%S\")\n # Translate name for log file using current language\n translated_name = _t(ach.name)\n line = f\"{ach.id} | {time_stamp} | {translated_name}\\n\"\n with log_path.open(\"a\", encoding=\"utf-8\") as fh:\n fh.write(line)\n except Exception as e:\n if self.logger:\n self.logger.warning(f\"Could not write achievement log: {e}\")\n\n def setup(self, plugin_manager, tamagotchi_logic) -> bool:\n \"\"\"Called by PluginManager when enabling the plugin\"\"\"\n self.plugin_manager = plugin_manager\n self.tamagotchi_logic = tamagotchi_logic\n\n # Setup logger\n if hasattr(plugin_manager, 'logger'):\n self.logger = plugin_manager.logger.getChild(PLUGIN_NAME)\n else:\n self.logger = logging.getLogger(f\"{PLUGIN_NAME}_Plugin\")\n if not self.logger.handlers:\n handler = logging.StreamHandler()\n handler.setFormatter(logging.Formatter('%(levelname)s:%(name)s: %(message)s'))\n self.logger.addHandler(handler)\n self.logger.setLevel(logging.INFO)\n\n self.logger.info(f\"Setting up {PLUGIN_NAME}...\")\n\n # Get squid reference\n if tamagotchi_logic and hasattr(tamagotchi_logic, 'squid'):\n self.squid = tamagotchi_logic.squid\n self.logger.info(f\"Got squid reference: {self.squid}\")\n\n # Get parent window\n if tamagotchi_logic and hasattr(tamagotchi_logic, 'user_interface'):\n ui = tamagotchi_logic.user_interface\n if hasattr(ui, 'window'):\n self.parent_window = ui.window\n elif isinstance(ui, QtWidgets.QMainWindow):\n self.parent_window = ui\n\n self.debug_mode = getattr(tamagotchi_logic, 'debug_mode', False)\n\n # Setup timers\n self._setup_timers()\n\n # Subscribe to plugin manager hooks\n self._subscribe_to_hooks()\n\n # Also try direct method hooks as backup\n self._install_hooks()\n\n self.is_setup = True\n self.logger.info(f\"{PLUGIN_NAME} setup complete. {len(self.unlocked)} achievements loaded.\")\n return True\n\n def _subscribe_to_hooks(self):\n \"\"\"Subscribe to plugin manager hooks for event tracking\"\"\"\n if not self.plugin_manager:\n if self.logger:\n self.logger.warning(\"No plugin_manager, cannot subscribe to hooks\")\n return\n \n hook_subscriptions = [\n # Original hooks\n (\"on_feed\", self._hook_on_feed),\n (\"on_wake\", self._hook_on_wake),\n (\"on_sleep\", self._hook_on_sleep),\n (\"on_neurogenesis\", self._hook_on_neurogenesis),\n # New hooks for expanded achievements\n (\"on_clean\", self._hook_on_clean),\n (\"on_medicine\", self._hook_on_medicine),\n (\"on_rock_pickup\", self._hook_on_rock_pickup),\n (\"on_rock_throw\", self._hook_on_rock_throw),\n (\"on_decoration_interaction\", self._hook_on_decoration_interaction),\n (\"on_ink_cloud\", self._hook_on_ink_cloud),\n (\"on_startle\", self._hook_on_startle),\n (\"on_memory_created\", self._hook_on_memory_created),\n (\"on_memory_to_long_term\", self._hook_on_memory_to_long_term),\n (\"on_curiosity_change\", self._hook_on_curiosity_change),\n (\"on_anxiety_change\", self._hook_on_anxiety_change),\n (\"on_speed_change\", self._hook_on_speed_change),\n ]\n \n for hook_name, callback in hook_subscriptions:\n try:\n if hasattr(self.plugin_manager, 'subscribe_to_hook'):\n result = self.plugin_manager.subscribe_to_hook(hook_name, PLUGIN_NAME, callback)\n if self.logger:\n self.logger.debug(f\"Subscribed to hook '{hook_name}': {result}\")\n except Exception as e:\n if self.logger:\n self.logger.warning(f\"Could not subscribe to hook '{hook_name}': {e}\")\n\n # ----------------------------------------------------------\n # Hook Callbacks\n # ----------------------------------------------------------\n \n def _hook_on_feed(self, **kwargs):\n self.on_squid_fed()\n\n def _hook_on_wake(self, **kwargs):\n self.on_squid_woke()\n\n def _hook_on_sleep(self, **kwargs):\n pass # Sleep achievement triggers on wake\n\n def _hook_on_neurogenesis(self, **kwargs):\n self.on_neuron_created()\n\n def _hook_on_clean(self, **kwargs):\n self.on_tank_cleaned()\n\n def _hook_on_medicine(self, **kwargs):\n self.on_medicine_given()\n\n def _hook_on_rock_pickup(self, **kwargs):\n self.on_rock_picked_up()\n\n def _hook_on_rock_throw(self, **kwargs):\n self.on_rock_thrown()\n\n def _hook_on_decoration_interaction(self, **kwargs):\n decoration = kwargs.get('decoration')\n interaction_type = kwargs.get('type', 'push')\n self.on_decoration_interacted(decoration, interaction_type)\n\n def _hook_on_ink_cloud(self, **kwargs):\n self.on_ink_cloud_released()\n\n def _hook_on_startle(self, **kwargs):\n self.on_squid_startled()\n\n def _hook_on_memory_created(self, **kwargs):\n self.on_memory_formed()\n\n def _hook_on_memory_to_long_term(self, **kwargs):\n self.on_memory_promoted()\n\n def _hook_on_curiosity_change(self, **kwargs):\n new_value = kwargs.get('new_value', 0)\n if new_value >= 100:\n self.unlock_achievement(\"curiosity_100\")\n\n def _hook_on_anxiety_change(self, **kwargs):\n new_value = kwargs.get('new_value', 0)\n if new_value >= 100:\n self.unlock_achievement(\"nervous_wreck\")\n # Track for zen_master\n if new_value < 10:\n if self.anxiety_low_since is None:\n self.anxiety_low_since = time.time()\n else:\n self.anxiety_low_since = None\n\n def _hook_on_speed_change(self, **kwargs):\n speed = kwargs.get('speed', 1)\n max_speed = kwargs.get('max_speed', 4)\n if speed >= max_speed:\n if self.max_speed_since is None:\n self.max_speed_since = time.time()\n else:\n self.max_speed_since = None\n\n # ----------------------------------------------------------\n # Event Handlers\n # ----------------------------------------------------------\n\n def on_squid_fed(self):\n self._increment_stat(\"times_fed\")\n count = self.statistics.get(\"times_fed\", 0)\n if count == 1:\n self.unlock_achievement(\"first_feeding\")\n if count >= 10:\n self.unlock_achievement(\"fed_10_times\")\n if count >= 50:\n self.unlock_achievement(\"fed_50_times\")\n if count >= 100:\n self.unlock_achievement(\"fed_100_times\")\n if count >= 500:\n self.unlock_achievement(\"fed_500_times\")\n for aid in [\"fed_10_times\", \"fed_50_times\", \"fed_100_times\", \"fed_500_times\"]:\n self._update_progress(aid, count)\n\n def on_squid_woke(self):\n self._increment_stat(\"times_slept\")\n count = self.statistics.get(\"times_slept\", 0)\n if count == 1:\n self.unlock_achievement(\"first_sleep\")\n if count >= 10:\n self.unlock_achievement(\"slept_10_times\")\n self._update_progress(\"slept_10_times\", count)\n\n def on_neuron_created(self):\n self._increment_stat(\"neurons_created\")\n count = self.statistics.get(\"neurons_created\", 0)\n if count == 1:\n self.unlock_achievement(\"first_neuron\")\n if count >= 10:\n self.unlock_achievement(\"neurons_10\")\n if count >= 50:\n self.unlock_achievement(\"neurons_50\")\n if count >= 100:\n self.unlock_achievement(\"neurons_100\")\n self._update_progress(\"neurons_10\", count)\n self._update_progress(\"neurons_50\", count)\n self._update_progress(\"neurons_100\", count)\n\n def on_neuron_leveled(self):\n self._increment_stat(\"neurons_leveled\")\n if self.statistics.get(\"neurons_leveled\", 0) == 1:\n self.unlock_achievement(\"first_neuron_levelup\")\n\n def on_poop_thrown(self):\n self._increment_stat(\"poops_thrown\")\n if self.statistics.get(\"poops_thrown\", 0) == 1:\n self.unlock_achievement(\"first_poop_throw\")\n\n def on_tank_cleaned(self):\n self._increment_stat(\"times_cleaned\")\n count = self.statistics.get(\"times_cleaned\", 0)\n if count == 1:\n self.unlock_achievement(\"first_clean\")\n if count >= 25:\n self.unlock_achievement(\"cleaned_25_times\")\n self._update_progress(\"cleaned_25_times\", count)\n\n def on_medicine_given(self):\n self._increment_stat(\"times_medicated\")\n count = self.statistics.get(\"times_medicated\", 0)\n if count == 1:\n self.unlock_achievement(\"first_medicine\")\n if count >= 10:\n self.unlock_achievement(\"medicine_10_times\")\n self._update_progress(\"medicine_10_times\", count)\n \n # Check for comeback_kid - track if health was critical before medicine\n if self.health_was_critical and self.squid:\n health = getattr(self.squid, 'health', 100)\n if health >= 100:\n self.unlock_achievement(\"comeback_kid\")\n self.health_was_critical = False\n\n def on_rock_picked_up(self):\n self._increment_stat(\"rocks_picked\")\n count = self.statistics.get(\"rocks_picked\", 0)\n if count == 1:\n self.unlock_achievement(\"first_rock_pickup\")\n if count >= 10:\n self.unlock_achievement(\"rocks_picked_10\")\n if count >= 50:\n self.unlock_achievement(\"rocks_picked_50\")\n self._update_progress(\"rocks_picked_10\", count)\n self._update_progress(\"rocks_picked_50\", count)\n # Also count as object investigated\n self._on_object_investigated()\n\n def on_rock_thrown(self):\n self._increment_stat(\"rocks_thrown\")\n count = self.statistics.get(\"rocks_thrown\", 0)\n if count == 1:\n self.unlock_achievement(\"first_rock_throw\")\n if count >= 25:\n self.unlock_achievement(\"rocks_thrown_25\")\n if count >= 100:\n self.unlock_achievement(\"rocks_thrown_100\")\n self._update_progress(\"rocks_thrown_25\", count)\n self._update_progress(\"rocks_thrown_100\", count)\n\n def on_decoration_interacted(self, decoration=None, interaction_type='push'):\n \"\"\"Handle decoration interactions (push, investigate, etc.)\"\"\"\n # Track push interactions\n if interaction_type == 'push':\n self._increment_stat(\"decorations_pushed\")\n count = self.statistics.get(\"decorations_pushed\", 0)\n if count == 1:\n self.unlock_achievement(\"first_decoration_push\")\n if count >= 10:\n self.unlock_achievement(\"decorations_pushed_10\")\n if count >= 50:\n self.unlock_achievement(\"decorations_pushed_50\")\n self._update_progress(\"decorations_pushed_10\", count)\n self._update_progress(\"decorations_pushed_50\", count)\n \n # Track plant-specific interactions\n if decoration and hasattr(decoration, 'category'):\n if decoration.category == 'plant':\n self._increment_stat(\"plants_interacted\")\n count = self.statistics.get(\"plants_interacted\", 0)\n if count == 1:\n self.unlock_achievement(\"first_plant_interact\")\n if count >= 10:\n self.unlock_achievement(\"plants_interacted_10\")\n if count >= 50:\n self.unlock_achievement(\"plants_interacted_50\")\n self._update_progress(\"plants_interacted_10\", count)\n self._update_progress(\"plants_interacted_50\", count)\n \n # Count as object investigated\n self._on_object_investigated()\n\n def _on_object_investigated(self):\n \"\"\"Track unique object investigations\"\"\"\n self._increment_stat(\"objects_investigated\")\n count = self.statistics.get(\"objects_investigated\", 0)\n if count >= 25:\n self.unlock_achievement(\"objects_investigated_25\")\n if count >= 100:\n self.unlock_achievement(\"objects_investigated_100\")\n self._update_progress(\"objects_investigated_25\", count)\n self._update_progress(\"objects_investigated_100\", count)\n\n def on_ink_cloud_released(self):\n self._increment_stat(\"ink_clouds\")\n count = self.statistics.get(\"ink_clouds\", 0)\n if count == 1:\n self.unlock_achievement(\"first_ink_cloud\")\n if count >= 20:\n self.unlock_achievement(\"ink_clouds_20\")\n self._update_progress(\"ink_clouds_20\", count)\n\n def on_squid_startled(self):\n self._increment_stat(\"times_startled\")\n if self.statistics.get(\"times_startled\", 0) == 1:\n self.unlock_achievement(\"first_startle\")\n\n def on_memory_formed(self):\n self._increment_stat(\"memories_formed\")\n count = self.statistics.get(\"memories_formed\", 0)\n if count == 1:\n self.unlock_achievement(\"first_memory\")\n if count >= 50:\n self.unlock_achievement(\"memories_50\")\n self._update_progress(\"memories_50\", count)\n\n def on_memory_promoted(self):\n self._increment_stat(\"memories_promoted\")\n if self.statistics.get(\"memories_promoted\", 0) == 1:\n self.unlock_achievement(\"memory_long_term\")\n\n def on_brain_tool_opened(self):\n \"\"\"Called when brain visualization is opened\"\"\"\n if \"brain_surgeon\" not in self.unlocked:\n self.unlock_achievement(\"brain_surgeon\")\n\n # ----------------------------------------------------------\n # Periodic Checks\n # ----------------------------------------------------------\n\n def _check_age_achievements(self):\n if not self.squid:\n return\n age_hours = 0\n if hasattr(self.squid, 'birth_time'):\n age_hours = (time.time() - self.squid.birth_time) / 3600\n elif hasattr(self.squid, 'age_hours'):\n age_hours = self.squid.age_hours\n\n if age_hours >= 1:\n self.unlock_achievement(\"age_1_hour\")\n if age_hours >= 10:\n self.unlock_achievement(\"age_10_hours\")\n if age_hours >= 24:\n self.unlock_achievement(\"age_24_hours\")\n if age_hours >= 168: # 1 week\n self.unlock_achievement(\"age_1_week\")\n if age_hours >= 720: # 30 days\n self.unlock_achievement(\"age_1_month\")\n\n # Time-of-day achievements\n hour = datetime.now().hour\n if 0 <= hour < 4:\n self.unlock_achievement(\"night_owl\")\n if 5 <= hour < 7:\n self.unlock_achievement(\"early_bird\")\n \n # Weekend warrior\n day = datetime.now().weekday()\n if day == 5: # Saturday\n self.weekend_saturday = True\n elif day == 6: # Sunday\n self.weekend_sunday = True\n if self.weekend_saturday and self.weekend_sunday:\n self.unlock_achievement(\"weekend_warrior\")\n\n def _check_stat_achievements(self):\n if not self.squid:\n return\n \n # Happiness\n if hasattr(self.squid, 'happiness') and self.squid.happiness >= 100:\n self.unlock_achievement(\"happiness_100\")\n\n # All stats high\n stats = ['happiness', 'hunger', 'energy', 'health']\n all_high = all(getattr(self.squid, s, 0) >= 80 for s in stats if hasattr(self.squid, s))\n if all_high:\n self.unlock_achievement(\"all_stats_high\")\n \n # Check health for comeback_kid tracking\n if hasattr(self.squid, 'health'):\n if self.squid.health < 20:\n self.health_was_critical = True\n elif self.squid.health >= 100 and self.health_was_critical:\n self.unlock_achievement(\"comeback_kid\")\n self.health_was_critical = False\n \n # Cleanliness tracking for germaphobe\n if hasattr(self.squid, 'cleanliness'):\n if self.squid.cleanliness >= 90:\n if self.cleanliness_high_since is None:\n self.cleanliness_high_since = time.time()\n elif time.time() - self.cleanliness_high_since >= 3600: # 1 hour\n self.unlock_achievement(\"germaphobe\")\n else:\n self.cleanliness_high_since = None\n \n # Anxiety tracking for zen_master\n if hasattr(self.squid, 'anxiety'):\n if self.squid.anxiety < 10:\n if self.anxiety_low_since is None:\n self.anxiety_low_since = time.time()\n elif time.time() - self.anxiety_low_since >= 1800: # 30 minutes\n self.unlock_achievement(\"zen_master\")\n else:\n self.anxiety_low_since = None\n \n # Speed demon check\n if self.max_speed_since is not None:\n if time.time() - self.max_speed_since >= 600: # 10 minutes\n self.unlock_achievement(\"speed_demon\")\n \n # Completionist check\n unlocked_count = len(self.unlocked)\n if \"completionist\" not in self.unlocked and unlocked_count >= 30:\n self.unlock_achievement(\"completionist\")\n\n # ----------------------------------------------------------\n # Core Methods\n # ----------------------------------------------------------\n\n def unlock_achievement(self, achievement_id: str, silent: bool = False) -> bool:\n if achievement_id in self.unlocked:\n return False\n if achievement_id not in ACHIEVEMENT_DEFINITIONS:\n return False\n\n ach = ACHIEVEMENT_DEFINITIONS[achievement_id]\n if ach.target_count > 1 and self.progress.get(achievement_id, 0) < ach.target_count:\n return False\n\n self.unlocked[achievement_id] = UnlockedAchievement(\n achievement_id=achievement_id,\n unlocked_at=datetime.now().isoformat(),\n progress=ach.target_count,\n notified=silent\n )\n\n # Log with translated name for console/logger (optional, or keep English)\n if self.logger:\n # Using English key here might be safer for logs, or translated:\n self.logger.info(f\"🏆 Unlocked: {_t(ach.name)}\")\n\n self._log_unlock_to_text_file(ach)\n\n if not silent:\n self._queue_notification(ach)\n\n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'show_message'):\n self.tamagotchi_logic.show_message(f\"🏆\")\n\n return True\n\n def manually_trigger(self, event_name: str):\n handlers = {\n \"fed\": self.on_squid_fed,\n \"woke\": self.on_squid_woke,\n \"neuron_created\": self.on_neuron_created,\n \"neuron_leveled\": self.on_neuron_leveled,\n \"poop_thrown\": self.on_poop_thrown,\n \"cleaned\": self.on_tank_cleaned,\n \"medicine\": self.on_medicine_given,\n \"rock_pickup\": self.on_rock_picked_up,\n \"rock_throw\": self.on_rock_thrown,\n \"ink_cloud\": self.on_ink_cloud_released,\n \"startle\": self.on_squid_startled,\n \"memory_formed\": self.on_memory_formed,\n \"memory_promoted\": self.on_memory_promoted,\n \"brain_opened\": self.on_brain_tool_opened,\n \"neuron_max_level\": lambda: self.unlock_achievement(\"neuron_max_level\"),\n \"dream_state\": lambda: self.unlock_achievement(\"dream_state\"),\n }\n if event_name in handlers:\n handlers[event_name]()\n else:\n self.unlock_achievement(event_name)\n\n def get_total_points(self) -> int:\n return sum(\n ACHIEVEMENT_DEFINITIONS[a.achievement_id].points\n for a in self.unlocked.values()\n if a.achievement_id in ACHIEVEMENT_DEFINITIONS\n )\n\n def _increment_stat(self, name: str, amount: int = 1):\n self.statistics[name] = self.statistics.get(name, 0) + amount\n\n def _update_progress(self, achievement_id: str, value: int):\n self.progress[achievement_id] = value\n\n # ----------------------------------------------------------\n # Notifications\n # ----------------------------------------------------------\n\n def _queue_notification(self, achievement: Achievement):\n self.notification_queue.append(achievement)\n if not self.notification_timer.isActive():\n self._show_next_notification()\n\n def _show_next_notification(self):\n if self.current_notification:\n self.current_notification.close()\n self.current_notification = None\n\n if not self.notification_queue:\n self.notification_timer.stop()\n return\n\n ach = self.notification_queue.pop(0)\n self.current_notification = AchievementNotification(ach, self.parent_window)\n\n if self.parent_window:\n geo = self.parent_window.geometry()\n x = geo.x() + DisplayScaling.scale(20)\n y = geo.y() + DisplayScaling.scale(20)\n self.current_notification.move(x, y)\n\n self.current_notification.show_notification()\n\n if self.notification_queue:\n self.notification_timer.start(4500) # Slightly longer for reading description\n\n # ----------------------------------------------------------\n # Timers & Hooks Setup\n # ----------------------------------------------------------\n\n def _setup_timers(self):\n self.age_check_timer = QtCore.QTimer()\n self.age_check_timer.timeout.connect(self._check_age_achievements)\n\n self.stat_check_timer = QtCore.QTimer()\n self.stat_check_timer.timeout.connect(self._check_stat_achievements)\n\n self.notification_timer = QtCore.QTimer()\n self.notification_timer.timeout.connect(self._show_next_notification)\n\n def _install_hooks(self):\n \"\"\"Hook into game events via method wrapping\"\"\"\n if self.logger:\n self.logger.info(f\"Installing hooks... squid={self.squid is not None}\")\n \n if not self.squid:\n if self.logger:\n self.logger.warning(\"Cannot install hooks: squid is None\")\n return\n\n hooks_installed = []\n \n try:\n # Hook squid.eat\n if hasattr(self.squid, 'eat') and 'eat' not in self._original_methods:\n self._original_methods['eat'] = self.squid.eat\n original_eat = self._original_methods['eat']\n plugin_self = self\n \n def hooked_eat(*args, **kwargs):\n result = original_eat(*args, **kwargs)\n try:\n plugin_self.on_squid_fed()\n except Exception as e:\n if plugin_self.logger:\n plugin_self.logger.error(f\"Error in on_squid_fed: {e}\")\n return result\n \n self.squid.eat = hooked_eat\n hooks_installed.append('eat')\n\n # Hook squid.wake_up\n if hasattr(self.squid, 'wake_up') and 'wake_up' not in self._original_methods:\n self._original_methods['wake_up'] = self.squid.wake_up\n original_wake = self._original_methods['wake_up']\n plugin_self = self\n \n def hooked_wake(*args, **kwargs):\n result = original_wake(*args, **kwargs)\n try:\n plugin_self.on_squid_woke()\n except Exception as e:\n if plugin_self.logger:\n plugin_self.logger.error(f\"Error in on_squid_woke: {e}\")\n return result\n \n self.squid.wake_up = hooked_wake\n hooks_installed.append('wake_up')\n\n # Hook neurogenesis\n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'neurogenesis_system'):\n ng = self.tamagotchi_logic.neurogenesis_system\n if ng and hasattr(ng, 'create_neuron') and 'create_neuron' not in self._original_methods:\n self._original_methods['create_neuron'] = ng.create_neuron\n original_create = self._original_methods['create_neuron']\n plugin_self = self\n \n def hooked_create(*args, **kwargs):\n result = original_create(*args, **kwargs)\n if result:\n try:\n plugin_self.on_neuron_created()\n except Exception as e:\n if plugin_self.logger:\n plugin_self.logger.error(f\"Error in on_neuron_created: {e}\")\n return result\n \n ng.create_neuron = hooked_create\n hooks_installed.append('create_neuron')\n\n # Hook poop throwing\n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'poop_manager'):\n pm = self.tamagotchi_logic.poop_manager\n if pm and hasattr(pm, 'throw_poop') and 'throw_poop' not in self._original_methods:\n self._original_methods['throw_poop'] = pm.throw_poop\n original_throw = self._original_methods['throw_poop']\n plugin_self = self\n \n def hooked_throw(*args, **kwargs):\n result = original_throw(*args, **kwargs)\n if result:\n try:\n plugin_self.on_poop_thrown()\n except Exception as e:\n if plugin_self.logger:\n plugin_self.logger.error(f\"Error in on_poop_thrown: {e}\")\n return result\n \n pm.throw_poop = hooked_throw\n hooks_installed.append('throw_poop')\n\n # Hook push_decoration on squid\n if hasattr(self.squid, 'push_decoration') and 'push_decoration' not in self._original_methods:\n self._original_methods['push_decoration'] = self.squid.push_decoration\n original_push = self._original_methods['push_decoration']\n plugin_self = self\n \n def hooked_push(decoration, direction):\n result = original_push(decoration, direction)\n try:\n plugin_self.on_decoration_interacted(decoration, 'push')\n except Exception as e:\n if plugin_self.logger:\n plugin_self.logger.error(f\"Error in on_decoration_interacted: {e}\")\n return result\n \n self.squid.push_decoration = hooked_push\n hooks_installed.append('push_decoration')\n\n if self.logger:\n self.logger.info(f\"Hooks installed: {hooks_installed}\")\n\n except Exception as e:\n if self.logger:\n self.logger.error(f\"Error installing hooks: {e}\", exc_info=True)\n\n def _uninstall_hooks(self):\n try:\n if 'eat' in self._original_methods and self.squid:\n self.squid.eat = self._original_methods['eat']\n if 'wake_up' in self._original_methods and self.squid:\n self.squid.wake_up = self._original_methods['wake_up']\n if 'push_decoration' in self._original_methods and self.squid:\n self.squid.push_decoration = self._original_methods['push_decoration']\n except:\n pass\n self._original_methods.clear()\n\n # ----------------------------------------------------------\n # Enable / Disable / Shutdown\n # ----------------------------------------------------------\n\n def enable(self) -> bool:\n if self.logger:\n self.logger.info(f\"{PLUGIN_NAME} enable() called. is_setup={self.is_setup}\")\n \n if not self.age_check_timer:\n self._setup_timers()\n \n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'squid'):\n if self.squid != self.tamagotchi_logic.squid:\n self.squid = self.tamagotchi_logic.squid\n self._install_hooks()\n if self.logger:\n self.logger.info(f\"Re-acquired squid reference and reinstalled hooks\")\n\n if self.age_check_timer and not self.age_check_timer.isActive():\n self.age_check_timer.start(60000)\n \n if self.stat_check_timer and not self.stat_check_timer.isActive():\n self.stat_check_timer.start(5000)\n\n if self.logger:\n self.logger.info(f\"{PLUGIN_NAME} enabled successfully\")\n return True\n\n def disable(self):\n if self.logger:\n self.logger.info(f\"{PLUGIN_NAME} disable() called\")\n \n if self.age_check_timer:\n self.age_check_timer.stop()\n if self.stat_check_timer:\n self.stat_check_timer.stop()\n if self.notification_timer:\n self.notification_timer.stop()\n \n if self.logger:\n self.logger.info(f\"{PLUGIN_NAME} disabled\")\n\n def shutdown(self):\n self.disable()\n self._uninstall_hooks()\n\n # ----------------------------------------------------------\n # Persistence\n # ----------------------------------------------------------\n\n def _get_save_path(self) -> str:\n os.makedirs(\"saves\", exist_ok=True)\n return os.path.join(\"saves\", \"achievements.json\")\n\n def get_save_data(self) -> dict:\n return {\n \"unlocked\": {k: v.to_dict() for k, v in self.unlocked.items()},\n \"progress\": self.progress,\n \"statistics\": self.statistics,\n \"tracking\": {\n \"weekend_saturday\": self.weekend_saturday,\n \"weekend_sunday\": self.weekend_sunday,\n }\n }\n\n def load_save_data(self, data: dict):\n if not data:\n return\n for aid, adata in data.get(\"unlocked\", {}).items():\n self.unlocked[aid] = UnlockedAchievement.from_dict(adata)\n self.progress = data.get(\"progress\", {})\n self.statistics = data.get(\"statistics\", {})\n tracking = data.get(\"tracking\", {})\n self.weekend_saturday = tracking.get(\"weekend_saturday\", False)\n self.weekend_sunday = tracking.get(\"weekend_sunday\", False)\n\n # ----------------------------------------------------------\n # UI\n # ----------------------------------------------------------\n\n def show_achievements_window(self):\n window = AchievementsWindow(self, self.parent_window)\n window.exec_()\n\n def register_menu_actions(self, main_window: QtWidgets.QMainWindow, menu: QtWidgets.QMenu):\n action = QtWidgets.QAction(f\"🏆 {PLUGIN_NAME}...\", main_window)\n action.triggered.connect(self.show_achievements_window)\n menu.addAction(action)\n\n\n# =============================================================================\n# INITIALIZE FUNCTION - Required by PluginManager\n# =============================================================================\n\ndef initialize(plugin_manager) -> bool:\n plugin_key = PLUGIN_NAME.lower()\n\n if plugin_key in plugin_manager.plugins:\n if hasattr(plugin_manager, 'logger'):\n plugin_manager.logger.warning(f\"{PLUGIN_NAME} is already registered. Skipping re-registration.\")\n return True # Already initialized, no error\n\n try:\n instance = AchievementsPlugin()\n\n plugin_manager.plugins[plugin_key] = {\n 'name': plugin_key,\n 'original_name': PLUGIN_NAME,\n 'version': PLUGIN_VERSION,\n 'author': PLUGIN_AUTHOR,\n 'description': PLUGIN_DESCRIPTION,\n 'requires': PLUGIN_REQUIRES,\n 'instance': instance,\n 'is_setup': False,\n }\n\n if hasattr(plugin_manager, 'logger'):\n plugin_manager.logger.info(f\"{PLUGIN_NAME} v{PLUGIN_VERSION} initialized\")\n\n return True\n\n except Exception as e:\n if hasattr(plugin_manager, 'logger'):\n plugin_manager.logger.error(f\"Failed to initialize {PLUGIN_NAME}: {e}\")\n return False"
},
{
"path": "plugins/multiplayer/__init__.py",
"content": ""
},
{
"path": "plugins/multiplayer/main.py",
"content": "# File: main.py (Plugin Entry Point)\r\n\r\nimport os\r\nimport sys\r\nimport traceback \r\n\r\n# --- Plugin Metadata ---\r\n# These constants describe the plugin to the system and users.\r\nPLUGIN_NAME = \"multiplayer\"\r\nPLUGIN_VERSION = \"1.2.0\"\r\nPLUGIN_AUTHOR = \"ViciousSquid\"\r\nPLUGIN_DESCRIPTION = \"Enables network sync for squids and objects (Experimental)\"\r\nPLUGIN_REQUIRES = [] # Names of other plugins this one depends on\r\n\r\n# --- Python Path Setup ---\r\n# Adjust these paths if your project structure is different.\r\n# This setup helps Python find your 'src' directory and other plugin modules.\r\ntry:\r\n current_file_dir = os.path.dirname(os.path.abspath(__file__))\r\n # Assuming 'main.py' is in 'project_root/plugins/your_plugin_name/'\r\n project_root_candidate_one_up = os.path.abspath(os.path.join(current_file_dir, '..', '..')) # plugins folder is one up, project root is two up\r\n project_root_candidate_two_up = os.path.abspath(os.path.join(current_file_dir, '..', '..', '..')) # If nested deeper\r\n\r\n project_root = None\r\n # Check if 'src' directory exists at the determined project root level\r\n if os.path.isdir(os.path.join(project_root_candidate_one_up, 'src')):\r\n project_root = project_root_candidate_one_up\r\n elif os.path.isdir(os.path.join(project_root_candidate_two_up, 'src')): # Fallback for deeper nesting\r\n project_root = project_root_candidate_two_up\r\n else:\r\n # Using print here as logger might not be available/configured at this early stage of module loading\r\n print(f\"Multiplayer Plugin (main.py) Warning: 'src' directory not reliably found from {current_file_dir}. Imports might fail.\")\r\n # Default to a common structure if unsure (e.g., plugin is in 'project_root/plugins/plugin_name/')\r\n project_root = project_root_candidate_one_up\r\n\r\n if project_root and project_root not in sys.path:\r\n sys.path.insert(0, project_root)\r\n # Optional: print(f\"Multiplayer Plugin (main.py): Added '{project_root}' to sys.path for src imports.\")\r\n if current_file_dir not in sys.path: # Add current plugin directory to sys.path (for relative imports if run directly)\r\n sys.path.insert(0, current_file_dir)\r\n\r\nexcept Exception as e:\r\n print(f\"Multiplayer Plugin (main.py): Error setting up sys.path: {e}\")\r\n# --- End Python Path Setup ---\r\n\r\n# Import after sys.path modifications\r\ntry:\r\n from src.tamagotchi_logic import TamagotchiLogic\r\nexcept ImportError:\r\n # This print is important for diagnosing issues if the main application structure isn't found\r\n print(\"Multiplayer Plugin (main.py) CRITICAL IMPORT ERROR: TamagotchiLogic could not be imported. Ensure 'src' is in sys.path and contains tamagotchi_logic.py.\")\r\n TamagotchiLogic = None # Define as None if import fails, plugin should handle this gracefully.\r\n\r\n# Import plugin metadata constants (defined centrally)\r\nfrom . import mp_constants # Use this to access PLUGIN_NAME, etc.\r\n\r\n# Import the main plugin class\r\nfrom .mp_plugin_logic import MultiplayerPlugin\r\n\r\n\r\n# --- Plugin Registration Function ---\r\ndef initialize(plugin_manager_instance): # plugin_manager_instance is the actual PluginManager object\r\n \"\"\"\r\n Initializes the Multiplayer plugin and registers it with the plugin manager.\r\n This function is called by the plugin system.\r\n \"\"\"\r\n try:\r\n # Create an instance of the main plugin class\r\n plugin_instance = MultiplayerPlugin() # This is MultiplayerPlugin from mp_plugin_logic.py\r\n\r\n # --- Set plugin_manager on the instance ---\r\n # Explicitly set the plugin_manager on the plugin instance here.\r\n # This ensures it's available to the plugin instance's methods like enable() and particularly setup().\r\n # Assumes MultiplayerPlugin.__init__ defines self.plugin_manager = None\r\n plugin_instance.plugin_manager = plugin_manager_instance\r\n\r\n # Define a unique key for the plugin (e.g., based on its name from constants)\r\n plugin_key = mp_constants.PLUGIN_NAME.lower().replace(\" \", \"_\") # Example: \"multiplayer\"\r\n\r\n # Register the plugin with the plugin manager\r\n # The plugin manager will use this information to manage the plugin\r\n plugin_manager_instance.plugins[plugin_key] = {\r\n 'instance': plugin_instance, # The actual plugin object\r\n 'name': mp_constants.PLUGIN_NAME, # Display name of the plugin\r\n 'version': mp_constants.PLUGIN_VERSION,# Version number\r\n 'author': mp_constants.PLUGIN_AUTHOR, # Author(s)\r\n 'description': mp_constants.PLUGIN_DESCRIPTION, # Brief description\r\n 'requires': mp_constants.PLUGIN_REQUIRES, # List of dependencies (other plugin names)\r\n 'is_setup': False, # Plugin's own setup method will set this to True\r\n 'is_enabled_by_default': False # This should ALWAYS ALWAYS be set to 'False' or bad things will happen\r\n }\r\n\r\n # The plugin manager should ideally pass itself to the plugin instance,\r\n # which we now do above.\r\n # The MultiplayerPlugin.enable() method relies on self.plugin_manager being set.\r\n\r\n # This print uses the global print function, as an instance logger isn't set up for this main.py scope.\r\n print(f\"{mp_constants.PLUGIN_NAME} (Version: {mp_constants.PLUGIN_VERSION} by {mp_constants.PLUGIN_AUTHOR}) has been registered with the plugin manager.\")\r\n return True\r\n except Exception as e:\r\n # Use global print for errors at this very early stage if a logger isn't available/reliable\r\n print(f\"Error during {mp_constants.PLUGIN_NAME} plugin initialization (in plugins/multiplayer/main.py): {e}\")\r\n traceback.print_exc() # Print full traceback for diagnosing initialization errors\r\n return False\r\n\r\n# --- End of Plugin Registration ---"
},
{
"path": "plugins/multiplayer/mp_constants.py",
"content": "# File: mp_constants.py\r\n\r\n# --- Plugin Metadata ---\r\n# These constants describe the plugin to the system and users.\r\nPLUGIN_NAME = \"Multiplayer\"\r\nPLUGIN_VERSION = \"1.2.0\"\r\nPLUGIN_AUTHOR = \"ViciousSquid\"\r\nPLUGIN_DESCRIPTION = \"Enables network sync for squids and objects (Experimental)\"\r\nPLUGIN_REQUIRES = [] # Names of other plugins this one depends on\r\n\r\n# --- Network Configuration ---\r\n# These define the network parameters for multicast communication.\r\nMULTICAST_GROUP = '224.3.29.71' # IP address for the multicast group\r\nMULTICAST_PORT = 10000 # Port number for multicast communication\r\nSYNC_INTERVAL = 1.0 # Default seconds between game state sync broadcasts\r\nMAX_PACKET_SIZE = 1472 # Maximum UDP packet size, to prevent fragmentation\r\n\r\nUSE_TCP = False # default – restored from ini\r\nTCP_IP_LIST = [] # will be ['192.168.1.50','192.168.1.51',…]\r\nTCP_PORT = 5008\r\n\r\n# --- Visual Settings (Defaults) ---\r\n# These are default visual parameters. The MultiplayerPlugin instance may override these\r\n# based on runtime configuration (e.g., from a settings dialog).\r\nREMOTE_SQUID_OPACITY = 1.0 # Default opacity for remote squids (0.0 to 1.0)\r\nSHOW_REMOTE_LABELS = True # Default setting for showing labels on remote entities\r\n\r\nSHOW_CONNECTION_LINES = True # Default setting for showing lines connecting to remote squids\r\n"
},
{
"path": "plugins/multiplayer/mp_network_node.py",
"content": "# File: mp_network_node.py\n\nimport uuid\nimport time\nimport socket\nimport queue\nimport zlib\nimport json\nimport traceback\nimport threading\nimport logging\n\nfrom .mp_constants import MULTICAST_GROUP, MULTICAST_PORT, MAX_PACKET_SIZE\n\n\nclass NetworkNode:\n def __init__(self, node_id=None, logger=None):\n \"\"\"\n Represents a networked node in the multiplayer system.\n\n Args:\n node_id (str, optional): Unique identifier for this node.\n Generated if not provided.\n logger (logging.Logger, optional): Logger instance to use.\n A default one is created if not provided.\n \"\"\"\n try:\n # Attempt to use NetworkUtilities if available\n from plugins.multiplayer.network_utilities import NetworkUtilities\n self.node_id = node_id or NetworkUtilities.generate_node_id()\n self.utils = NetworkUtilities\n except ImportError:\n self.node_id = node_id or f\"squid_{uuid.uuid4().hex[:8]}\"\n self.utils = None # Mark utils as unavailable\n\n self.socket = None\n self.initialized = False # Socket structure initialized (IP_ADD_MEMBERSHIP etc.)\n self.is_connected = False # Socket bound and ready for I/O\n \n self._is_listening_active = False # Flag to control the listening loop\n self.listener_thread = None # Thread object for the listening loop\n\n self.last_connection_attempt = 0\n self.connection_retry_interval = 5.0 # seconds\n self.auto_reconnect = True # Flag to control auto-reconnect attempts\n self.use_compression = True # Flag to control message compression\n\n self.incoming_queue = queue.Queue(maxsize=500) # Bounded: if drain stops, old packets are dropped rather than eating RAM\n self.queue_lock = threading.Lock() # Used with incoming_message_queue in one of the versions, ensure consistency\n\n # Deduplication: on a single machine every multicast packet is received once\n # per membership (once per interface + the 0.0.0.0 catch-all), so the same\n # message can arrive 2-3× in the queue. We track (node_id, timestamp) tuples\n # and silently drop duplicates for self._dedup_ttl seconds.\n self._seen_message_ids: dict = {} # {(node_id, timestamp): time_first_seen}\n self._dedup_ttl: float = 10.0 # seconds before a seen-key is expired\n\n self.known_nodes = {} # Stores info about other detected nodes\n self.last_sync_time = 0 # Timestamp of the last sync operation\n self.debug_mode = False # Controlled by MultiplayerPlugin\n\n # Logger must be set up before _get_local_ip() which uses self.logger\n if logger is not None:\n self.logger = logger\n else:\n _logger_name = f\"{__name__}.NetworkNode.{self.node_id[:4]}\"\n self.logger = logging.getLogger(_logger_name)\n if not self.logger.handlers: # Avoid adding multiple handlers if logger is passed around\n handler = logging.StreamHandler()\n formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n handler.setFormatter(formatter)\n self.logger.addHandler(handler)\n # Initial level, can be updated by MultiplayerPlugin if debug_mode changes\n self.logger.setLevel(logging.DEBUG if self.debug_mode else logging.INFO)\n\n self.local_ip = self._get_local_ip()\n \n self.initialize_socket_structure() # Initialize socket when a NetworkNode is created\n\n def _get_local_ip(self):\n \"\"\"\n Detects the best local LAN IP for multicast by enumerating all interfaces\n and ranking them. Prefers 192.168.x.x (typical home/office LAN) over\n 172.16.x.x, then 10.x.x.x -- avoiding VPN/virtual adapters that may have\n captured the default route and share the same IP across machines.\n\n Set MULTICAST_BIND_IP in mp_constants.py to a specific IP to override.\n \"\"\"\n # Allow manual override via config\n from . import mp_constants as _mc\n override = getattr(_mc, 'MULTICAST_BIND_IP', '').strip()\n if override and override != '0.0.0.0':\n self.logger.info(f\"[IP] Using manually configured MULTICAST_BIND_IP: {override}\")\n return override\n\n candidates = []\n\n # Strategy 1: enumerate all IPs via getaddrinfo on hostname\n try:\n hostname = socket.gethostname()\n for info in socket.getaddrinfo(hostname, None, socket.AF_INET):\n ip = info[4][0]\n if ip not in candidates:\n candidates.append(ip)\n except Exception:\n pass\n\n # Strategy 2: also grab the default-route IP the OS prefers\n try:\n with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:\n s.settimeout(0.1)\n s.connect((\"8.8.8.8\", 80))\n default_ip = s.getsockname()[0]\n if default_ip not in candidates:\n candidates.append(default_ip)\n except Exception:\n pass\n\n self.logger.info(f\"[IP] All detected IPs on this machine: {candidates}\")\n\n def score(ip):\n \"\"\"Higher score = more likely a real LAN interface.\"\"\"\n if ip.startswith('127.') or ip.startswith('169.254.'):\n return -1 # loopback / link-local: skip\n if ip.startswith('192.168.'):\n return 3 # classic home/office LAN -- highest priority\n if ip.startswith('172.'):\n parts = ip.split('.')\n try:\n if 16 <= int(parts[1]) <= 31:\n return 2 # RFC1918 172.16-31 range\n except (IndexError, ValueError):\n pass\n if ip.startswith('10.'):\n return 1 # Could be LAN or VPN; lower priority\n return 0\n\n scored = [(score(ip), ip) for ip in candidates if score(ip) >= 0]\n scored.sort(key=lambda x: x[0], reverse=True)\n\n self.logger.info(f\"[IP] Scored candidates (higher=better): {scored}\")\n\n if scored:\n chosen = scored[0][1]\n if len(scored) > 1 and scored[0][0] == scored[1][0]:\n all_ips = [ip for _, ip in scored]\n self.logger.warning(\n f\"[IP] Multiple equal-score IPs: {all_ips}. Using {chosen}. \"\n f\"If wrong (e.g. a VPN IP), set MULTICAST_BIND_IP in mp_constants.py to your real LAN IP.\"\n )\n else:\n self.logger.info(f\"[IP] Selected local IP for multicast: {chosen}\")\n return chosen\n\n self.logger.warning(\"[IP] Could not detect a suitable LAN IP. Falling back to 127.0.0.1.\")\n return '127.0.0.1'\n\n def _get_all_send_ips(self):\n \"\"\"\n Returns all local IPv4 addresses that are valid for multicast sending,\n scored so the best LAN IPs come first. Always includes 0.0.0.0 (default\n interface) as a fallback at the end so same-machine loopback always works\n even if NIC enumeration misses something.\n \"\"\"\n def score(ip):\n if ip.startswith('127.') or ip.startswith('169.254.'):\n return -1\n if ip.startswith('192.168.'):\n return 3\n if ip.startswith('172.'):\n try:\n if 16 <= int(ip.split('.')[1]) <= 31:\n return 2\n except (IndexError, ValueError):\n pass\n if ip.startswith('10.'):\n return 1\n return 0\n\n candidates = set()\n try:\n for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):\n candidates.add(info[4][0])\n except Exception:\n pass\n try:\n with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:\n s.settimeout(0.1)\n s.connect((\"8.8.8.8\", 80))\n candidates.add(s.getsockname()[0])\n except Exception:\n pass\n\n scored = sorted(\n [(score(ip), ip) for ip in candidates if score(ip) >= 0],\n key=lambda x: x[0], reverse=True\n )\n result = [ip for _, ip in scored]\n\n # Always ensure 0.0.0.0 is last — it lets the OS pick the default route\n # interface, which covers same-machine loopback if nothing else does.\n if '0.0.0.0' not in result:\n result.append('0.0.0.0')\n\n self.logger.info(f\"[MCAST] Send interfaces: {result}\")\n return result\n\n def initialize_socket_structure(self):\n \"\"\"Initializes the socket, sets options, binds, and joins the multicast group.\"\"\"\n if self.is_connected and self.socket: # Check if already properly set up\n self.logger.info(\"Socket structure already initialized and connected.\")\n return True\n \n try:\n if self.socket: # If socket exists but not connected, close it first\n try:\n self.socket.close()\n except Exception: pass # Ignore errors on close if already closed\n \n self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)\n self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n # SO_REUSEPORT allows multiple processes to bind to the same port, useful for testing on one machine\n if hasattr(socket, \"SO_REUSEPORT\"):\n try:\n self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)\n except OSError as e:\n if self.debug_mode: self.logger.debug(f\"SO_REUSEPORT not supported or error setting it: {e}\")\n\n try:\n # Enable loopback so packets are delivered to other sockets on the same host.\n # Value 1 = enabled (was incorrectly set to 0, which disabled same-machine peer detection).\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)\n if self.debug_mode: self.logger.debug(\"Multicast loopback enabled.\")\n except socket.error as e_loop:\n self.logger.warning(f\"Could not enable multicast loopback: {e_loop}. May impact same-machine testing.\")\n\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2) # Time-to-live for multicast packets\n\n # All instances MUST bind to the same port (MULTICAST_PORT) so they all\n # receive packets sent to that port. The old port-increment fallback was\n # broken: if instance 2 bumped to 10001, it sent to 10000 but listened on\n # 10001, so it never heard anything. SO_REUSEADDR (set above) allows\n # multiple processes to share a UDP multicast port on Windows.\n try:\n self.socket.bind(('', MULTICAST_PORT))\n self.logger.info(f\"Socket bound successfully to port {MULTICAST_PORT}.\")\n except OSError as bind_error:\n self.logger.error(\n f\"Could not bind to port {MULTICAST_PORT}: {bind_error}. \"\n f\"Ensure SO_REUSEADDR is supported and no non-multicast process has exclusively claimed this port.\"\n )\n self.is_connected = False\n self.initialized = False\n return False\n \n # Join the multicast group on every valid local interface so we receive\n # packets whether they arrive from the loopback (same-machine peers) or\n # from the physical LAN adapter (remote peers).\n self._multicast_send_ips = self._get_all_send_ips()\n joined_count = 0\n for iface_ip in self._multicast_send_ips:\n try:\n mreq = socket.inet_aton(MULTICAST_GROUP) + socket.inet_aton(iface_ip)\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)\n joined_count += 1\n self.logger.info(f\"[MCAST] Joined multicast group on interface {iface_ip}\")\n except OSError as e_join:\n self.logger.warning(f\"[MCAST] Could not join group on {iface_ip}: {e_join}\")\n # Always also join via 0.0.0.0 as a catch-all safety net\n try:\n mreq_any = socket.inet_aton(MULTICAST_GROUP) + socket.inet_aton(\"0.0.0.0\")\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq_any)\n self.logger.info(f\"[MCAST] Also joined via 0.0.0.0 (catch-all). Total explicit joins: {joined_count}\")\n except OSError:\n pass # Already joined on all interfaces - OS treats 0.0.0.0 as duplicate, harmless\n \n self.socket.settimeout(0.1) # Non-blocking recvfrom\n\n self.is_connected = True # Socket is bound and ready\n self.initialized = True # Full structure (options, group) is set up\n self.last_connection_attempt = time.time()\n self.logger.info(f\"Socket structure initialized on {self.local_ip} (listening on all interfaces, port {MULTICAST_PORT}) for multicast group {MULTICAST_GROUP}.\")\n return True\n\n except Exception as e:\n self.logger.error(f\"Error initializing socket structure: {e}\", exc_info=self.debug_mode)\n if self.socket:\n try: self.socket.close()\n except: pass\n self.socket = None\n self.is_connected = False\n self.initialized = False\n return False\n\n def _listen_for_multicast(self):\n \"\"\"Dedicated thread function to listen for incoming multicast packets.\"\"\"\n self.logger.info(f\"Listener thread started for node {self.node_id} on IP {self.local_ip}.\")\n while self._is_listening_active: # Loop controlled by flag\n if not self.is_connected or not self.socket:\n self.logger.warning(\"Listening loop: Socket not connected or available. Attempting to reconnect...\")\n if not self.try_reconnect(): # This will call initialize_socket_structure\n self.logger.error(\"Listening loop: Reconnect failed. Pausing before retry.\")\n time.sleep(self.connection_retry_interval) \n continue # Retry connection\n\n try:\n raw_data, addr = self.socket.recvfrom(MAX_PACKET_SIZE)\n\n if raw_data:\n # Use the thread-safe queue for passing data to the main thread.\n # put_nowait raises queue.Full (never blocks) so the listener\n # thread can't be stalled if the main thread stops draining.\n try:\n self.incoming_queue.put_nowait({'raw_data': raw_data, 'addr': addr})\n except queue.Full:\n # Queue is full – main thread has stopped draining. Drop\n # the oldest packet to make room (FIFO discard) rather than\n # losing the newest one entirely.\n try:\n self.incoming_queue.get_nowait()\n except queue.Empty:\n pass\n try:\n self.incoming_queue.put_nowait({'raw_data': raw_data, 'addr': addr})\n except queue.Full:\n pass # Give up on this packet – main thread is very stuck\n except socket.timeout:\n continue # Normal behavior for non-blocking socket, allows checking _is_listening_active\n except OSError as e: # Handle socket closed or other OS errors\n if self._is_listening_active: # Log only if we weren't expecting closure\n self.logger.error(f\"Socket OS error in listener thread: {e}\", exc_info=True)\n self.is_connected = False # Assume connection is lost if OS error occurs\n # No break here, rely on try_reconnect in the next iteration if _is_listening_active is still true\n except Exception as e: # Catch any other unexpected errors\n if self._is_listening_active:\n self.logger.error(f\"Unexpected error in listener thread: {e}\", exc_info=True)\n time.sleep(0.1) # Brief pause before retrying or exiting based on flag\n\n self.logger.info(f\"Listener thread stopped for node {self.node_id}.\")\n\n\n def is_listening(self):\n \"\"\"Checks if the listener thread is active and alive.\"\"\"\n return self._is_listening_active and self.listener_thread is not None and self.listener_thread.is_alive()\n\n def watchdog_check(self) -> bool:\n \"\"\"\n Call this periodically (e.g. from the plugin's connection_timer) to\n detect and recover a silently-dead listener thread.\n\n A thread can die silently when an unexpected exception escapes the\n while-loop (shouldn't happen given the broad except clause, but OS\n signal delivery or interpreter shutdown edge cases can still kill it).\n\n Returns True if everything is healthy, False if a restart was attempted.\n \"\"\"\n if not self._is_listening_active:\n return True # We deliberately stopped – not a fault\n\n if self.listener_thread is None or not self.listener_thread.is_alive():\n self.logger.error(\n f\"Watchdog: Listener thread for node {self.node_id} has died unexpectedly! \"\n f\"Attempting automatic restart.\"\n )\n self._is_listening_active = False # Reset flag so start_listening doesn't bail early\n self.listener_thread = None\n restarted = self.start_listening()\n if restarted:\n self.logger.info(\"Watchdog: Listener thread restarted successfully.\")\n else:\n self.logger.error(\"Watchdog: Listener thread restart FAILED.\")\n return False # Signal that a recovery was needed\n\n return True # Thread is alive and well\n\n def start_listening(self):\n \"\"\"Starts the multicast listener thread if not already running.\"\"\"\n if self.is_listening():\n self.logger.info(\"Attempted to start listening, but already listening.\")\n return True # Already doing its job\n\n # Ensure socket is initialized and connected before starting to listen\n if not self.initialized or not self.is_connected:\n self.logger.warning(\"Socket not initialized or connected. Attempting to initialize before listening.\")\n if not self.initialize_socket_structure():\n self.logger.error(\"Failed to initialize socket structure. Cannot start listening.\")\n return False\n \n self.logger.info(\"Starting network listener thread...\")\n try:\n self._is_listening_active = True # Set flag before starting thread\n self.listener_thread = threading.Thread(target=self._listen_for_multicast, daemon=True)\n self.listener_thread.setName(f\"MPNodeListener-{self.node_id[:4]}\") # Helpful for debugging threads\n self.listener_thread.start()\n self.logger.info(\"Listener thread started successfully.\")\n return True\n except Exception as e:\n self.logger.error(f\"Failed to start listener thread: {e}\", exc_info=self.debug_mode)\n self._is_listening_active = False # Reset flag on error\n return False\n\n def stop_listening(self):\n \"\"\"Stops the multicast listener thread.\"\"\"\n if not self._is_listening_active and (self.listener_thread is None or not self.listener_thread.is_alive()):\n # If the flag is already false and thread is gone or never started.\n self.logger.info(\"Listener already stopped or was never started.\")\n return\n\n self.logger.info(\"Stopping listener thread...\")\n self._is_listening_active = False # Signal the loop to terminate\n \n if self.listener_thread and self.listener_thread.is_alive():\n self.listener_thread.join(timeout=2.0) # Wait for the thread to finish\n if self.listener_thread.is_alive():\n # This might happen if socket.recvfrom() is stuck, though timeout should prevent it.\n self.logger.warning(\"Listener thread did not stop in time (join timeout).\")\n else:\n self.logger.info(\"Listener thread joined successfully.\")\n else:\n self.logger.info(\"Listener thread was not active or did not exist at explicit stop.\")\n \n self.listener_thread = None # Clear the thread object\n\n\n def try_reconnect(self):\n \"\"\"Attempts to re-establish the socket connection and restart listening if needed.\"\"\"\n if self.is_listening(): # If already listening, assume connection is fine\n return True\n\n current_time = time.time()\n if current_time - self.last_connection_attempt < self.connection_retry_interval:\n # Avoid rapid reconnection attempts\n return False \n\n self.logger.info(\"Attempting to reconnect and restart listener...\")\n self.last_connection_attempt = current_time\n \n self.stop_listening() # Ensure any old listener is stopped\n\n if self.initialize_socket_structure(): # Re-initialize socket (binds, joins group)\n return self.start_listening() # Start listening again\n else:\n self.logger.error(\"Reconnect failed: Could not re-initialize socket structure.\")\n return False\n\n def send_message(self, message_type: str, payload: dict):\n \"\"\"Sends a single message to the multicast group.\"\"\"\n if not self.is_connected: # Check if socket is ready\n self.logger.warning(f\"Cannot send '{message_type}', socket not connected.\")\n if self.auto_reconnect and not self.try_reconnect(): # Attempt to reconnect if enabled\n self.logger.error(f\"Send failed for '{message_type}': Reconnect attempt failed.\")\n return False\n elif not self.is_connected: # If still not connected after attempt\n self.logger.error(f\"Send failed for '{message_type}': Still not connected after reconnect check.\")\n return False\n\n # Construct the full message with metadata\n message_data = {\n 'node_id': self.node_id, # Sender's ID\n 'timestamp': time.time(), # Time of sending\n 'type': message_type, # Type of message (e.g., \"squid_exit\")\n 'payload': payload # The actual data payload\n }\n\n try:\n data_to_send: bytes\n serialized_message = json.dumps(message_data).encode('utf-8')\n\n if self.use_compression:\n # Use NetworkUtilities for compression if available, else direct zlib\n if self.utils and hasattr(self.utils, 'compress_message'):\n # Assuming compress_message takes the dict and returns bytes\n data_to_send = self.utils.compress_message(message_data) \n else: # Fallback to direct zlib if NetworkUtilities or method missing\n data_to_send = zlib.compress(serialized_message)\n if self.debug_mode and message_type.upper() in [\"SQUID_EXIT\", \"SQUID_RETURN\"]:\n self.logger.debug(f\"DEBUG_COMPRESS (send): Type: {message_type}. Original: {len(serialized_message)}, Compressed: {len(data_to_send)}\")\n else: \n data_to_send = serialized_message\n\n if len(data_to_send) > MAX_PACKET_SIZE:\n self.logger.warning(f\"Message '{message_type}' size ({len(data_to_send)}) exceeds MAX_PACKET_SIZE. May fail or be fragmented (UDP handles this, but can be less reliable).\")\n\n if not self.socket:\n self.logger.error(f\"Cannot send '{message_type}', socket is None.\")\n return False\n\n # Send on every valid local interface so that:\n # - same-machine peers receive it via IP_MULTICAST_LOOP loopback\n # - LAN peers receive it via the physical NIC\n send_ips = getattr(self, '_multicast_send_ips', None) or ['0.0.0.0']\n sent_ok = False\n for iface_ip in send_ips:\n try:\n iface_bytes = socket.inet_aton(iface_ip)\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, iface_bytes)\n self.socket.sendto(data_to_send, (MULTICAST_GROUP, MULTICAST_PORT))\n sent_ok = True\n except OSError as e_send:\n self.logger.warning(f\"[MCAST] Send on interface {iface_ip} failed: {e_send}\")\n\n if self.debug_mode and message_type not in ['object_sync', 'squid_move', 'heartbeat']:\n self.logger.debug(f\"Sent '{message_type}' ({len(data_to_send)} bytes) on {len(send_ips)} interface(s).\")\n return sent_ok\n except socket.error as sock_err: # Specific socket errors\n self.logger.error(f\"Socket error sending message '{message_type}': {sock_err}\")\n self.is_connected = False # Assume connection is broken\n self.stop_listening() # Stop listener as connection is likely bad\n except Exception as e: # Other errors (JSON encoding, compression etc.)\n self.logger.error(f\"Error sending message '{message_type}': {e}\", exc_info=self.debug_mode)\n return False\n\n def send_message_batch(self, messages: list):\n \"\"\"Sends a batch of messages in a single packet.\"\"\"\n # Connection check similar to send_message\n if not self.is_connected:\n self.logger.warning(\"Cannot send batch, socket not connected.\")\n if self.auto_reconnect and not self.try_reconnect():\n self.logger.error(\"Send batch failed: Reconnect attempt failed.\")\n return False\n elif not self.is_connected:\n self.logger.error(\"Send batch failed: Still not connected after reconnect check.\")\n return False\n\n # Structure for batch message\n batch_data = {\n 'node_id': self.node_id,\n 'timestamp': time.time(),\n 'batch': True, # Indicates this packet contains multiple messages\n 'messages': [{'type': msg_type, 'payload': payload} for msg_type, payload in messages]\n }\n\n try:\n data_to_send: bytes\n serialized_batch = json.dumps(batch_data).encode('utf-8')\n\n if self.use_compression:\n if self.utils and hasattr(self.utils, 'compress_message'):\n data_to_send = self.utils.compress_message(batch_data)\n else:\n data_to_send = zlib.compress(serialized_batch)\n else: \n data_to_send = serialized_batch\n\n if len(data_to_send) > MAX_PACKET_SIZE:\n self.logger.warning(f\"Batch message size ({len(data_to_send)}) exceeds MAX_PACKET_SIZE. Transmission may fail.\")\n\n if not self.socket:\n self.logger.error(\"Cannot send batch, socket is None.\")\n return False\n\n send_ips = getattr(self, '_multicast_send_ips', None) or ['0.0.0.0']\n sent_ok = False\n for iface_ip in send_ips:\n try:\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(iface_ip))\n self.socket.sendto(data_to_send, (MULTICAST_GROUP, MULTICAST_PORT))\n sent_ok = True\n except OSError as e_send:\n self.logger.warning(f\"[MCAST] Batch send on interface {iface_ip} failed: {e_send}\")\n if self.debug_mode:\n self.logger.debug(f\"Sent batch ({len(data_to_send)} bytes, {len(messages)} msgs) on {len(send_ips)} interface(s).\")\n return sent_ok\n except socket.error as sock_err:\n self.logger.error(f\"Socket error sending message batch: {sock_err}\")\n self.is_connected = False\n self.stop_listening()\n except Exception as e:\n self.logger.error(f\"Error sending message batch: {e}\", exc_info=self.debug_mode)\n return False\n\n def receive_messages(self):\n \"\"\"\n Processes all currently queued raw datagrams from the listener thread.\n This should be called by the main application thread.\n Returns:\n list: A list of (message_dict, address_tuple) for successfully decoded messages.\n \"\"\"\n if not self.is_connected and not self.initialized : # If socket isn't even set up\n # This case might occur if receive_messages is called before successful initialization\n # or after a critical failure.\n # self.logger.debug(\"receive_messages called but socket not initialized/connected.\")\n return [] \n\n received_messages_this_call = []\n \n # Process all items currently in the queue\n while not self.incoming_queue.empty():\n try:\n item = self.incoming_queue.get_nowait() # Get item from queue\n raw_data = item['raw_data']\n addr = item['addr']\n except queue.Empty: # Should not happen with while not empty(), but as safeguard\n break\n except Exception as e_q: # Should not happen for basic queue ops\n self.logger.error(f\"Error getting item from incoming_queue: {e_q}\")\n continue\n\n # Peek at sender_node_id from raw data if possible (for debug log context)\n temp_node_id_peek = \"unknown_at_raw_recv\"\n try: # This peeking is best-effort for logging, might fail if data is not as expected\n peek_data_bytes = raw_data\n if self.use_compression: # Try decompressing a copy for peeking\n try: peek_data_bytes = zlib.decompress(raw_data)\n except zlib.error: pass # If not zlib compressed, peek_data_bytes remains raw_data\n \n j_peek = json.loads(peek_data_bytes.decode('utf-8', errors='ignore'))\n temp_node_id_peek = j_peek.get('node_id', 'peek_decode_fail')\n except: # Broad except as peeking can fail in many ways\n temp_node_id_peek = 'peek_failed_entirely'\n\n\n # Log raw reception if it's not from self (based on peek)\n if temp_node_id_peek != self.node_id:\n if self.debug_mode: print(f\"DEBUG_RAW_RECEIVE (Node {self.node_id}) from {addr} (Peeked Sender: {temp_node_id_peek}). Size: {len(raw_data)}. Data[:60]: {raw_data[:60]}\")\n \n message_dict = None\n decoded_successfully = False\n # Try decoding (with or without compression)\n try:\n data_for_json_decode = raw_data\n if self.use_compression:\n try:\n if self.utils and hasattr(self.utils, 'decompress_message'):\n # Assumes decompress_message returns a dict or raises error\n message_dict = self.utils.decompress_message(raw_data)\n else: # Fallback to direct zlib + json\n data_for_json_decode = zlib.decompress(raw_data)\n message_dict = json.loads(data_for_json_decode.decode('utf-8'))\n decoded_successfully = True\n except (zlib.error, TypeError) as e_zlib: # TypeError if utils.decompress_message fails unexpectedly\n # If zlib fails, it might be an uncompressed message. Try decoding raw_data as JSON.\n if self.debug_mode: self.logger.debug(f\"Zlib decompression failed from {addr} (Sender: {temp_node_id_peek}): {e_zlib}. Trying as uncompressed JSON.\")\n # data_for_json_decode remains raw_data\n message_dict = json.loads(raw_data.decode('utf-8'))\n decoded_successfully = True # If this line is reached, uncompressed JSON was successful\n else: # Not using compression, just decode JSON\n message_dict = json.loads(raw_data.decode('utf-8'))\n decoded_successfully = True\n \n except (json.JSONDecodeError, UnicodeDecodeError) as e_decode:\n if self.debug_mode: self.logger.warning(f\"Failed to decode JSON/UTF-8 from {addr} (Sender: {temp_node_id_peek}). Error: {e_decode}. Data: {raw_data[:80]}\")\n continue # Skip this malformed packet\n except Exception as e_general_decode: # Catch-all for other unexpected decoding issues\n if self.debug_mode: self.logger.error(f\"General error decoding packet from {addr} (Sender: {temp_node_id_peek}): {e_general_decode}\", exc_info=True)\n continue\n\n if not decoded_successfully or not isinstance(message_dict, dict) or 'node_id' not in message_dict:\n if self.debug_mode: self.logger.debug(f\"Invalid or incomplete message structure after all decode attempts from {addr} (Sender: {temp_node_id_peek}): {message_dict}\")\n continue\n \n final_sender_node_id = message_dict.get('node_id')\n \n # Critical filter: Ignore messages from self\n if final_sender_node_id == self.node_id:\n continue\n\n # ── Deduplication ────────────────────────────────────────────────────────\n # On a single machine every multicast send is received once per membership\n # (once per NIC interface + the 0.0.0.0 catch-all join), so the same\n # logical message can arrive 2-3× in the queue. We key on\n # (sender_node_id, timestamp) – every outgoing envelope already stamps a\n # float timestamp – and silently drop copies seen within _dedup_ttl seconds.\n _now = time.time()\n # Prune expired entries so the dict stays small\n self._seen_message_ids = {\n k: v for k, v in self._seen_message_ids.items()\n if _now - v < self._dedup_ttl\n }\n msg_dedup_key = (final_sender_node_id, message_dict.get('timestamp'))\n if msg_dedup_key in self._seen_message_ids:\n if self.debug_mode:\n self.logger.debug(\n f\"Dropping duplicate message key={msg_dedup_key} from {addr}\"\n )\n continue\n self._seen_message_ids[msg_dedup_key] = _now\n # ─────────────────────────────────────────────────────────────────────────\n\n # Log decoded message details\n if self.debug_mode:\n payload_keys_str = list(message_dict.get('payload', {}).keys()) if isinstance(message_dict.get('payload'), dict) else 'Payload_Not_Dict'\n print(f\"DEBUG_DECODED (Node {self.node_id}) from {addr}: Type '{message_dict.get('type', 'N/A')}', From Node '{final_sender_node_id}', PayloadKeys: {payload_keys_str}\")\n if message_dict.get('type') == 'squid_exit': # Specific debug for SQUID_EXIT payload\n print(f\"DEBUG_SQUID_EXIT_PAYLOAD_RECEIVED: {message_dict.get('payload')}\")\n \n # Update known_nodes (this is a simplified version, a more robust presence system might be needed)\n # The payload of interest for squid's last known state might be deeper, e.g., message_dict['payload']['payload'] for SQUID_EXIT\n squid_info_for_known_nodes = message_dict.get('payload', {}) \n if message_dict.get('type') == 'squid_exit' and isinstance(squid_info_for_known_nodes.get('payload'), dict):\n squid_info_for_known_nodes = squid_info_for_known_nodes.get('payload')\n\n self.known_nodes[final_sender_node_id] = (addr[0], time.time(), squid_info_for_known_nodes)\n \n # Add the fully processed message and its original address to the list for the caller\n received_messages_this_call.append((message_dict, addr))\n\n return received_messages_this_call\n\n\n def process_messages(self, plugin_manager_ref): \n \"\"\"\n Retrieves messages from the internal queue (filled by receive_messages via listener thread)\n and triggers hooks in the PluginManager.\n This method is intended to be called by the main application thread.\n \"\"\"\n messages_to_process_from_queue = []\n while not self.incoming_queue.empty(): # Drain the queue\n try:\n # Item from queue is expected to be {'raw_data': ..., 'addr': ...} from _listen_for_multicast\n # NO, item from queue should be (decoded_message_dict, addr) if receive_messages puts decoded ones.\n # Let's clarify: _listen_for_multicast puts raw data.\n # receive_messages (called by this process_messages or similar) decodes them.\n # This process_messages should be working with DECODED messages.\n \n # The current structure has receive_messages called by process_messages.\n # So, call receive_messages first to get decoded messages.\n decoded_messages_and_addrs = self.receive_messages() # This call processes the queue internally.\n\n for message_data, addr in decoded_messages_and_addrs:\n # Now message_data is a decoded dict\n if not isinstance(message_data, dict) or 'type' not in message_data or 'node_id' not in message_data:\n if self.debug_mode: self.logger.debug(f\"process_messages: Discarding malformed message: {message_data}\")\n continue\n\n # Redundant self-check, receive_messages should have handled this.\n # if message_data['node_id'] == self.node_id: \n # continue \n\n message_type = message_data.get('type', 'unknown_message')\n hook_name = f\"on_network_{message_type}\" # Convention for hook names\n\n if self.debug_mode: \n print(f\"DEBUG_STEP_2A: NetworkNode {self.node_id} attempting to trigger hook: '{hook_name}' for msg type '{message_type}' from node {message_data['node_id']}\")\n \n # Trigger hook via PluginManager\n if hasattr(plugin_manager_ref, 'trigger_hook'): \n plugin_manager_ref.trigger_hook(\n hook_name, \n node=self, # Pass this NetworkNode instance\n message=message_data, # Pass the decoded message dictionary\n addr=addr # Pass the original address tuple\n )\n # Fallback if PluginManager has a different direct processing method (less common for hook systems)\n elif hasattr(plugin_manager_ref, '_process_network_message'): \n plugin_manager_ref._process_network_message(message_data, addr)\n else: # Log if no way to dispatch the message\n if self.debug_mode: self.logger.warning(f\"Plugin manager has no trigger_hook or _process_network_message method for hook {hook_name}\")\n \n break # process_messages should ideally process one batch from receive_messages at a time.\n\n except Exception as e: # Catch any errors during the processing loop\n self.logger.error(f\"Error in process_messages loop: {e}\", exc_info=self.debug_mode)\n break # Exit loop on error to avoid continuous failure on same bad data\n\n def close(self):\n \"\"\"Cleans up the network node, stops listening, and closes the socket.\"\"\"\n self.logger.info(f\"Closing network node {self.node_id}...\")\n self.auto_reconnect = False # Prevent any further reconnect attempts during closure\n \n self.stop_listening() # Signal listener thread to stop and wait for it\n \n if self.socket:\n socket_was_initialized_and_connected = self.initialized and self.is_connected\n self.is_connected = False # Mark as not connected\n self.initialized = False # Mark as not initialized\n\n # Attempt to leave multicast group if socket was properly set up\n if socket_was_initialized_and_connected and self.local_ip: \n try:\n # Use \"0.0.0.0\" for imr_interface when leaving, consistent with joining\n mreq_leave_struct = socket.inet_aton(MULTICAST_GROUP) + socket.inet_aton(\"0.0.0.0\")\n self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_DROP_MEMBERSHIP, mreq_leave_struct)\n self.logger.info(\"Left multicast group.\")\n except socket.error as e_mcast_leave: \n if self.debug_mode: self.logger.debug(f\"Socket error leaving multicast group (may be normal if already disconnected): {e_mcast_leave}\")\n except AttributeError: # Can happen if local_ip was problematic\n if self.debug_mode: self.logger.debug(\"AttributeError leaving multicast group (IP likely invalid during shutdown).\")\n except Exception as e_general_leave: # Catch any other unexpected errors\n if self.debug_mode: self.logger.error(f\"Unexpected error leaving multicast group: {e_general_leave}\", exc_info=True)\n try:\n self.socket.close()\n self.logger.info(\"Socket closed.\")\n except Exception as e_sock_close:\n if self.debug_mode: self.logger.debug(f\"Error closing socket (may already be closed): {e_sock_close}\")\n self.socket = None # Clear socket reference\n \n\n self.logger.info(f\"Network node {self.node_id} closed.\")\n\n\n\n\n\n\n"
},
{
"path": "plugins/multiplayer/mp_plugin_logic.py",
"content": "# File: mp_plugin_logic.py\r\n\r\nimport os\r\n# import sys # sys.path is handled in main.py\r\nimport inspect # For _find_tamagotchi_logic\r\nimport json\r\nimport uuid\r\nimport time\r\n# import socket # Network operations are in NetworkNode\r\nimport threading\r\nimport queue # For plugin's own internal queuing if different from NetworkNode's\r\nimport random\r\nimport traceback # For logging exceptions\r\nimport math\r\nfrom typing import Dict, List, Any, Tuple\r\nfrom PyQt5 import QtCore, QtGui, QtWidgets\r\n\r\n# --- Local Imports ---\r\nimport logging # Added for logger\r\nfrom . import mp_constants # Access constants like mp_constants.PLUGIN_NAME\r\nfrom .mp_network_node import NetworkNode\r\nfrom .remote_entity_manager import RemoteEntityManager # Ensure this is imported if type hinting or direct use\r\nfrom .squid_multiplayer_autopilot import RemoteSquidController # Ensure this for autopilot logic\r\n\r\n# TamagotchiLogic is imported in main.py and should be in sys.path\r\n# If type hinting is needed here and main.py's import might not be seen by linters:\r\ntry:\r\n from src.tamagotchi_logic import TamagotchiLogic\r\nexcept ImportError:\r\n TamagotchiLogic = None\r\n\r\n\r\nclass MultiplayerPlugin:\r\n def __init__(self):\r\n # --- Initialize logger attribute ---\r\n self.logger = None \r\n\r\n # --- Locks for thread safety ---\r\n self.network_lock = threading.RLock()\r\n self.remote_squids_lock = threading.RLock()\r\n self.remote_objects_lock = threading.RLock()\r\n\r\n # --- Core Components ---\r\n self.network_node: NetworkNode | None = None\r\n self.plugin_manager = None # Set by plugin system or during setup\r\n self.tamagotchi_logic: TamagotchiLogic | None = None # Set during setup\r\n\r\n # --- Timers and Threads ---\r\n self.sync_thread: threading.Thread | None = None\r\n self.message_process_timer: QtCore.QTimer | None = None\r\n self.controller_update_timer: QtCore.QTimer | None = None\r\n self.controller_creation_timer: QtCore.QTimer | None = None\r\n self.cleanup_timer_basic: QtCore.QTimer | None = None\r\n self.connection_timer_basic: QtCore.QTimer | None = None\r\n\r\n # --- State and Data ---\r\n self.remote_squids: Dict[str, Dict[str, Any]] = {}\r\n self.remote_objects: Dict[str, Dict[str, Any]] = {}\r\n self.remote_squid_controllers: Dict[str, Any] = {} # Should be RemoteSquidController\r\n self.pending_controller_creations: List[Dict[str, Any]] = []\r\n self.connection_lines: Dict[str, QtWidgets.QGraphicsLineItem] = {}\r\n self.last_message_times: Dict[str, float] = {}\r\n\r\n # --- Configuration ---\r\n self.MULTICAST_GROUP = mp_constants.MULTICAST_GROUP\r\n self.MULTICAST_PORT = mp_constants.MULTICAST_PORT\r\n self.SYNC_INTERVAL = mp_constants.SYNC_INTERVAL\r\n # MODIFIED for testing: Force full opacity\r\n self.REMOTE_SQUID_OPACITY = 1.0 # Was mp_constants.REMOTE_SQUID_OPACITY\r\n self.SHOW_REMOTE_LABELS = mp_constants.SHOW_REMOTE_LABELS\r\n self.SHOW_CONNECTION_LINES = mp_constants.SHOW_CONNECTION_LINES\r\n\r\n # --- UI Elements ---\r\n self.config_dialog: QtWidgets.QDialog | None = None\r\n self.status_widget: Any | None = None # Should be MultiplayerStatusWidget\r\n self.status_bar: Any | None = None\r\n\r\n # --- Flags ---\r\n self.is_setup = False\r\n # 1. Try to get the global flag from config.ini\r\n try:\r\n self.debug_mode = self.plugin_manager.config_manager.get_debug_flag(\"multiplayer_debug\", fallback=False)\r\n except Exception:\r\n # 2. Any problem (no ConfigManager, no key, etc.) → stay quiet\r\n self.debug_mode = False\r\n\r\n # 3. Push the value to every sub-component that cares\r\n if self.network_node:\r\n self.network_node.debug_mode = self.debug_mode\r\n if getattr(self, 'entity_manager', None):\r\n self.entity_manager.debug_mode = self.debug_mode\r\n self.last_controller_update = time.time() \r\n self.entity_manager: RemoteEntityManager | None = None # Added type hint\r\n self.config_manager = None # Placeholder, ensure this is set if used (e.g. in handle_squid_exit_message print)\r\n\r\n def _initialize_remote_entity_manager(self):\r\n \"\"\"\r\n Initializes the RemoteEntityManager instance.\r\n This method encapsulates the logic for creating and configuring\r\n the RemoteEntityManager.\r\n \"\"\"\r\n if not self.logger:\r\n # This case should ideally not happen if logger is set up in __init__ or early setup\r\n print(\"MPPluginLogic ERRA: Logger not available for _initialize_remote_entity_manager\")\r\n self.entity_manager = None\r\n return\r\n\r\n if self.tamagotchi_logic and \\\r\n hasattr(self.tamagotchi_logic, 'user_interface') and \\\r\n self.tamagotchi_logic.user_interface and \\\r\n hasattr(self.tamagotchi_logic.user_interface, 'image_cache'): # Check for image_cache\r\n\r\n ui = self.tamagotchi_logic.user_interface\r\n try:\r\n self.entity_manager = RemoteEntityManager(\r\n scene=ui.scene,\r\n window_width=ui.window_width,\r\n window_height=ui.window_height,\r\n #image_cache=ui.image_cache, # Pass the image_cache instance\r\n debug_mode=self.debug_mode, # self.debug_mode should be set in MpPluginLogic\r\n logger=self.logger.getChild(\"RemoteEntityManager\") # Pass a child logger\r\n )\r\n self.logger.info(\"RemoteEntityManager initialized successfully.\")\r\n except ImportError: # Should not happen if imports are correct at file top\r\n self.logger.error(\"RemoteEntityManager import failed during initialization. Visuals for remote entities will be basic or non-functional.\", exc_info=True)\r\n self.entity_manager = None\r\n # self.initialize_remote_representation() # Call your fallback if RemoteEntityManager fails\r\n except Exception as e_rem:\r\n self.logger.error(f\"Error initializing RemoteEntityManager: {e_rem}\", exc_info=True)\r\n self.entity_manager = None\r\n # self.initialize_remote_representation() # Call your fallback\r\n else:\r\n self.logger.warning(\"User interface, TamagotchiLogic, or ImageCache not available for RemoteEntityManager setup. Remote visuals may be limited or non-functional.\")\r\n self.entity_manager = None\r\n # self.initialize_remote_representation() # Call your fallback\r\n\r\n\r\n def debug_autopilot_status(self):\r\n \"\"\"Debug the status of all autopilot controllers for remote squids.\"\"\"\r\n if not self.logger: # Safeguard\r\n print(\"Multiplayer ERRA: Logger not initialized in debug_autopilot_status\")\r\n return\r\n\r\n if not hasattr(self, 'remote_squid_controllers') or not self.remote_squid_controllers:\r\n self.logger.debug(\"No remote squid controllers are currently active.\")\r\n return\r\n\r\n self.logger.debug(f\"\\n=== AUTOPILOT DEBUG ({len(self.remote_squid_controllers)} controllers) ===\")\r\n for node_id, controller in self.remote_squid_controllers.items():\r\n squid_name = node_id[-6:]\r\n self.logger.debug(f\"Squid {squid_name}:\")\r\n self.logger.debug(f\" State: {getattr(controller, 'state', 'N/A')}\")\r\n squid_data = getattr(controller, 'squid_data', {})\r\n pos_x = squid_data.get('x', 0.0)\r\n pos_y = squid_data.get('y', 0.0)\r\n self.logger.debug(f\" Position: ({pos_x:.1f}, {pos_y:.1f})\")\r\n self.logger.debug(f\" Direction: {squid_data.get('direction', 'N/A')}\")\r\n self.logger.debug(f\" Home Dir: {getattr(controller, 'home_direction', 'N/A')}\")\r\n time_away = getattr(controller, 'time_away', 0.0)\r\n max_time = getattr(controller, 'max_time_away', 0.0)\r\n self.logger.debug(f\" Time Away: {time_away:.1f}s / {max_time:.1f}s\")\r\n food_count = getattr(controller, 'food_eaten_count', 0)\r\n rock_count = getattr(controller, 'rock_interaction_count', 0)\r\n self.logger.debug(f\" Activities: {food_count} food, {rock_count} rocks\")\r\n target_obj = getattr(controller, 'target_object', None)\r\n self.logger.debug(f\" Target: {'Yes (' + type(target_obj).__name__ + ')' if target_obj else 'No'}\")\r\n self.logger.debug(\"=====================================\\n\")\r\n\r\n def enable(self):\r\n self.logger.info(\"Attempting to enable Multiplayer...\")\r\n\r\n # --- NEW: Debug log all key objects ---\r\n self.logger.debug(f\"[ENABLE] status_widget: {self.status_widget}\")\r\n self.logger.debug(f\"[ENABLE] entity_manager: {self.entity_manager}\")\r\n self.logger.debug(f\"[ENABLE] network_node: {self.network_node}\")\r\n self.logger.debug(f\"[ENABLE] tamagotchi_logic: {self.tamagotchi_logic}\")\r\n self.logger.debug(f\"[ENABLE] config_manager: {getattr(self, 'config_manager', None)}\")\r\n # --- END DEBUG LOG ---\r\n\r\n # Plugin already set up?\r\n if not self.is_setup:\r\n self.logger.info(\"Multiplayer plugin is not set up. Calling setup()...\")\r\n # Assuming self.plugin_manager and self.tamagotchi_logic_ref are available\r\n if not self.setup(self.plugin_manager, self.tamagotchi_logic_ref): # Pass necessary args\r\n self.logger.error(\"Multiplayer setup failed during enable(). Cannot enable.\")\r\n return False\r\n else:\r\n self.logger.info(\"Multiplayer is already marked as set up. Re-enabling components.\")\r\n\r\n # --- BEGIN NEW/MODIFIED SECTION ---\r\n # Ensure network node is ready and listening\r\n if self.network_node:\r\n # Ensure the socket structure is initialized (it should be by NetworkNode.__init__ or a previous setup)\r\n # but a re-check or re-init if disconnected can be robust.\r\n if not self.network_node.is_connected:\r\n self.logger.info(\"NetworkNode socket not connected, attempting to initialize in enable()...\")\r\n if not self.network_node.initialize_socket_structure():\r\n self.logger.error(\"Failed to initialize NetworkNode socket in enable(). Cannot proceed with enabling multiplayer.\")\r\n # Potentially set self.enabled = False or similar state management\r\n return False # Or handle error appropriately\r\n\r\n # Explicitly start the listener thread if it's not already active\r\n if not self.network_node.is_listening():\r\n self.logger.info(\"NetworkNode listener not active, starting it explicitly in enable()...\")\r\n if not self.network_node.start_listening():\r\n self.logger.error(\"Failed to start NetworkNode listener in enable(). Multiplayer might not receive messages.\")\r\n # Decide if this is a fatal error for enabling or just a warning\r\n # For now, let's treat it as potentially non-fatal but log an error.\r\n # Depending on requirements, you might return False here.\r\n else:\r\n self.logger.info(\">>>>>> NetworkNode listener started successfully!\")\r\n else:\r\n self.logger.info(\"NetworkNode listener was already active.\")\r\n else:\r\n self.logger.error(\"NetworkNode not found after setup in enable(). Cannot enable multiplayer fully.\")\r\n # Potentially set self.enabled = False\r\n return False # This is likely a critical failure\r\n # --- END NEW/MODIFIED SECTION ---\r\n\r\n # Resume original enable logic:\r\n # For example, re-initialize UI components, timers, etc.\r\n # Ensure any components that were disabled are re-enabled.\r\n\r\n # Re-initialize or ensure timers are running (if they were stopped in disable)\r\n if self.message_process_timer:\r\n if not self.message_process_timer.isActive():\r\n self.message_process_timer.start(50)\r\n self.logger.info(\"Message processing timer restarted.\")\r\n else:\r\n self.logger.warning(\"message_process_timer is None in enable(). Skipping.\")\r\n\r\n if hasattr(self, 'sync_timer') and self.sync_timer:\r\n if not self.sync_timer.isActive():\r\n self.logger.info(\"Sync timer not active, starting/restarting it.\")\r\n self.start_sync_timer()\r\n else:\r\n self.logger.warning(\"sync_timer not found or is None. Skipping.\")\r\n\r\n # Update status widget if applicable\r\n if self.status_widget:\r\n try:\r\n self.status_widget.update_status(\"Enabled\", True)\r\n current_ip = self.network_node.local_ip if self.network_node else \"N/A\"\r\n if hasattr(self.status_widget, 'set_ip_address'):\r\n self.status_widget.set_ip_address(current_ip)\r\n else:\r\n self.logger.warning(\"status_widget has no set_ip_address method.\")\r\n except Exception as e:\r\n self.logger.error(f\"Error updating status_widget in enable(): {e}\", exc_info=True)\r\n else:\r\n self.logger.warning(\"status_widget is None in enable(). Skipping UI update.\")\r\n\r\n self.enabled = True # Mark as enabled\r\n self.logger.info(\"Multiplayer enabled successfully.\")\r\n return True\r\n\r\n def disable(self):\r\n \"\"\"Disables the multiplayer plugin and cleans up resources.\"\"\"\r\n if not self.logger: # Should be set by now\r\n print(\"Multiplayer ERRA: Logger not set in disable()\") # Fallback to print if logger is broken\r\n return\r\n self.logger.info(f\"Disabling {mp_constants.PLUGIN_NAME}...\")\r\n if self.network_node and self.network_node.is_connected:\r\n self.network_node.send_message(\r\n 'player_leave',\r\n {'node_id': self.network_node.node_id, 'reason': 'plugin_disabled'}\r\n )\r\n\r\n self.cleanup()\r\n\r\n if self.status_widget: self.status_widget.hide()\r\n if self.status_bar:\r\n if hasattr(self.status_bar, 'update_network_status'): self.status_bar.update_network_status(False)\r\n if hasattr(self.status_bar, 'update_peers_count'): self.status_bar.update_peers_count(0)\r\n\r\n self.logger.info(f\"{mp_constants.PLUGIN_NAME} disabled.\")\r\n\r\n def setup(self, plugin_manager_instance, tamagotchi_logic_instance):\r\n \"\"\"\r\n Sets up the multiplayer plugin. Called when the plugin is first loaded or enabled.\r\n Args:\r\n plugin_manager_instance: A reference to the main plugin manager.\r\n tamagotchi_logic_instance: A reference to the core tamagotchi logic.\r\n \"\"\"\r\n self.plugin_manager = plugin_manager_instance\r\n\r\n # --- BEGIN LOGGER INITIALIZATION ---\r\n if hasattr(self.plugin_manager, 'logger') and self.plugin_manager.logger is not None:\r\n self.logger = self.plugin_manager.logger.getChild(mp_constants.PLUGIN_NAME) # Get a child logger is good practice\r\n else:\r\n logger_name = f\"{mp_constants.PLUGIN_NAME}_Plugin\"\r\n self.logger = logging.getLogger(logger_name)\r\n if not self.logger.hasHandlers():\r\n handler = logging.StreamHandler()\r\n formatter = logging.Formatter('%(asctime)s - %(name)s - [%(levelname)s] - %(message)s')\r\n handler.setFormatter(formatter)\r\n self.logger.addHandler(handler)\r\n # Initial level, might be changed by debug_mode later\r\n self.logger.setLevel(logging.INFO) \r\n self.logger.warning(\r\n \"PluginManager did not provide a valid logger. Using fallback logger.\"\r\n )\r\n \r\n self.logger.info(f\"Initializing setup for {mp_constants.PLUGIN_NAME}...\")\r\n # --- END LOGGER INITIALIZATION ---\r\n \r\n # Attempt to get config_manager from plugin_manager if available (for the print in handle_squid_exit)\r\n if hasattr(plugin_manager_instance, 'config_manager'):\r\n self.config_manager = plugin_manager_instance.config_manager\r\n elif hasattr(tamagotchi_logic_instance, 'config_manager'): # Check on tamagotchi_logic as well\r\n self.config_manager = tamagotchi_logic_instance.config_manager\r\n else:\r\n self.logger.warning(\"ConfigManager not found for debug print in handle_squid_exit_message.\")\r\n # Create a dummy if needed for the print to not error out, or handle it in the print\r\n class DummyConfigManager:\r\n def get_node_id(self): return \"UnknownNodeID_Setup\" # Differentiate if needed\r\n if not hasattr(self, 'config_manager') or self.config_manager is None : # Set only if not already set\r\n self.config_manager = DummyConfigManager()\r\n\r\n\r\n self.tamagotchi_logic = tamagotchi_logic_instance\r\n\r\n if not TamagotchiLogic: # Class itself\r\n self.logger.critical(\"TamagotchiLogic module was not loaded (import failed). Cannot complete setup.\")\r\n return False\r\n\r\n if self.tamagotchi_logic is None: # Instance\r\n self.logger.warning(\"TamagotchiLogic instance was not directly passed or was None. Attempting to find it via PluginManager.\")\r\n if hasattr(self.plugin_manager, 'core_game_logic'):\r\n self.tamagotchi_logic = self.plugin_manager.core_game_logic\r\n elif hasattr(self.plugin_manager, 'tamagotchi_logic'): # Common attribute name\r\n self.tamagotchi_logic = self.plugin_manager.tamagotchi_logic\r\n else: # Fallback deep search\r\n self.tamagotchi_logic = self._find_tamagotchi_logic(self.plugin_manager)\r\n\r\n if not self.tamagotchi_logic:\r\n self.logger.critical(\"TamagotchiLogic instance not found. Plugin functionality will be severely limited.\")\r\n # return False # Decided to proceed with limited functionality if UI parts are missing\r\n else:\r\n self.debug_mode = getattr(self.tamagotchi_logic, 'debug_mode', False)\r\n if self.logger and hasattr(self.logger, 'setLevel'): # Make sure logger has setLevel\r\n self.logger.setLevel(logging.DEBUG if self.debug_mode else logging.INFO)\r\n self.logger.info(f\"TamagotchiLogic instance found. Debug mode: {self.debug_mode}\")\r\n\r\n node_id_val = f\"squid_{uuid.uuid4().hex[:6]}\"\r\n self.network_node = NetworkNode(node_id_val, logger=self.logger)\r\n self.network_node.debug_mode = self.debug_mode # Pass debug mode to network node\r\n \r\n if self.tamagotchi_logic: # Ensure tamagotchi_logic exists before setting attribute\r\n setattr(self.tamagotchi_logic, 'multiplayer_network_node', self.network_node)\r\n\r\n if not self.message_process_timer:\r\n self.message_process_timer = QtCore.QTimer()\r\n self.message_process_timer.timeout.connect(self._process_network_node_queue)\r\n self.message_process_timer.start(50) # Process queue every 50ms\r\n\r\n if not self.controller_update_timer:\r\n self.controller_update_timer = QtCore.QTimer()\r\n self.controller_update_timer.timeout.connect(self.update_remote_controllers)\r\n self.controller_update_timer.start(50) # Update controllers every 50ms\r\n\r\n if not self.controller_creation_timer:\r\n self._setup_controller_creation_timer() # For deferred controller creation\r\n\r\n self._register_hooks() # Register message handlers\r\n\r\n # Clear previous state\r\n self.remote_squids.clear()\r\n self.remote_objects.clear()\r\n self.connection_lines.clear()\r\n self.remote_squid_controllers.clear()\r\n self.last_controller_update = time.time()\r\n\r\n\r\n # === MODIFIED RemoteEntityManager Instantiation Block START ===\r\n if self.tamagotchi_logic and \\\r\n hasattr(self.tamagotchi_logic, 'user_interface') and \\\r\n self.tamagotchi_logic.user_interface:\r\n\r\n ui = self.tamagotchi_logic.user_interface # This is the GameWindow instance\r\n\r\n # Removed check for ui.image_cache as it's no longer passed or needed by RemoteEntityManager\r\n try:\r\n # RemoteEntityManager should be imported at the top of mp_plugin_logic.py\r\n self.entity_manager = RemoteEntityManager(\r\n scene=ui.scene,\r\n window_width=ui.window_width,\r\n window_height=ui.window_height,\r\n # image_cache=ui.image_cache, # <<< THIS LINE IS REMOVED\r\n debug_mode=self.debug_mode, # Correct: Pass the debug_mode boolean\r\n logger=self.logger.getChild(\"RemoteEntityManager\") # Good practice for logger\r\n )\r\n self.logger.info(\"RemoteEntityManager initialized.\")\r\n except ImportError: # Should be caught if RemoteEntityManager isn't imported\r\n self.logger.error(\"RemoteEntityManager class import failed. Visuals for remote entities will be basic or non-functional.\", exc_info=True)\r\n self.entity_manager = None\r\n self.initialize_remote_representation() # Your fallback\r\n except Exception as e_rem:\r\n self.logger.error(f\"Error initializing RemoteEntityManager: {e_rem}\", exc_info=True)\r\n self.entity_manager = None\r\n self.initialize_remote_representation() # Your fallback\r\n else:\r\n self.logger.warning(\"User interface or TamagotchiLogic not available for RemoteEntityManager setup. Remote visuals may be limited.\")\r\n self.entity_manager = None\r\n self.initialize_remote_representation() # Your fallback\r\n # === MODIFIED RemoteEntityManager Instantiation Block END ===\r\n\r\n self.initialize_status_ui() # Initialize status widget or bar\r\n\r\n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'show_message') and self.network_node:\r\n self.tamagotchi_logic.show_message(f\"Multiplayer active! Node ID: {self.network_node.node_id}\")\r\n\r\n node_ip = self.network_node.local_ip if self.network_node else \"N/A\"\r\n node_port = self.MULTICAST_PORT # Use the constant\r\n self.logger.info(f\"Setup complete. Node: {node_id_val} on IP: {node_ip}. Listening for multicast on port: {node_port}\")\r\n self.is_setup = True\r\n return True\r\n\r\n def _process_network_node_queue(self, **kwargs):\r\n \"\"\"Called by a QTimer to process messages from the NetworkNode's incoming_queue.\"\"\"\r\n if not self.logger: return\r\n if self.network_node and self.plugin_manager:\r\n try:\r\n self.network_node.process_messages(self.plugin_manager)\r\n except Exception as e:\r\n if self.debug_mode:\r\n self.logger.error(f\"Error in _process_network_node_queue: {e}\", exc_info=True)\r\n\r\n def setup_minimal_network(self):\r\n \"\"\"(Helper) Creates a basic network interface if one is required but not found.\"\"\"\r\n if not self.logger: return\r\n self.logger.info(\"Setting up minimal network interface...\")\r\n class MinimalNetworkInterface:\r\n def create_socket(self, socket_type='udp'):\r\n import socket\r\n return socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\r\n if self.plugin_manager:\r\n self.plugin_manager.plugins['network_interface'] = {\r\n 'instance': MinimalNetworkInterface(), 'name': 'Minimal Network Interface', 'version': '0.1'\r\n }\r\n self.logger.info(\"Minimal network interface registered.\")\r\n\r\n def update_remote_squid_image(self, remote_squid_display_data: Dict, direction: str):\r\n \"\"\"Updates the visual image of a remote squid based on its direction.\"\"\"\r\n if not self.logger: return False\r\n visual_item = remote_squid_display_data.get('visual')\r\n if not visual_item or not isinstance(visual_item, QtWidgets.QGraphicsPixmapItem):\r\n return False\r\n try:\r\n base_image_path = \"images\"\r\n squid_image_file = f\"{direction.lower()}1.png\"\r\n full_image_path = os.path.join(base_image_path, squid_image_file)\r\n squid_pixmap = QtGui.QPixmap(full_image_path)\r\n if squid_pixmap.isNull():\r\n fallback_path = os.path.join(base_image_path, \"right1.png\") # Default fallback\r\n squid_pixmap = QtGui.QPixmap(fallback_path)\r\n if squid_pixmap.isNull() and self.debug_mode:\r\n self.logger.warning(f\"Could not load squid image '{full_image_path}' or fallback '{fallback_path}'.\")\r\n # Create a colored square as an ultimate fallback if even \"right1.png\" fails\r\n squid_pixmap = QtGui.QPixmap(60,40) # Default size\r\n squid_color = remote_squid_display_data.get('data',{}).get('color',(128,128,128))\r\n squid_pixmap.fill(QtGui.QColor(*squid_color))\r\n\r\n visual_item.setPixmap(squid_pixmap)\r\n return True\r\n except Exception as e:\r\n if self.debug_mode:\r\n self.logger.error(f\"Error updating remote squid image for direction '{direction}': {e}\", exc_info=True)\r\n return False\r\n\r\n def handle_squid_interaction(self, local_squid, remote_node_id, remote_squid_data):\r\n \"\"\"Handles interactions between the local squid and a detected remote squid.\"\"\"\r\n if not self.logger: return\r\n if not local_squid or not remote_squid_data or not self.tamagotchi_logic: return\r\n local_pos = (local_squid.squid_x, local_squid.squid_y)\r\n remote_pos = (remote_squid_data.get('x',0.0), remote_squid_data.get('y',0.0))\r\n distance = math.hypot(local_pos[0] - remote_pos[0], local_pos[1] - remote_pos[1])\r\n interaction_distance_threshold = 80 # Example threshold\r\n if distance < interaction_distance_threshold:\r\n if hasattr(local_squid, 'memory_manager') and hasattr(local_squid.memory_manager, 'add_short_term_memory'):\r\n local_squid.memory_manager.add_short_term_memory(\r\n category='social', event_type='squid_meeting',\r\n description=f\"Met squid {remote_node_id[-6:]} from another tank.\",\r\n importance=5\r\n )\r\n self.attempt_gift_exchange(local_squid, remote_node_id)\r\n\r\n def attempt_gift_exchange(self, local_squid, remote_node_id: str):\r\n \"\"\"Allows squids to exchange a random decoration item if conditions are met.\"\"\"\r\n if not self.logger: return False\r\n if random.random() > 0.15: return False # 15% chance\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface'): return False\r\n ui = self.tamagotchi_logic.user_interface\r\n local_decorations = [\r\n item for item in ui.scene.items()\r\n if isinstance(item, QtWidgets.QGraphicsPixmapItem) and\r\n getattr(item, 'category', '') == 'decoration' and\r\n item.isVisible() and not getattr(item, 'is_foreign', False) and # Not already from remote\r\n not getattr(item, 'is_gift_from_remote', False) # Not a gift they received\r\n ]\r\n if not local_decorations: return False\r\n gift_to_send_away = random.choice(local_decorations)\r\n \r\n # Simulate receiving a gift (create a new decoration)\r\n received_gift_item = self.create_gift_decoration(remote_node_id)\r\n \r\n if received_gift_item: # If a gift was successfully created for the local scene\r\n # Make the local squid's chosen decoration disappear (sent away)\r\n gift_to_send_away.setVisible(False)\r\n # Optionally, remove it from the scene after a delay or permanently\r\n QtCore.QTimer.singleShot(15000, lambda item=gift_to_send_away: self._remove_gifted_item_from_scene(item))\r\n\r\n if hasattr(local_squid, 'memory_manager'):\r\n local_squid.memory_manager.add_short_term_memory(\r\n 'social', 'decoration_exchange',\r\n f\"Exchanged decorations with squid {remote_node_id[-6:]}!\", importance=7\r\n )\r\n if hasattr(self.tamagotchi_logic, 'show_message'):\r\n self.tamagotchi_logic.show_message(f\"🎁 Your squid exchanged gifts with {remote_node_id[-6:]}!\")\r\n return True\r\n return False\r\n\r\n def _remove_gifted_item_from_scene(self, item_to_remove):\r\n \"\"\"Safely removes an item from the scene if it's still present.\"\"\"\r\n if not self.logger: return\r\n if item_to_remove and self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'user_interface'):\r\n scene = self.tamagotchi_logic.user_interface.scene\r\n if item_to_remove in scene.items():\r\n scene.removeItem(item_to_remove)\r\n if self.debug_mode: self.logger.debug(f\"Removed gifted item '{getattr(item_to_remove,'filename','N/A')}' from scene.\")\r\n\r\n def create_stolen_rocks(self, local_squid, num_rocks: int, entry_position: tuple):\r\n \"\"\"Creates rock items in the local scene, representing rocks 'stolen' by the local squid from a remote tank.\"\"\"\r\n if not self.logger: return\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface') or num_rocks <= 0:\r\n return\r\n ui = self.tamagotchi_logic.user_interface\r\n scene = ui.scene\r\n rock_image_files = []\r\n search_paths = [os.path.join(\"images\", \"decoration\"), \"images\"] # Common paths for rocks\r\n for path in search_paths:\r\n if os.path.exists(path):\r\n for filename in os.listdir(path):\r\n if 'rock' in filename.lower() and filename.lower().endswith(('.png', '.jpg')):\r\n rock_image_files.append(os.path.join(path, filename))\r\n \r\n if not rock_image_files: # Fallback if no specific rocks found\r\n rock_image_files.append(os.path.join(\"images\", \"rock.png\")) # Assume a default rock image\r\n\r\n entry_x, entry_y = entry_position\r\n for i in range(num_rocks):\r\n try:\r\n chosen_rock_file = random.choice(rock_image_files)\r\n # Scatter rocks around the entry point\r\n angle_offset = random.uniform(-math.pi / 4, math.pi / 4) \r\n angle = (i * (2 * math.pi / num_rocks)) + angle_offset \r\n dist = random.uniform(60, 100) # Distance from entry point\r\n rock_x = entry_x + dist * math.cos(angle)\r\n rock_y = entry_y + dist * math.sin(angle)\r\n\r\n rock_pixmap = QtGui.QPixmap(chosen_rock_file)\r\n if rock_pixmap.isNull(): continue # Skip if image fails to load\r\n\r\n rock_graphics_item = None\r\n if hasattr(ui, 'ResizablePixmapItem'): # Check if custom item class exists\r\n rock_graphics_item = ui.ResizablePixmapItem(rock_pixmap, chosen_rock_file)\r\n else:\r\n rock_graphics_item = QtWidgets.QGraphicsPixmapItem(rock_pixmap)\r\n setattr(rock_graphics_item, 'filename', chosen_rock_file) # Store filename if not ResizablePixmapItem\r\n \r\n setattr(rock_graphics_item, 'category', 'rock')\r\n setattr(rock_graphics_item, 'can_be_picked_up', True)\r\n setattr(rock_graphics_item, 'is_stolen_from_remote', True)\r\n setattr(rock_graphics_item, 'is_foreign', True) # Mark as foreign for tinting\r\n rock_graphics_item.setPos(rock_x, rock_y)\r\n scene.addItem(rock_graphics_item)\r\n self.apply_foreign_object_tint(rock_graphics_item) # Apply a visual tint\r\n\r\n # Simple fade-in for stolen rocks (no complex animation for static testing)\r\n rock_graphics_item.setOpacity(0.2) # Start slightly transparent\r\n # Removed QPropertyAnimation for opacity for static testing\r\n rock_graphics_item.setOpacity(1.0) # Make fully visible immediately\r\n\r\n\r\n except Exception as e:\r\n if self.debug_mode: self.logger.error(f\"Error creating stolen rock visuals: {e}\", exc_info=True)\r\n \r\n if hasattr(local_squid, 'memory_manager'):\r\n local_squid.memory_manager.add_short_term_memory(\r\n 'achievement', 'rock_heist',\r\n f\"Brought back {num_rocks} rocks from an adventure!\", importance=8\r\n )\r\n\r\n def apply_foreign_object_tint(self, q_graphics_item: QtWidgets.QGraphicsPixmapItem):\r\n \"\"\"Applies a visual tint to indicate an object is from a remote instance.\"\"\"\r\n if not self.logger: return\r\n if not isinstance(q_graphics_item, QtWidgets.QGraphicsPixmapItem): return\r\n \r\n existing_effect = q_graphics_item.graphicsEffect()\r\n if isinstance(existing_effect, QtWidgets.QGraphicsColorizeEffect):\r\n # Update existing effect if it's already the right type\r\n existing_effect.setColor(QtGui.QColor(255, 120, 120, 200)) # Tint color (e.g., reddish)\r\n existing_effect.setStrength(0.3) # Tint strength\r\n else:\r\n # Create and apply new effect\r\n colorize_effect = QtWidgets.QGraphicsColorizeEffect()\r\n colorize_effect.setColor(QtGui.QColor(255, 120, 120, 200)) \r\n colorize_effect.setStrength(0.3)\r\n q_graphics_item.setGraphicsEffect(colorize_effect)\r\n setattr(q_graphics_item, 'is_foreign', True) # Ensure flag is set\r\n\r\n\r\n def show_network_dashboard(self):\r\n \"\"\"Displays a dialog with detailed network status and peer information.\"\"\"\r\n if not self.logger: return\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface') or not self.network_node:\r\n self.logger.warning(\"Cannot show network dashboard - UI or NetworkNode missing.\")\r\n return\r\n\r\n parent_window = self.tamagotchi_logic.user_interface.window\r\n dashboard_dialog = QtWidgets.QDialog(parent_window)\r\n dashboard_dialog.setWindowTitle(\"Multiplayer Network Dashboard\")\r\n dashboard_dialog.setMinimumSize(550, 450)\r\n\r\n main_layout = QtWidgets.QVBoxLayout(dashboard_dialog)\r\n\r\n # Connection Info Group\r\n conn_info_group = QtWidgets.QGroupBox(\"My Connection\")\r\n conn_info_form = QtWidgets.QFormLayout(conn_info_group)\r\n node_id_label = QtWidgets.QLabel(self.network_node.node_id)\r\n ip_label = QtWidgets.QLabel(self.network_node.local_ip)\r\n status_val_label = QtWidgets.QLabel() # Will be updated\r\n conn_info_form.addRow(\"Node ID:\", node_id_label)\r\n conn_info_form.addRow(\"Local IP:\", ip_label)\r\n conn_info_form.addRow(\"Status:\", status_val_label)\r\n main_layout.addWidget(conn_info_group)\r\n\r\n # Peers Group\r\n peers_group = QtWidgets.QGroupBox(\"Detected Peers\")\r\n peers_layout = QtWidgets.QVBoxLayout(peers_group)\r\n peers_table_widget = QtWidgets.QTableWidget()\r\n peers_table_widget.setColumnCount(4)\r\n peers_table_widget.setHorizontalHeaderLabels([\"Node ID\", \"IP Address\", \"Last Seen\", \"Status\"])\r\n peers_table_widget.horizontalHeader().setStretchLastSection(True)\r\n peers_table_widget.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)\r\n peers_table_widget.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)\r\n peers_layout.addWidget(peers_table_widget)\r\n main_layout.addWidget(peers_group)\r\n \r\n # Network Stats Group (Conceptual)\r\n stats_group = QtWidgets.QGroupBox(\"Network Statistics (Conceptual)\")\r\n stats_form = QtWidgets.QFormLayout(stats_group)\r\n stats_form.addRow(\"Messages Sent (Total):\", QtWidgets.QLabel(str(getattr(self.network_node, 'total_sent_count', 'N/A'))))\r\n stats_form.addRow(\"Messages Received (Total):\", QtWidgets.QLabel(str(getattr(self.network_node, 'total_received_count', 'N/A'))))\r\n main_layout.addWidget(stats_group)\r\n\r\n\r\n def refresh_dashboard_data():\r\n # Update connection status\r\n is_connected = self.network_node.is_connected\r\n status_val_label.setText(\"Connected\" if is_connected else \"Disconnected\")\r\n status_val_label.setStyleSheet(\"color: green; font-weight: bold;\" if is_connected else \"color: red; font-weight: bold;\")\r\n\r\n # Update peers table\r\n peers_table_widget.setRowCount(0) # Clear table\r\n if self.network_node: # Check if network_node still exists\r\n for row, (node_id, (ip, last_seen, _)) in enumerate(self.network_node.known_nodes.items()):\r\n peers_table_widget.insertRow(row)\r\n peers_table_widget.setItem(row, 0, QtWidgets.QTableWidgetItem(node_id))\r\n peers_table_widget.setItem(row, 1, QtWidgets.QTableWidgetItem(ip))\r\n time_delta_secs = time.time() - last_seen\r\n time_ago_str = f\"{int(time_delta_secs)}s ago\"\r\n peers_table_widget.setItem(row, 2, QtWidgets.QTableWidgetItem(time_ago_str))\r\n \r\n peer_status_str = \"Active\" if time_delta_secs < 20 else \"Inactive\" # Example threshold\r\n status_cell_item = QtWidgets.QTableWidgetItem(peer_status_str)\r\n status_cell_item.setForeground(QtGui.QBrush(QtGui.QColor(\"green\" if peer_status_str == \"Active\" else \"gray\")))\r\n peers_table_widget.setItem(row, 3, status_cell_item)\r\n peers_table_widget.resizeColumnsToContents()\r\n \r\n refresh_dashboard_data() # Initial population\r\n\r\n # Buttons\r\n button_box = QtWidgets.QDialogButtonBox()\r\n refresh_btn = button_box.addButton(\"Refresh\", QtWidgets.QDialogButtonBox.ActionRole)\r\n close_btn = button_box.addButton(QtWidgets.QDialogButtonBox.Close)\r\n refresh_btn.clicked.connect(refresh_dashboard_data)\r\n close_btn.clicked.connect(dashboard_dialog.accept)\r\n main_layout.addWidget(button_box)\r\n\r\n dashboard_dialog.exec_()\r\n\r\n\r\n def initialize_status_ui(self):\r\n \"\"\"Initializes UI components for displaying multiplayer status.\"\"\"\r\n if not self.logger: return\r\n try:\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface'):\r\n self.logger.warning(\"Status UI cannot be initialized - user_interface not found.\")\r\n return\r\n\r\n ui = self.tamagotchi_logic.user_interface\r\n try:\r\n from plugins.multiplayer.multiplayer_status_widget import MultiplayerStatusWidget\r\n if not hasattr(ui, '_mp_status_widget_instance_'): # Create if not exists\r\n ui._mp_status_widget_instance_ = MultiplayerStatusWidget(ui.window)\r\n # Position the widget (example: top-right corner)\r\n ui._mp_status_widget_instance_.move(\r\n ui.window.width() - ui._mp_status_widget_instance_.width() - 15, 15\r\n )\r\n ui._mp_status_widget_instance_.hide() # Initially hidden\r\n \r\n self.status_widget = ui._mp_status_widget_instance_\r\n if self.network_node and hasattr(self.status_widget, 'set_network_node_reference'):\r\n self.status_widget.set_network_node_reference(self.network_node)\r\n self.logger.info(\"Dedicated status widget initialized.\")\r\n\r\n except ImportError:\r\n self.logger.info(\"MultiplayerStatusWidget not found. Will attempt fallback status bar integration.\")\r\n self.initialize_status_bar() # Fallback\r\n except Exception as e_msw:\r\n self.logger.error(f\"Error initializing MultiplayerStatusWidget: {e_msw}. Using fallback.\", exc_info=True)\r\n self.initialize_status_bar() # Fallback\r\n\r\n except Exception as e:\r\n self.logger.error(f\"Could not initialize status UI: {e}\", exc_info=True)\r\n \r\n def initialize_status_bar(self): # Added stub, assuming it was missing\r\n \"\"\"Fallback to initialize status bar component if dedicated widget fails.\"\"\"\r\n if not self.logger: return\r\n self.logger.info(\"Attempting to initialize fallback status bar component.\")\r\n # Implementation for status_bar initialization would go here\r\n # For now, just log that it's a fallback\r\n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'user_interface') and \\\r\n hasattr(self.tamagotchi_logic.user_interface, 'statusBar'): # Example access\r\n self.status_bar = self.tamagotchi_logic.user_interface.statusBar()\r\n # Example: Add a permanent widget or label to the status bar\r\n # if self.status_bar and not hasattr(self, '_mp_status_label_basic'):\r\n # self._mp_status_label_basic = QtWidgets.QLabel(\"MP: Disconnected\")\r\n # self.status_bar.addPermanentWidget(self._mp_status_label_basic)\r\n self.logger.info(\"Fallback status bar component obtained.\")\r\n else:\r\n self.logger.warning(\"Fallback status bar component could not be obtained.\")\r\n\r\n\r\n def _find_tamagotchi_logic(self, search_object, depth=0, visited_ids=None):\r\n \"\"\"Recursively searches for an attribute named 'tamagotchi_logic'.\"\"\"\r\n if not self.logger: return None # Should not happen if called after setup\r\n if visited_ids is None: visited_ids = set()\r\n \r\n if id(search_object) in visited_ids or depth > 6: # Prevent deep recursion / cycles\r\n return None\r\n visited_ids.add(id(search_object))\r\n\r\n # Direct check: Is the search_object itself the TamagotchiLogic instance?\r\n if TamagotchiLogic and isinstance(search_object, TamagotchiLogic):\r\n return search_object\r\n \r\n # Check for a 'tamagotchi_logic' attribute specifically\r\n if hasattr(search_object, 'tamagotchi_logic'):\r\n tl_attr = getattr(search_object, 'tamagotchi_logic')\r\n if TamagotchiLogic and isinstance(tl_attr, TamagotchiLogic):\r\n return tl_attr\r\n \r\n # Iterate through attributes if it's not a basic type or module\r\n try:\r\n for attr_name in dir(search_object):\r\n if attr_name.startswith('_'): continue # Skip private/magic attributes\r\n\r\n try:\r\n attr_value = getattr(search_object, attr_name)\r\n \r\n # Avoid recursing into very common or problematic types\r\n if attr_value is None or isinstance(attr_value, (int, str, bool, float, list, dict, set, tuple, bytes)):\r\n continue\r\n if inspect.ismodule(attr_value) or inspect.isbuiltin(attr_value) or inspect.isroutine(attr_value):\r\n continue\r\n # Be careful with Qt parent traversals to avoid excessive depth or cycles\r\n if isinstance(attr_value, (QtWidgets.QWidget, QtCore.QObject)):\r\n if depth > 2 and attr_name in ['parent', 'parentWidget', 'parentItem']: # Limit depth for parent attributes\r\n continue\r\n \r\n found_logic = self._find_tamagotchi_logic(attr_value, depth + 1, visited_ids)\r\n if found_logic: return found_logic\r\n except (AttributeError, RecursionError, TypeError, ReferenceError): # Catch errors during getattr or recursion\r\n continue\r\n except (RecursionError, TypeError, ReferenceError): # Catch errors from dir() or initial checks\r\n pass # Could happen with problematic objects\r\n \r\n return None\r\n\r\n def _animate_remote_squid_entry(self, squid_graphics_item, status_text_item, entry_direction_str):\r\n \"\"\"MODIFIED: Animates (or rather, just shows) the visual entry of a remote squid.\"\"\"\r\n if not self.logger: return\r\n if not squid_graphics_item: return\r\n\r\n # Directly set opacity to full (or the plugin's setting)\r\n squid_graphics_item.setOpacity(self.REMOTE_SQUID_OPACITY) # REMOTE_SQUID_OPACITY is 1.0 for testing\r\n squid_graphics_item.setScale(1.0) # Ensure normal scale\r\n\r\n if squid_graphics_item.graphicsEffect(): # Remove any prior effect\r\n squid_graphics_item.setGraphicsEffect(None)\r\n\r\n if status_text_item:\r\n status_text_item.setOpacity(1.0) # Make status text fully visible\r\n if status_text_item.graphicsEffect(): # Remove any prior effect\r\n status_text_item.setGraphicsEffect(None)\r\n \r\n if self.debug_mode:\r\n self.logger.debug(f\"Static display for remote squid entry: {entry_direction_str}\")\r\n\r\n\r\n def get_opposite_direction(self, direction_str: str) -> str:\r\n \"\"\"Returns the opposite of a given cardinal direction string.\"\"\"\r\n opposites = {'left': 'right', 'right': 'left', 'up': 'down', 'down': 'up'}\r\n return opposites.get(direction_str.lower(), 'right') # Default if unknown\r\n\r\n def create_entry_effect(self, center_x: float, center_y: float, direction_str: str = \"\"):\r\n \"\"\"Creates a visual effect at the point where a remote squid enters the scene.\r\n MODIFIED: This effect will be static or very simple for testing.\"\"\"\r\n if not self.logger: return\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface'): return\r\n scene = self.tamagotchi_logic.user_interface.scene\r\n\r\n # Simplified static indicator (e.g., a small, briefly visible circle or text)\r\n # For testing, we can even skip this visual flourish if the goal is just to see the squid.\r\n if self.debug_mode:\r\n self.logger.debug(f\"Skipping dynamic entry effect for static testing at ({center_x},{center_y}).\")\r\n \r\n # If you still want a minimal static cue:\r\n # arrival_text_str = \"New Visitor\"\r\n # arrival_text_item = scene.addText(arrival_text_str)\r\n # arrival_font = QtGui.QFont(\"Arial\", 10, QtGui.QFont.Bold)\r\n # arrival_text_item.setFont(arrival_font)\r\n # text_metrics = QtGui.QFontMetrics(arrival_font)\r\n # text_rect = text_metrics.boundingRect(arrival_text_str)\r\n # arrival_text_item.setDefaultTextColor(QtGui.QColor(255, 215, 0)) # Gold\r\n # arrival_text_item.setPos(center_x - text_rect.width() / 2, center_y - 60) # Position above entry\r\n # arrival_text_item.setZValue(100)\r\n # arrival_text_item.setVisible(True)\r\n # # Timer to remove it after a short period if desired, or let it persist.\r\n # QtCore.QTimer.singleShot(3000, lambda: scene.removeItem(arrival_text_item) if arrival_text_item.scene() else None)\r\n\r\n def _setup_controller_immediately(self, node_id: str, squid_initial_data: Dict):\r\n \"\"\"Creates and initializes a RemoteSquidController.\"\"\"\r\n if not self.logger: return\r\n try:\r\n # from plugins.multiplayer.squid_multiplayer_autopilot import RemoteSquidController # Already at top\r\n pass # Ensure it's imported\r\n except ImportError:\r\n if self.debug_mode: self.logger.error(\"RemoteSquidController module not found. Remote squids will not be autonomous.\")\r\n return\r\n\r\n if node_id in self.remote_squid_controllers:\r\n if self.debug_mode: self.logger.debug(f\"Controller for squid {node_id[-6:]} already exists. Updating its data.\")\r\n # Ensure squid_data includes x,y if updating position via controller\r\n self.remote_squid_controllers[node_id].squid_data.update(squid_initial_data)\r\n # Potentially trigger a state re-evaluation in the controller if data changed significantly\r\n # self.remote_squid_controllers[node_id].evaluate_state() # If such a method exists\r\n return\r\n\r\n if self.debug_mode: self.logger.info(f\"Creating autopilot controller for remote squid {node_id[-6:]}.\")\r\n try:\r\n controller_instance = RemoteSquidController(\r\n squid_data=squid_initial_data, # This now contains x,y from entry_details if available\r\n scene=self.tamagotchi_logic.user_interface.scene,\r\n plugin_instance=self, # Pass self (MultiplayerPlugin instance)\r\n debug_mode=self.debug_mode,\r\n remote_entity_manager=self.entity_manager # Pass the entity manager\r\n )\r\n self.remote_squid_controllers[node_id] = controller_instance\r\n if self.debug_mode: self.logger.info(f\"Controller for {node_id[-6:]} created. Initial state: {getattr(controller_instance, 'state', 'N/A')}\")\r\n except Exception as e_create:\r\n self.logger.error(f\"Failed to create RemoteSquidController for {node_id[-6:]}: {e_create}\", exc_info=True)\r\n return\r\n \r\n # Ensure the controller update timer is running\r\n if self.controller_update_timer and not self.controller_update_timer.isActive():\r\n self.controller_update_timer.start()\r\n if self.debug_mode: self.logger.debug(\"Restarted controller update timer.\")\r\n\r\n\r\n def handle_squid_exit_message(self, node: Any, message: Dict, addr: tuple):\r\n \"\"\"\r\n We just received a 'squid_exit' multicast.\r\n Draw the giant exit-arrow and then create / update the remote squid visual.\r\n \"\"\"\r\n # ----- basic sanity / logging -----\r\n node_id_for_print = (getattr(self, 'config_manager', None) and\r\n getattr(self.config_manager, 'get_node_id', None) and\r\n self.config_manager.get_node_id()) or \\\r\n (self.network_node and self.network_node.node_id) or \"UnknownNode_HandleExit\"\r\n\r\n if self.debug_mode:\r\n print(f\"DEBUG_STEP_1: Node {node_id_for_print} - handle_squid_exit_message CALLED. \"\r\n f\"Message type: {message.get('type')}\")\r\n\r\n if not self.logger:\r\n print(\"MPPluginLogic ERRA: Logger not available in handle_squid_exit_message\")\r\n return False\r\n\r\n try:\r\n self.logger.info(f\"MY NODE ID {self.network_node.node_id if self.network_node else 'Unknown'} - \"\r\n f\"Received squid_exit message: {message} from {addr}\")\r\n\r\n exit_payload_outer = message.get('payload', {})\r\n exit_payload_inner = exit_payload_outer.get('payload') # actual exit_data\r\n if not exit_payload_inner:\r\n self.logger.warning(\"squid_exit message missing nested 'payload' key.\")\r\n return False\r\n\r\n source_node_id = exit_payload_inner.get('node_id')\r\n if not source_node_id:\r\n self.logger.warning(\"squid_exit inner payload missing 'node_id'.\")\r\n return False\r\n\r\n # ignore our own broadcast\r\n if self.network_node and source_node_id == self.network_node.node_id:\r\n self.logger.debug(f\"Ignoring own squid_exit broadcast for {source_node_id}.\")\r\n return False\r\n\r\n # ========== NEW: SHOW THE BIG EXIT ARROW ==========\r\n exit_dir = exit_payload_inner.get('direction', 'right')\r\n if self.debug_mode:\r\n self.logger.debug(f\"Showing exit arrow for direction: {exit_dir}\")\r\n self._show_exit_arrow(exit_dir)\r\n # ===================================================\r\n\r\n # create / update the remote squid visual\r\n if self.entity_manager:\r\n update_success = self.entity_manager.update_remote_squid(\r\n source_node_id, exit_payload_inner, is_new_arrival=True\r\n )\r\n if update_success and source_node_id not in self.remote_squid_controllers:\r\n self.logger.info(f\"Creating new autopilot for remote squid {source_node_id}\")\r\n entry_details = self.entity_manager.get_last_calculated_entry_details(source_node_id)\r\n initial_data = exit_payload_inner.copy()\r\n if entry_details:\r\n initial_data['x'], initial_data['y'] = entry_details['entry_pos']\r\n initial_data['entry_direction_on_this_screen'] = entry_details['entry_direction']\r\n\r\n autopilot_controller = RemoteSquidController(\r\n squid_data=initial_data,\r\n scene=self.tamagotchi_logic.user_interface.scene,\r\n plugin_instance=self,\r\n debug_mode=self.debug_mode,\r\n remote_entity_manager=self.entity_manager\r\n )\r\n self.remote_squid_controllers[source_node_id] = autopilot_controller\r\n self.logger.info(f\"Autopilot for {source_node_id} created.\")\r\n else:\r\n self.logger.warning(f\"Failed to create/update remote squid {source_node_id} in entity_manager.\")\r\n else:\r\n self.logger.error(\"Remote entity manager (self.entity_manager) not found!\")\r\n\r\n return True\r\n\r\n except Exception as e:\r\n self.logger.error(f\"Error in handle_squid_exit_message: {e}\", exc_info=True)\r\n return False\r\n\r\n def _setup_controller_creation_timer(self):\r\n \"\"\"(Fallback) Sets up a QTimer to process pending controller creations.\"\"\"\r\n if not self.logger: return\r\n if self.controller_creation_timer and self.controller_creation_timer.isActive():\r\n return # Already running\r\n if not self.controller_creation_timer:\r\n self.controller_creation_timer = QtCore.QTimer()\r\n self.controller_creation_timer.timeout.connect(self._process_pending_controller_creations)\r\n self.controller_creation_timer.start(300) # Check every 300ms\r\n if self.debug_mode: self.logger.debug(\"Fallback controller creation timer started.\")\r\n\r\n def _process_pending_controller_creations(self):\r\n \"\"\"(Fallback) Processes remote squids waiting for controllers.\"\"\"\r\n if not self.logger: return\r\n if not hasattr(self, 'pending_controller_creations') or not self.pending_controller_creations:\r\n return\r\n\r\n items_to_process = list(self.pending_controller_creations) # Copy for safe iteration\r\n self.pending_controller_creations.clear() # Clear original list\r\n\r\n for creation_task in items_to_process:\r\n node_id = creation_task.get('node_id')\r\n squid_data = creation_task.get('squid_data')\r\n if not node_id or not squid_data: continue\r\n\r\n if node_id not in self.remote_squid_controllers:\r\n if self.debug_mode: self.logger.debug(f\"Fallback: Creating controller for squid {node_id[-6:]}.\")\r\n self._setup_controller_immediately(node_id, squid_data)\r\n elif self.debug_mode:\r\n self.logger.debug(f\"Fallback: Controller for {node_id[-6:]} already exists, skipping duplicate creation.\")\r\n\r\n\r\n def update_remote_controllers(self):\r\n \"\"\"Called by a QTimer to update RemoteSquidController instances.\"\"\"\r\n if not self.logger:\r\n return\r\n\r\n # ---- TRACE ----\r\n if self.debug_mode:\r\n print(f\"TRACE ++++ MP_PLUGIN_LOGIC: update_remote_controllers METHOD ENTERED. \"\r\n f\"Num controllers: {len(self.remote_squid_controllers)} ++++\")\r\n self.logger.info(\"DEBUG_MPL_UPDATE: At start of update_remote_controllers. \"\r\n \"Current controllers: %s. Dict size: %s\",\r\n list(self.remote_squid_controllers.keys()),\r\n len(self.remote_squid_controllers))\r\n # -----------------\r\n\r\n if not hasattr(self, 'remote_squid_controllers') or not self.remote_squid_controllers:\r\n return\r\n\r\n current_time = time.time()\r\n delta_time = current_time - self.last_controller_update\r\n if delta_time <= 0.001:\r\n return\r\n self.last_controller_update = current_time\r\n\r\n for node_id, controller in list(self.remote_squid_controllers.items()):\r\n try:\r\n if self.debug_mode:\r\n print(f\"++++ MP_PLUGIN_LOGIC: Attempting to call update() for controller {node_id[-4:]} ++++\")\r\n controller.update(delta_time)\r\n except Exception as e:\r\n self.logger.error(f\"++++ MP_PLUGIN_LOGIC: Error updating controller for {node_id[-6:]}: {e}\", exc_info=True)\r\n\r\n\r\n def calculate_entry_position(self, entry_side_direction: str) -> tuple:\r\n \"\"\"Calculates X,Y coordinates for a squid entering this local screen.\"\"\"\r\n if not self.logger: return (100,100) # Default fallback\r\n if not self.tamagotchi_logic or not self.tamagotchi_logic.user_interface:\r\n return (100, 100) # Fallback if UI not available\r\n \r\n window_w = self.tamagotchi_logic.user_interface.window_width\r\n window_h = self.tamagotchi_logic.user_interface.window_height\r\n margin = 70 # How far from the edge it should appear\r\n\r\n if entry_side_direction == 'left': return (margin, window_h / 2)\r\n elif entry_side_direction == 'right':return (window_w - margin, window_h / 2)\r\n elif entry_side_direction == 'up': return (window_w / 2, margin)\r\n elif entry_side_direction == 'down': return (window_w / 2, window_h - margin)\r\n \r\n return (window_w / 2, window_h / 2) # Default to center if direction unknown\r\n\r\n\r\n def apply_remote_experiences(self, local_squid, activity_summary: Dict):\r\n \"\"\"Applies summarized experiences from a remote journey to the local squid.\"\"\"\r\n if not self.logger: return\r\n if not local_squid or not activity_summary: return\r\n\r\n food_eaten = activity_summary.get('food_eaten', 0)\r\n rocks_interacted = activity_summary.get('rock_interactions', 0)\r\n rocks_brought_back = activity_summary.get('rocks_stolen', 0)\r\n time_away_seconds = activity_summary.get('time_away', 0)\r\n time_str = f\"{int(time_away_seconds/60)}m {int(time_away_seconds%60)}s\"\r\n \r\n journey_desc = f\"Returned from a {time_str} journey to another tank. \"\r\n\r\n if hasattr(local_squid, 'memory_manager'):\r\n mm = local_squid.memory_manager\r\n if food_eaten > 0:\r\n journey_desc += f\"Ate {food_eaten} snacks there. \"\r\n local_squid.hunger = max(0, local_squid.hunger - 10 * food_eaten) # Reduce hunger\r\n mm.add_short_term_memory('travel', 'ate_on_trip', f\"Found {food_eaten} yummy treats on my trip!\", 5)\r\n if rocks_interacted > 0:\r\n journey_desc += f\"Played with {rocks_interacted} interesting rocks. \"\r\n local_squid.happiness = min(100, local_squid.happiness + 3 * rocks_interacted) # Increase happiness\r\n mm.add_short_term_memory('travel', 'played_on_trip', f\"Played with {rocks_interacted} cool rocks elsewhere!\", 4)\r\n \r\n mm.add_short_term_memory('travel', 'completed_journey', journey_desc, importance=7)\r\n\r\n if food_eaten > 1 or rocks_interacted > 3 or rocks_brought_back > 0:\r\n mm.add_short_term_memory('emotion', 'happy_return', \"It's great to be back home after an exciting adventure!\", 6)\r\n else:\r\n mm.add_short_term_memory('emotion', 'calm_return', \"Returned home. It was a quiet trip.\", 3)\r\n\r\n if hasattr(local_squid, 'curiosity'): # Reduce curiosity after travel\r\n local_squid.curiosity = max(0, local_squid.curiosity - 25)\r\n\r\n def create_exit_effect(self, center_x: float, center_y: float, direction_str: str = \"\"):\r\n \"\"\"Creates a visual effect when a local squid exits the screen.\r\n MODIFIED: This effect will be static or very simple for testing.\"\"\"\r\n if not self.logger: return\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface'): return\r\n # scene = self.tamagotchi_logic.user_interface.scene # Scene not used if no visual effects\r\n\r\n # Simplified static indicator (e.g., a small, briefly visible circle or text)\r\n if self.debug_mode:\r\n self.logger.debug(f\"Skipping dynamic exit effect for static testing at ({center_x},{center_y}).\")\r\n\r\n from PyQt5 import QtCore, QtGui, QtWidgets\r\n\r\n def _show_exit_arrow(self, exit_direction: str):\r\n \"\"\"\r\n Draw a big arrow flush with the screen edge the squid just left through.\r\n exit_direction : 'left' | 'right' | 'up' | 'down'\r\n \"\"\"\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface'):\r\n return\r\n ui = self.tamagotchi_logic.user_interface\r\n scene = ui.scene\r\n w, h = ui.window_width, ui.window_height\r\n colour = QtGui.QColor(255, 200, 0, 200) # juicy orange\r\n pen = QtGui.QPen(colour, 16)\r\n pen.setCapStyle(QtCore.Qt.RoundCap)\r\n pen.setJoinStyle(QtCore.Qt.RoundJoin)\r\n\r\n # ---------- geometry ----------\r\n shaft_len = min(w, h) * 0.55 # long shaft\r\n head_len = shaft_len * 0.30 # arrow-head\r\n shaft_wid = 24 # visual thickness\r\n\r\n if exit_direction == 'left': # leaving LEFT edge → arrow points LEFT\r\n shaft = QtCore.QLineF(shaft_len, h/2, 0, h/2)\r\n head1 = QtCore.QLineF(head_len, h/2 - head_len*0.6, 0, h/2)\r\n head2 = QtCore.QLineF(head_len, h/2 + head_len*0.6, 0, h/2)\r\n elif exit_direction == 'right': # leaving RIGHT edge → arrow points RIGHT\r\n shaft = QtCore.QLineF(w - shaft_len, h/2, w, h/2)\r\n head1 = QtCore.QLineF(w - head_len, h/2 - head_len*0.6, w, h/2)\r\n head2 = QtCore.QLineF(w - head_len, h/2 + head_len*0.6, w, h/2)\r\n elif exit_direction == 'up': # leaving TOP edge → arrow points UP\r\n shaft = QtCore.QLineF(w/2, shaft_len, w/2, 0)\r\n head1 = QtCore.QLineF(w/2 - head_len*0.6, head_len, w/2, 0)\r\n head2 = QtCore.QLineF(w/2 + head_len*0.6, head_len, w/2, 0)\r\n else: # leaving BOTTOM edge → arrow points DOWN\r\n shaft = QtCore.QLineF(w/2, h - shaft_len, w/2, h)\r\n head1 = QtCore.QLineF(w/2 - head_len*0.6, h - head_len, w/2, h)\r\n head2 = QtCore.QLineF(w/2 + head_len*0.6, h - head_len, w/2, h)\r\n\r\n # ---------- draw ----------\r\n group = QtWidgets.QGraphicsItemGroup()\r\n group.setZValue(1000) # on top of everything\r\n for line in (shaft, head1, head2):\r\n group.addToGroup(scene.addLine(line, pen))\r\n scene.addItem(group)\r\n\r\n # ---------- fade & self-destruct ----------\r\n def fade():\r\n opacity = group.opacity()\r\n if opacity > 0.01:\r\n group.setOpacity(max(0, opacity - 0.04))\r\n else:\r\n scene.removeItem(group)\r\n fade_timer.stop()\r\n\r\n fade_timer = QtCore.QTimer()\r\n fade_timer.timeout.connect(fade)\r\n fade_timer.start(40) # ~25 fps → gone in ~2 s\r\n\r\n def handle_squid_return(self, node: NetworkNode, message: Dict, addr: tuple):\r\n \"\"\"Handles a 'squid_return' message for the player's own squid.\"\"\"\r\n if not self.logger: return\r\n try:\r\n return_payload = message.get('payload', {})\r\n returning_node_id = return_payload.get('node_id')\r\n\r\n if not self.network_node or returning_node_id != self.network_node.node_id:\r\n if self.debug_mode:\r\n expected_id = self.network_node.node_id if self.network_node else \"N/A\"\r\n self.logger.debug(f\"Squid_return message ignored. Expected node '{expected_id}', got '{returning_node_id}'.\")\r\n return\r\n\r\n local_squid = self.tamagotchi_logic.squid\r\n if not local_squid or not local_squid.squid_item:\r\n if self.debug_mode: self.logger.debug(\"Local squid or its visual item not found for return.\")\r\n return\r\n\r\n activity_summary = return_payload.get('activity_summary', {})\r\n entry_side = return_payload.get('return_direction', 'left') \r\n entry_coords = self.calculate_entry_position(entry_side)\r\n\r\n local_squid.squid_x, local_squid.squid_y = entry_coords[0], entry_coords[1]\r\n local_squid.squid_item.setPos(local_squid.squid_x, local_squid.squid_y)\r\n local_squid.squid_item.setVisible(True)\r\n local_squid.squid_item.setOpacity(1.0)\r\n if local_squid.squid_item.graphicsEffect():\r\n local_squid.squid_item.graphicsEffect().setEnabled(False)\r\n local_squid.squid_item.setGraphicsEffect(None)\r\n\r\n self.apply_remote_experiences(local_squid, activity_summary)\r\n\r\n # --- MODIFICATION FOR DETAILED ITEM RECREATION ---\r\n carried_items_details_list = activity_summary.get('carried_items_details', [])\r\n num_items_brought_back = len(carried_items_details_list) # Or use 'rocks_stolen' if it reliably matches the list length\r\n\r\n if num_items_brought_back > 0:\r\n self.logger.info(f\"Local squid returned carrying {num_items_brought_back} item(s). Details: {carried_items_details_list}\")\r\n # We'll create/modify this method in the next step:\r\n self.recreate_carried_items_in_tank(local_squid, carried_items_details_list, entry_coords)\r\n \r\n if hasattr(self.tamagotchi_logic, 'show_message'):\r\n self.tamagotchi_logic.show_message(f\"Your squid returned with {num_items_brought_back} item(s) from its adventure!\")\r\n else:\r\n # ... (existing message for no items stolen) ...\r\n if hasattr(self.tamagotchi_logic, 'show_message'):\r\n journey_time_sec = activity_summary.get('time_away', 0)\r\n time_str = f\"{int(journey_time_sec/60)}m {int(journey_time_sec%60)}s\"\r\n self.tamagotchi_logic.show_message(f\"Welcome back! Your squid explored for {time_str}.\")\r\n \r\n local_squid.can_move = True\r\n if hasattr(local_squid, 'is_transitioning'): local_squid.is_transitioning = False\r\n local_squid.status = \"just returned home\"\r\n\r\n if self.debug_mode: self.logger.debug(f\"Local squid '{getattr(local_squid,'name','')}' returned to {entry_coords} from {entry_side}. Brought back {num_items_brought_back} items.\")\r\n\r\n except Exception as e:\r\n self.logger.error(f\"Handling local squid's return failed: {e}\", exc_info=True)\r\n\r\n def recreate_carried_items_in_tank(self, local_squid, carried_items_data_list: List[Dict], entry_position: tuple):\r\n \"\"\"\r\n Recreates items in the local scene based on detailed data brought back by the squid.\r\n The first item is given to the squid to carry; subsequent items are placed in the tank.\r\n \"\"\"\r\n if not self.logger:\r\n print(\"MPPluginLogic ERRA: Logger not available in recreate_carried_items_in_tank\")\r\n return\r\n if not self.tamagotchi_logic or not hasattr(self.tamagotchi_logic, 'user_interface') or not carried_items_data_list:\r\n self.logger.warning(\"Cannot recreate carried items: TamagotchiLogic, UI, or item data missing.\")\r\n return\r\n \r\n ui = self.tamagotchi_logic.user_interface\r\n scene = ui.scene\r\n entry_x, entry_y = entry_position\r\n\r\n self.logger.info(f\"Recreating {len(carried_items_data_list)} item(s) brought back by squid {local_squid.name if hasattr(local_squid, 'name') else 'N/A'}.\")\r\n\r\n item_successfully_given_to_squid_to_carry = False\r\n\r\n for i, item_data in enumerate(carried_items_data_list):\r\n try:\r\n original_filename = item_data.get('original_filename')\r\n original_category = item_data.get('original_category', 'decoration') # Default if not specified\r\n item_scale = item_data.get('scale', 1.0)\r\n # Use original_zValue if provided, otherwise default (e.g. for decorations)\r\n # Add a small positive bias if it's going to be carried to appear above squid if at same base Z\r\n item_z_value = item_data.get('zValue', 0) \r\n\r\n\r\n if not original_filename:\r\n self.logger.warning(f\"Skipping item recreation: 'original_filename' missing in item data: {item_data}\")\r\n continue\r\n\r\n # --- Asset Path Resolution ---\r\n # This logic attempts to find the image based on the original_filename.\r\n # It assumes original_filename might be a base name or include a subfolder like \"decoration/\".\r\n possible_paths = [\r\n os.path.join(\"images\", original_filename), \r\n os.path.join(\"images\", \"decoration\", os.path.basename(original_filename)),\r\n os.path.join(\"images\", \"items\", os.path.basename(original_filename)),\r\n os.path.join(\"images\", \"food\", os.path.basename(original_filename)), # If food can be carried\r\n os.path.join(\"images\", \"rocks\", os.path.basename(original_filename)), # If rocks are in subfolder\r\n original_filename # If original_filename was already a relative path like \"images/foo.png\"\r\n ]\r\n \r\n item_image_path = None\r\n for p_path in possible_paths:\r\n # Normalize path for consistent checking\r\n normalized_path = os.path.normpath(p_path)\r\n if os.path.exists(normalized_path):\r\n item_image_path = normalized_path\r\n break\r\n \r\n if not item_image_path:\r\n self.logger.warning(f\"Could not find local image asset for '{original_filename}'. Attempting fallback to default rock/item.\")\r\n # Fallback to a generic rock image if specific image not found\r\n item_image_path = os.path.join(\"images\", \"rock.png\") # Default fallback\r\n if not os.path.exists(item_image_path):\r\n self.logger.error(f\"Default fallback image 'images/rock.png' also not found. Cannot recreate item.\")\r\n continue # Skip this item\r\n original_category = 'rock' # Override category if using fallback rock\r\n\r\n self.logger.info(f\"Attempting to recreate item {i+1}: Path='{item_image_path}', Category='{original_category}', Scale={item_scale:.2f}\")\r\n\r\n pixmap = QtGui.QPixmap(item_image_path)\r\n if pixmap.isNull():\r\n self.logger.error(f\"Failed to load QPixmap for item image: '{item_image_path}'\")\r\n continue\r\n\r\n # --- Item Creation ---\r\n created_item_visual = None\r\n if hasattr(ui, 'ResizablePixmapItem'):\r\n created_item_visual = ui.ResizablePixmapItem(pixmap, item_image_path)\r\n else:\r\n created_item_visual = QtWidgets.QGraphicsPixmapItem(pixmap)\r\n setattr(created_item_visual, 'filename', item_image_path)\r\n \r\n setattr(created_item_visual, 'category', original_category)\r\n created_item_visual.setScale(item_scale)\r\n # ZValue for carried item will be handled by squid logic to be on top\r\n # ZValue for placed items will use item_z_value\r\n # setattr(created_item_visual, 'original_zValue', item_z_value) # Store for later placement\r\n\r\n setattr(created_item_visual, 'is_stolen_from_remote', True)\r\n setattr(created_item_visual, 'is_foreign', True)\r\n self.apply_foreign_object_tint(created_item_visual)\r\n \r\n # Add to scene so it's managed by Qt, positions will be updated\r\n scene.addItem(created_item_visual)\r\n\r\n if not item_successfully_given_to_squid_to_carry and hasattr(local_squid, 'start_carrying_item'):\r\n # The first successfully created item is given to the squid to carry\r\n created_item_visual.setZValue(local_squid.squid_item.zValue() + 0.1) # Ensure it's visually above squid slightly\r\n local_squid.start_carrying_item(created_item_visual)\r\n item_successfully_given_to_squid_to_carry = True\r\n self.logger.info(f\"Squid '{local_squid.name}' is now carrying '{os.path.basename(item_image_path)}'.\")\r\n else:\r\n # Subsequent items, or if squid can't carry, place them in the tank\r\n if not hasattr(local_squid, 'start_carrying_item'):\r\n self.logger.warning(f\"Squid object does not have 'start_carrying_item' method. Placing item '{os.path.basename(item_image_path)}' near entry.\")\r\n else:\r\n self.logger.info(f\"Placing additional item '{os.path.basename(item_image_path)}' directly in tank.\")\r\n\r\n created_item_visual.setZValue(item_z_value) # Use its original/default Z for placed items\r\n \r\n # Scatter these additional items around the entry point\r\n angle_offset = random.uniform(-math.pi / 2, math.pi / 2) \r\n # Use 'i' to ensure different angle for each subsequent item\r\n angle = (i * (math.pi / max(1, len(carried_items_data_list) -1 ))) + angle_offset \r\n dist_from_entry = random.uniform(80, 150) # Slightly further for placed items\r\n \r\n item_x = entry_x + dist_from_entry * math.cos(angle)\r\n item_y = entry_y + dist_from_entry * math.sin(angle)\r\n \r\n item_w = pixmap.width() * item_scale\r\n item_h = pixmap.height() * item_scale\r\n # Basic boundary check\r\n item_x = max(item_w/2, min(item_x, ui.window_width - item_w/2))\r\n item_y = max(item_h/2, min(item_y, ui.window_height - item_h/2))\r\n\r\n created_item_visual.setPos(item_x - item_w/2, item_y - item_h/2)\r\n created_item_visual.setOpacity(1.0) # Ensure visible\r\n\r\n # Add memory for each successfully recreated item\r\n if hasattr(local_squid, 'memory_manager'):\r\n local_squid.memory_manager.add_short_term_memory(\r\n 'achievement', f'brought_back_{original_category}',\r\n f\"Brought back a {os.path.basename(item_image_path)} from an adventure!\", importance=6\r\n )\r\n\r\n except Exception as e:\r\n self.logger.error(f\"Error processing and recreating a carried item from data '{item_data}': {e}\", exc_info=True)\r\n\r\n def _create_arrival_animation(self, graphics_item: QtWidgets.QGraphicsPixmapItem):\r\n \"\"\"MODIFIED: Creates a simple fade-in animation (now static) for newly arrived remote items.\"\"\"\r\n if not self.logger: return\r\n if not graphics_item: return\r\n try:\r\n # For static testing, just ensure opacity and scale are correct\r\n target_opacity = self.REMOTE_SQUID_OPACITY # Should be 1.0\r\n if hasattr(graphics_item, 'is_remote_clone') and getattr(graphics_item, 'is_remote_clone'):\r\n # Cloned objects might have a slightly different base opacity if desired, but for squid, full.\r\n pass # target_opacity *= 0.75 (example if clones were different)\r\n \r\n graphics_item.setOpacity(target_opacity)\r\n graphics_item.setScale(1.0) # Ensure normal scale\r\n\r\n if graphics_item.graphicsEffect(): # Remove any prior opacity effect\r\n graphics_item.setGraphicsEffect(None)\r\n\r\n except Exception as e:\r\n if self.debug_mode: self.logger.warning(f\"Simple static arrival display error: {e}\")\r\n if graphics_item: graphics_item.setOpacity(self.REMOTE_SQUID_OPACITY) # Fallback\r\n\r\n\r\n def _reset_remote_squid_style(self, node_id_or_item):\r\n \"\"\"Resets the visual style of a remote squid to default (static, full opacity).\"\"\"\r\n if not self.logger: return\r\n node_id = None\r\n squid_display_data = None\r\n\r\n if isinstance(node_id_or_item, str): # If node_id is passed\r\n node_id = node_id_or_item\r\n squid_display_data = self.remote_squids.get(node_id)\r\n elif isinstance(node_id_or_item, QtWidgets.QGraphicsPixmapItem): # If visual item is passed\r\n for nid, s_data in self.remote_squids.items():\r\n if s_data.get('visual') == node_id_or_item:\r\n node_id = nid\r\n squid_display_data = s_data\r\n break\r\n \r\n if not squid_display_data: return # Squid not found\r\n\r\n visual_item = squid_display_data.get('visual')\r\n status_text_item = squid_display_data.get('status_text')\r\n id_text_item = squid_display_data.get('id_text')\r\n\r\n if visual_item:\r\n visual_item.setZValue(5) # Default Z-order for remote squids\r\n visual_item.setOpacity(self.REMOTE_SQUID_OPACITY) # Ensure full opacity\r\n visual_item.setScale(1.0) # Ensure normal scale\r\n if visual_item.graphicsEffect(): # Remove any effects (like shadow or previous opacity effects)\r\n visual_item.setGraphicsEffect(None)\r\n \r\n # Reset status text style\r\n if status_text_item:\r\n current_status_from_data = squid_display_data.get('data', {}).get('status', 'visiting')\r\n status_text_item.setPlainText(current_status_from_data)\r\n status_text_item.setDefaultTextColor(QtGui.QColor(200, 200, 200, 220)) # Default color\r\n status_text_item.setFont(QtGui.QFont(\"Arial\", 9)) # Default font\r\n status_text_item.setZValue(6) # Above squid\r\n\r\n # Reset ID text style (usually less dynamic)\r\n if id_text_item:\r\n id_text_item.setDefaultTextColor(QtGui.QColor(200, 200, 200, 180))\r\n id_text_item.setFont(QtGui.QFont(\"Arial\", 8))\r\n id_text_item.setZValue(6)\r\n\r\n\r\n def register_menu_actions(self, main_ui_window: QtWidgets.QMainWindow, target_menu: QtWidgets.QMenu):\r\n \"\"\"Registers menu actions related to the multiplayer plugin.\"\"\"\r\n if not self.logger: return\r\n\r\n about_action = QtWidgets.QAction(f\"About {mp_constants.PLUGIN_NAME}...\", main_ui_window)\r\n about_action.triggered.connect(self.show_about_dialog)\r\n target_menu.addAction(about_action)\r\n\r\n config_action = QtWidgets.QAction(\"Network Settings...\", main_ui_window)\r\n config_action.triggered.connect(self.show_config_dialog)\r\n target_menu.addAction(config_action)\r\n\r\n dashboard_action = QtWidgets.QAction(\"Network Dashboard...\", main_ui_window)\r\n dashboard_action.triggered.connect(self.show_network_dashboard)\r\n target_menu.addAction(dashboard_action)\r\n \r\n target_menu.addSeparator()\r\n\r\n refresh_connections_action = QtWidgets.QAction(\"Refresh Connections\", main_ui_window)\r\n refresh_connections_action.triggered.connect(self.refresh_connections)\r\n target_menu.addAction(refresh_connections_action)\r\n\r\n # Toggle for connection lines\r\n self.mp_menu_toggle_connection_lines_action = QtWidgets.QAction(\"Show Connection Lines\", main_ui_window)\r\n self.mp_menu_toggle_connection_lines_action.setCheckable(True)\r\n self.mp_menu_toggle_connection_lines_action.setChecked(self.SHOW_CONNECTION_LINES)\r\n self.mp_menu_toggle_connection_lines_action.triggered.connect(self.toggle_connection_lines)\r\n target_menu.addAction(self.mp_menu_toggle_connection_lines_action)\r\n \r\n if self.debug_mode: # Debug specific actions\r\n target_menu.addSeparator()\r\n debug_autopilot_action = QtWidgets.QAction(\"Debug Autopilot Status\", main_ui_window)\r\n debug_autopilot_action.triggered.connect(self.debug_autopilot_status)\r\n target_menu.addAction(debug_autopilot_action)\r\n\r\n\r\n def update_menu_states(self):\r\n \"\"\"Updates the state of checkable menu items.\"\"\"\r\n if hasattr(self, 'mp_menu_toggle_connection_lines_action'):\r\n self.mp_menu_toggle_connection_lines_action.setChecked(self.SHOW_CONNECTION_LINES)\r\n\r\n\r\n def show_about_dialog(self):\r\n \"\"\"Displays an 'About' dialog.\"\"\"\r\n if not self.logger: return\r\n parent_window = None\r\n if self.tamagotchi_logic and hasattr(self.tamagotchi_logic, 'user_interface'):\r\n parent_window = self.tamagotchi_logic.user_interface.window\r\n \r\n node_id_str = getattr(self.network_node, 'node_id', \"N/A\") if self.network_node else \"N/A\"\r\n ip_str = getattr(self.network_node, 'local_ip', \"N/A\") if self.network_node else \"N/A\"\r\n status_str = \"Connected\" if self.network_node and self.network_node.is_connected else \"Disconnected\"\r\n\r\n about_text_content = (\r\n f\"
\n \"\"\"\n about_text.setHtml(about_html)\n \n # Create a custom widget for the badge\n badge_widget = QtWidgets.QWidget()\n badge_layout = QtWidgets.QVBoxLayout(badge_widget)\n badge_layout.setContentsMargins(0, 0, 0, 0)\n badge_layout.setSpacing(0)\n \n # Badge container\n badge_container = QtWidgets.QWidget()\n badge_container.setFixedWidth(DisplayScaling.scale(300))\n badge_container.setStyleSheet(\"\"\"\n background-color: white;\n border: 4px solid #FF0000;\n border-radius: 5px;\n \"\"\")\n \n badge_inner_layout = QtWidgets.QVBoxLayout(badge_container)\n badge_inner_layout.setContentsMargins(0, 0, 0, 0)\n badge_inner_layout.setSpacing(0)\n \n # \"HELLO\" label\n hello_label = QtWidgets.QLabel(self.loc.get(\"hello\"))\n hello_label.setAlignment(QtCore.Qt.AlignCenter)\n hello_label.setStyleSheet(f\"\"\"\n font-family: Arial, sans-serif;\n font-size: {DisplayScaling.font_size(38)}px;\n font-weight: bold;\n color: #FFFFFF;\n background-color: #FF0000;\n \"\"\")\n badge_inner_layout.addWidget(hello_label)\n \n # \"my name is...\" label\n my_name_label = QtWidgets.QLabel(self.loc.get(\"my_name_is\"))\n my_name_label.setAlignment(QtCore.Qt.AlignCenter)\n my_name_label.setStyleSheet(f\"\"\"\n font-family: Arial, sans-serif;\n font-size: {DisplayScaling.font_size(20)}px;\n color: #FFFFFF;\n background-color: #FF0000;\n \"\"\")\n badge_inner_layout.addWidget(my_name_label)\n \n # Name label - editable on double-click\n self.name_label = QtWidgets.QLabel(squid_name)\n self.name_label.setAlignment(QtCore.Qt.AlignCenter)\n self.name_label.setStyleSheet(f\"\"\"\n font-family: Arial, sans-serif;\n font-size: {DisplayScaling.font_size(38)}px;\n font-weight: bold;\n color: #000000;\n background-color: white;\n \"\"\")\n self.name_label.mouseDoubleClickEvent = lambda event: self.edit_name()\n self.name_label.setToolTip(self.loc.get(\"change_name\")) \n self.name_label.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))\n badge_inner_layout.addWidget(self.name_label)\n \n badge_layout.addWidget(badge_container, alignment=QtCore.Qt.AlignHCenter)\n \n # Add personality information below the badge\n personality_container = QtWidgets.QWidget()\n personality_layout = QtWidgets.QVBoxLayout(personality_container)\n personality_layout.setContentsMargins(DisplayScaling.scale(10), DisplayScaling.scale(20), DisplayScaling.scale(10), DisplayScaling.scale(10))\n \n # Personality label - store reference for updates\n # Using \"squid_personality\" key\n self.personality_label = QtWidgets.QLabel(f\"{self.loc.get('squid_personality')}: {display_personality}\")\n self.personality_label.setAlignment(QtCore.Qt.AlignCenter)\n self.personality_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(22)}px;\")\n personality_layout.addWidget(self.personality_label)\n \n # Button container\n button_container = QtWidgets.QWidget()\n button_layout = QtWidgets.QHBoxLayout(button_container)\n button_layout.setContentsMargins(0, DisplayScaling.scale(10), 0, 0)\n\n # Add stretchable space to the left\n button_layout.addStretch()\n\n # Add Certificate button\n certificate_button = QtWidgets.QPushButton(self.loc.get(\"view_certificate\"))\n certificate_button.clicked.connect(self.show_certificate)\n certificate_button.setStyleSheet(f\"font-size: {DisplayScaling.font_size(18)}px; padding: {DisplayScaling.scale(12)}px;\")\n # button_layout.addWidget(certificate_button) \n\n # Add color picker button\n color_button = QtWidgets.QPushButton(self.loc.get(\"change_colour\")) \n color_button.clicked.connect(self.open_color_picker)\n color_button.setStyleSheet(f\"font-size: {DisplayScaling.font_size(18)}px; padding: {DisplayScaling.scale(12)}px; background-color: #FFC0CB;\") \n button_layout.addWidget(color_button)\n\n # Add stretchable space to the right\n button_layout.addStretch()\n\n # Add button container to personality layout\n personality_layout.addWidget(button_container)\n\n # Add all widgets to the main layout\n self.layout.addWidget(about_text)\n self.layout.addWidget(badge_widget)\n self.layout.addWidget(personality_container)\n \n print(f\"AboutTab initialization complete - Personality: {display_personality}\")\n\n def open_color_picker(self):\n color = QtWidgets.QColorDialog.getColor()\n if color.isValid():\n if self.tamagotchi_logic and self.tamagotchi_logic.squid:\n self.tamagotchi_logic.squid.apply_tint(color)\n if hasattr(self.tamagotchi_logic, 'brain_window') and \\\n hasattr(self.tamagotchi_logic.brain_window, 'statistics_tab'):\n self.tamagotchi_logic.brain_window.statistics_tab.increment_stat('times_colour_changed')\n\n def edit_name(self):\n \"\"\"Allow user to edit squid name on double-click\"\"\"\n if not hasattr(self, 'name_label'):\n return\n\n current_name = self.name_label.text()\n new_name, ok = QtWidgets.QInputDialog.getText(\n self, \n self.loc.get(\"change_name\"), \n self.loc.get(\"enter_new_name\"),\n QtWidgets.QLineEdit.Normal, \n current_name\n )\n if ok and new_name:\n self.name_label.setText(new_name)\n # Update the squid's name\n if hasattr(self.tamagotchi_logic, 'squid') and self.tamagotchi_logic.squid:\n self.tamagotchi_logic.squid.name = new_name\n\n def show_certificate(self):\n \"\"\"Show the squid certificate window\"\"\"\n try:\n from .certificate import SquidCertificateWindow\n\n if not hasattr(self, 'certificate_window') or self.certificate_window is None:\n self.certificate_window = SquidCertificateWindow(self, self.tamagotchi_logic)\n else:\n self.certificate_window.update_certificate()\n\n self.certificate_window.show()\n self.certificate_window.raise_()\n except Exception as e:\n print(f\"Error showing certificate: {e}\")\n import traceback\n traceback.print_exc()\n\n def show_care_tips(self, personality_type_raw):\n \"\"\"Show care tips for the specific personality type\"\"\"\n # Ensure we are working with the raw string key (e.g., 'timid')\n personality_type_raw = str(personality_type_raw).lower()\n \n # Get localized name and tips\n localized_name = self.loc.get_personality_name(personality_type_raw)\n tips = self.get_care_tips(personality_type_raw)\n\n # Create a dialog to display the tips\n dialog = QtWidgets.QDialog(self)\n dialog.setWindowTitle(f\"{self.loc.get('care_tips')}: {localized_name}\")\n dialog.setMinimumSize(600, 800)\n\n layout = QtWidgets.QVBoxLayout(dialog)\n\n # Add a title\n # Uses format string \"Care Tips for {personality} Squids\"\n title_text = self.loc.get(\"care_tips_for\", personality=localized_name)\n title = QtWidgets.QLabel(title_text)\n title.setStyleSheet(\"font-size: 20px; font-weight: bold; margin-bottom: 15px;\")\n title.setAlignment(QtCore.Qt.AlignCenter)\n layout.addWidget(title)\n\n # Add the tips content\n tips_text = QtWidgets.QTextEdit()\n tips_text.setReadOnly(True)\n\n font = tips_text.font()\n font.setPointSize(12)\n tips_text.setFont(font)\n\n tips_text.setPlainText(tips)\n tips_text.setStyleSheet(\"line-height: 1.6;\")\n layout.addWidget(tips_text)\n\n # Add a close button\n close_button = QtWidgets.QPushButton(self.loc.get(\"close\"))\n close_button.clicked.connect(dialog.close)\n close_button.setFixedWidth(150)\n close_button.setStyleSheet(\"font-size: 18px; padding: 8px;\")\n layout.addWidget(close_button, alignment=QtCore.Qt.AlignRight)\n\n dialog.exec_()\n\n def get_care_tips(self, personality_type):\n \"\"\"Return care tips for a specific personality type using Localisation\"\"\"\n # This now delegates entirely to the Localisation class which handles languages\n return self.loc.get_care_tips(personality_type)\n\n def get_version_info(self):\n \"\"\"Read version information from the version file\"\"\"\n version_info = {\n \"dosidicus\": \"Dosidicus-2 2.6.2.0 STRINg2\",\n \"brain_tool\": \"06.03.26\",\n \"decision_engine\": \"4.0\",\n \"neurogenesis\": \"ver3_unified\"\n }\n\n try:\n # Look for version file in the project root\n version_file = os.path.join(os.path.dirname(__file__), '..', 'version')\n if os.path.exists(version_file):\n with open(version_file, 'r') as f:\n for line in f:\n if ':' in line:\n key, value = line.split(':', 1)\n key = key.strip().lower()\n value = value.strip()\n if key in version_info:\n version_info[key] = value\n except Exception as e:\n print(f\"Error reading version file: {e}\")\n\n return version_info\n"
},
{
"path": "src/brain_base_tab.py",
"content": "from PyQt5 import QtCore, QtGui, QtWidgets\nfrom .display_scaling import DisplayScaling\n\nclass BrainBaseTab(QtWidgets.QWidget):\n def __init__(self, parent=None, tamagotchi_logic=None, brain_widget=None, config=None, debug_mode=False):\n super().__init__(parent)\n self.parent = parent\n self.tamagotchi_logic = tamagotchi_logic\n self.brain_widget = brain_widget\n self.config = config\n self.debug_mode = debug_mode\n self.layout = QtWidgets.QVBoxLayout()\n self.setLayout(self.layout)\n\n # Set an explicit base font so all child widgets inherit a consistent\n # size regardless of platform defaults (important for Nuitka builds\n # where Qt may resolve a smaller system font than CPython does).\n base_font = QtGui.QFont()\n base_font.setPointSize(DisplayScaling.font_size(10))\n self.setFont(base_font)\n\n def set_tamagotchi_logic(self, tamagotchi_logic):\n \"\"\"Update the tamagotchi_logic reference\"\"\"\n #print(f\"BrainBaseTab.set_tamagotchi_logic: {tamagotchi_logic is not None}\")\n self.tamagotchi_logic = tamagotchi_logic\n \n def update_from_brain_state(self, state):\n \"\"\"Update tab based on brain state - override in subclasses\"\"\"\n pass\n \n def create_button(self, text, callback, color):\n \"\"\"Common utility for creating consistent buttons\"\"\"\n button = QtWidgets.QPushButton(text)\n button.clicked.connect(callback)\n button.setStyleSheet(f\"background-color: {color}; border: 1px solid black; padding: 5px;\")\n button.setFixedSize(200, 50)\n return button\n \n \n\n\n"
},
{
"path": "src/brain_constants.py",
"content": "\"\"\"\r\nbrain_constants.py - Shared constants for Dosidicus-2 brain system\r\n\r\nThis file defines the canonical neuron categories used across:\r\n- brain_widget.py\r\n- brain_tool.py \r\n- brain_designer.py\r\n- brain_neuron_hooks.py\r\n\r\nImport from here to ensure consistency.\r\n\"\"\"\r\n\r\n# =============================================================================\r\n# REQUIRED NEURONS - Mandatory for all brain designs\r\n# These 8 neurons MUST exist in any valid Dosidicus brain.\r\n# =============================================================================\r\n\r\n# Core stat neurons - positions match brain_widget.py's original_neuron_positions\r\nCORE_NEURONS = {\r\n \"hunger\": (127, 81),\r\n \"happiness\": (361, 81),\r\n \"cleanliness\": (627, 81),\r\n \"sleepiness\": (840, 81),\r\n \"satisfaction\": (271, 380),\r\n \"anxiety\": (491, 389),\r\n \"curiosity\": (701, 386),\r\n}\r\n\r\n# can_see_food is MANDATORY - the squid must be able to see food\r\n# This is separate from optional sensors because it's required for basic functionality\r\nMANDATORY_SENSOR = {\r\n \"can_see_food\": (50, 200),\r\n}\r\n\r\n# All required neurons combined (7 core + 1 mandatory sensor)\r\nREQUIRED_NEURONS = {**CORE_NEURONS, **MANDATORY_SENSOR}\r\n\r\n# Ordered list for consistent iteration\r\nCORE_NEURON_NAMES = [\r\n \"hunger\", \"happiness\", \"cleanliness\", \"sleepiness\",\r\n \"satisfaction\", \"anxiety\", \"curiosity\"\r\n]\r\n\r\nREQUIRED_NEURON_NAMES = CORE_NEURON_NAMES + [\"can_see_food\"]\r\n\r\n# =============================================================================\r\n# INPUT SENSORS - Optional neurons that receive values from game state\r\n# These neurons get their activation from BrainNeuronHooks, not from\r\n# neural propagation. They represent environmental/state observations.\r\n# NOTE: can_see_food is NOT here - it's in REQUIRED_NEURONS\r\n# =============================================================================\r\nINPUT_SENSORS = {\r\n \"external_stimulus\": (50, 50), # Environmental changes (resize, interactions)\r\n \"plant_proximity\": (50, 250), # Distance to nearest plant decoration\r\n \"threat_level\": (50, 350), # Computed from anxiety + startle state\r\n \"pursuing_food\": (150, 50), # Currently chasing food\r\n \"is_sick\": (150, 150), # Sickness state\r\n \"is_fleeing\": (150, 250), # Currently fleeing\r\n \"is_eating\": (150, 350), # Currently eating\r\n \"is_sleeping\": (250, 50), # Currently sleeping\r\n \"is_startled\": (250, 150), # Startled state\r\n}\r\n\r\n# Tuple for compatibility with brain_neuron_hooks.py (includes can_see_food)\r\nDEFAULT_INPUT_SENSORS = (\r\n 'external_stimulus',\r\n 'can_see_food', # Listed here for hooks compatibility but it's mandatory\r\n 'plant_proximity',\r\n 'threat_level',\r\n 'pursuing_food',\r\n 'is_sick',\r\n 'is_fleeing',\r\n 'is_eating',\r\n 'is_sleeping',\r\n 'is_startled',\r\n)\r\n\r\n# =============================================================================\r\n# BINARY NEURONS - Neurons that should display as on/off (0 or 100)\r\n# These use bright green/red coloring instead of gradient heat maps.\r\n# =============================================================================\r\nBINARY_NEURONS = {\r\n 'can_see_food',\r\n 'is_eating',\r\n 'is_sleeping',\r\n 'is_sick',\r\n 'pursuing_food',\r\n 'is_fleeing',\r\n 'is_startled',\r\n 'external_stimulus', # Usually high/low, treat as binary-ish\r\n}\r\n\r\n# =============================================================================\r\n# EXCLUDED NEURONS - Status neurons that exist but aren't visualized normally\r\n# These are tracked in brain state but not shown in the main visualization.\r\n# =============================================================================\r\nEXCLUDED_NEURONS = [\r\n 'is_sick',\r\n 'is_eating', \r\n 'pursuing_food',\r\n 'direction',\r\n 'is_sleeping'\r\n]\r\n\r\n# =============================================================================\r\n# VISUAL STYLE CONSTANTS - For consistent rendering across tools\r\n# =============================================================================\r\n\r\n# Ring colors for neuron types\r\nCORE_NEURON_RING_COLOR = (255, 215, 0) # Gold\r\nINPUT_SENSOR_RING_COLOR = (100, 149, 237) # Cornflower blue\r\nCUSTOM_NEURON_RING_COLOR = (180, 180, 180) # Gray\r\n\r\n# Ring widths\r\nPROTECTED_RING_WIDTH = 3\r\nNORMAL_RING_WIDTH = 2\r\n\r\n# Default neuron colors by type\r\nDEFAULT_COLORS = {\r\n 'core': (150, 150, 220), # Soft purple\r\n 'input': (100, 200, 150), # Soft green \r\n 'output': (220, 150, 150), # Soft red\r\n 'hidden': (180, 180, 200), # Neutral\r\n 'sensor': (150, 200, 220), # Soft blue\r\n}\r\n\r\n# =============================================================================\r\n# LAYER DEFAULTS\r\n# =============================================================================\r\nDEFAULT_LAYER_HEIGHT = 120\r\nDEFAULT_LAYER_SPACING = 150\r\n\r\nLAYER_COLORS = {\r\n 'input': {\r\n 'fill': (200, 255, 200, 80),\r\n 'border': (150, 220, 150, 120)\r\n },\r\n 'output': {\r\n 'fill': (255, 200, 200, 80),\r\n 'border': (220, 150, 150, 120)\r\n },\r\n 'hidden': {\r\n 'fill': (230, 230, 255, 80),\r\n 'border': (200, 200, 240, 120)\r\n }\r\n}\r\n\r\n\r\n# =============================================================================\r\n# HELPER FUNCTIONS\r\n# =============================================================================\r\n\r\ndef is_core_neuron(name: str) -> bool:\r\n \"\"\"Check if a neuron name is a core stat neuron (7 stats).\"\"\"\r\n return name in CORE_NEURONS\r\n\r\ndef is_required_neuron(name: str) -> bool:\r\n \"\"\"Check if a neuron is required (core + can_see_food).\"\"\"\r\n return name in REQUIRED_NEURONS\r\n\r\ndef is_input_sensor(name: str) -> bool:\r\n \"\"\"Check if a neuron name is an optional input sensor.\"\"\"\r\n return name in INPUT_SENSORS\r\n\r\ndef is_any_sensor(name: str) -> bool:\r\n \"\"\"Check if a neuron receives values from hooks (including can_see_food).\"\"\"\r\n return name in INPUT_SENSORS or name in MANDATORY_SENSOR or name in DEFAULT_INPUT_SENSORS\r\n\r\ndef is_binary_neuron(name: str) -> bool:\r\n \"\"\"Check if a neuron should display as binary (on/off).\"\"\"\r\n return name in BINARY_NEURONS\r\n\r\ndef is_protected_neuron(name: str) -> bool:\r\n \"\"\"Check if a neuron is protected (cannot be deleted or renamed).\"\"\"\r\n return is_required_neuron(name)\r\n\r\ndef get_neuron_category(name: str) -> str:\r\n \"\"\"Get the category of a neuron: 'core', 'required', 'sensor', or 'custom'.\"\"\"\r\n if is_core_neuron(name):\r\n return 'core'\r\n elif name == 'can_see_food':\r\n return 'required'\r\n elif is_input_sensor(name):\r\n return 'sensor'\r\n else:\r\n return 'custom'\r\n\r\ndef get_all_standard_neurons() -> dict:\r\n \"\"\"Get all standard neurons (required + optional sensors) with positions.\"\"\"\r\n result = dict(REQUIRED_NEURONS)\r\n result.update(INPUT_SENSORS)\r\n return result\r\n\r\ndef get_missing_required(existing_neurons: set) -> list:\r\n \"\"\"Get list of required neurons not in the given set.\"\"\"\r\n return [name for name in REQUIRED_NEURONS if name not in existing_neurons]"
},
{
"path": "src/brain_decisions_tab.py",
"content": "# src/brain_decisions_tab.py\r\n\r\nfrom PyQt5 import QtCore, QtGui, QtWidgets\r\nfrom .brain_base_tab import BrainBaseTab\r\nfrom .display_scaling import DisplayScaling\r\nfrom .localisation import Localisation\r\n\r\nclass DecisionsTab(BrainBaseTab):\r\n def __init__(self, parent=None, tamagotchi_logic=None, brain_widget=None, config=None, debug_mode=False):\r\n super().__init__(parent, tamagotchi_logic, brain_widget, config, debug_mode)\r\n self.loc = Localisation.instance()\r\n self.initialize_ui()\r\n\r\n def initialize_ui(self):\r\n \"\"\"\r\n Initializes the UI with a persistent, non-flickering layout for the decision path\r\n and a fixed bar at the bottom for the final action.\r\n \"\"\"\r\n self.layout.setContentsMargins(DisplayScaling.scale(15), DisplayScaling.scale(15), DisplayScaling.scale(15), DisplayScaling.scale(15))\r\n self.layout.setSpacing(DisplayScaling.scale(10))\r\n\r\n # Main container\r\n main_container = QtWidgets.QWidget()\r\n main_container.setObjectName(\"mainContainer\")\r\n main_container.setStyleSheet(\"background-color: #f8f9fa; border-radius: 10px;\")\r\n main_layout = QtWidgets.QVBoxLayout(main_container)\r\n main_layout.setContentsMargins(DisplayScaling.scale(10), DisplayScaling.scale(10), DisplayScaling.scale(10), DisplayScaling.scale(10))\r\n self.layout.addWidget(main_container)\r\n\r\n # Title\r\n title_layout = QtWidgets.QHBoxLayout()\r\n title_icon = QtWidgets.QLabel(\"🧠\")\r\n title_icon.setStyleSheet(f\"font-size: {DisplayScaling.font_size(34)}px;\")\r\n title_label = QtWidgets.QLabel(self.loc.get(\"thought_process\"))\r\n title_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(30)}px; font-weight: bold; color: #343a40;\")\r\n title_layout.addWidget(title_icon)\r\n title_layout.addWidget(title_label)\r\n title_layout.addStretch()\r\n main_layout.addLayout(title_layout)\r\n\r\n # Scroll area for the decision path (takes up the expandable space)\r\n path_scroll_area = QtWidgets.QScrollArea()\r\n path_scroll_area.setWidgetResizable(True)\r\n path_scroll_area.setStyleSheet(\"QScrollArea { border: none; background-color: #f8f9fa; }\")\r\n main_layout.addWidget(path_scroll_area, 1)\r\n \r\n path_container = QtWidgets.QWidget()\r\n self.path_layout = QtWidgets.QVBoxLayout(path_container)\r\n self.path_layout.setSpacing(DisplayScaling.scale(15))\r\n self.path_layout.setAlignment(QtCore.Qt.AlignTop)\r\n path_scroll_area.setWidget(path_container)\r\n\r\n # --- Create persistent widgets and labels for each step ---\r\n # Step 1: Current State\r\n step1, self.step1_label = self._create_path_step_widget(1, self.loc.get(\"step1_title\"), \"📡\")\r\n self.path_layout.addWidget(step1)\r\n self.path_layout.addWidget(self._create_arrow())\r\n\r\n # Step 2: Base Urges\r\n step2, self.step2_label = self._create_path_step_widget(2, self.loc.get(\"step2_title\"), \"⚖️\")\r\n self.path_layout.addWidget(step2)\r\n self.path_layout.addWidget(self._create_arrow())\r\n \r\n # Step 3: Personality & Memory\r\n step3, self.step3_label = self._create_path_step_widget(3, self.loc.get(\"step3_title\"), \"🎭\")\r\n self.path_layout.addWidget(step3)\r\n self.path_layout.addWidget(self._create_arrow())\r\n\r\n # Step 4: Final Decision\r\n step4, self.step4_label = self._create_path_step_widget(4, self.loc.get(\"step4_title\"), \"✅\")\r\n self.path_layout.addWidget(step4)\r\n\r\n # --- Final Action Bar (at the bottom) ---\r\n final_action_bar = QtWidgets.QFrame()\r\n final_action_bar.setObjectName(\"finalActionBar\")\r\n final_action_bar.setStyleSheet(\"\"\"\r\n #finalActionBar {\r\n background-color: #e9ecef;\r\n border: 1px solid #ced4da;\r\n border-radius: 8px;\r\n }\r\n \"\"\")\r\n final_action_bar.setFixedHeight(DisplayScaling.scale(60))\r\n \r\n bar_layout = QtWidgets.QHBoxLayout(final_action_bar)\r\n bar_layout.setContentsMargins(DisplayScaling.scale(15), DisplayScaling.scale(5), DisplayScaling.scale(15), DisplayScaling.scale(5))\r\n \r\n action_title_label = QtWidgets.QLabel(f\"{self.loc.get('final_action')}\")\r\n action_title_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(22)}px; color: #495057;\")\r\n \r\n self.final_action_label = QtWidgets.QLabel(\"...\")\r\n self.final_action_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(22)}px; font-weight: bold; color: #007bff;\")\r\n\r\n bar_layout.addWidget(action_title_label)\r\n bar_layout.addWidget(self.final_action_label)\r\n bar_layout.addStretch()\r\n\r\n main_layout.addWidget(final_action_bar)\r\n \r\n self.update_path_with_placeholder()\r\n\r\n def _create_path_step_widget(self, step_number, title, icon):\r\n \"\"\"Creates a styled widget for a single step and returns it and its content label.\"\"\"\r\n step_widget = QtWidgets.QWidget()\r\n step_widget.setObjectName(\"stepWidget\")\r\n step_widget.setStyleSheet(f\"\"\"\r\n #stepWidget {{\r\n background-color: #ffffff;\r\n border: 1px solid #dee2e6;\r\n border-radius: 8px;\r\n padding: {DisplayScaling.scale(10)}px;\r\n }}\r\n \"\"\")\r\n step_layout = QtWidgets.QVBoxLayout(step_widget)\r\n\r\n header_layout = QtWidgets.QHBoxLayout()\r\n icon_label = QtWidgets.QLabel(icon)\r\n icon_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(30)}px;\")\r\n title_label = QtWidgets.QLabel(f\"{self.loc.get('step')} {step_number}: {title}\")\r\n title_label.setStyleSheet(f\"font-size: {DisplayScaling.font_size(22)}px; color: #495057;\")\r\n header_layout.addWidget(icon_label)\r\n header_layout.addWidget(title_label)\r\n header_layout.addStretch()\r\n step_layout.addLayout(header_layout)\r\n\r\n content_label = QtWidgets.QLabel(\"...\")\r\n content_label.setWordWrap(True)\r\n content_label.setAlignment(QtCore.Qt.AlignTop)\r\n content_label.setStyleSheet(f\"padding-left: {DisplayScaling.scale(10)}px; padding-top: {DisplayScaling.scale(5)}px; font-size: {DisplayScaling.font_size(19)}px;\")\r\n step_layout.addWidget(content_label)\r\n \r\n return step_widget, content_label\r\n\r\n def update_path_with_placeholder(self):\r\n \"\"\"Sets initial placeholder content on the persistent labels.\"\"\"\r\n placeholder_text = f\"{self.loc.get('awaiting_thought')}\"\r\n self.step1_label.setText(placeholder_text)\r\n self.step2_label.setText(placeholder_text)\r\n self.step3_label.setText(placeholder_text)\r\n self.step4_label.setText(placeholder_text)\r\n self.final_action_label.setText(self.loc.get(\"awaiting_decision\"))\r\n\r\n def update_from_brain_state(self, state):\r\n \"\"\"Update visualization based on brain state.\"\"\"\r\n if hasattr(self.tamagotchi_logic, 'get_decision_data'):\r\n decision_data = self.tamagotchi_logic.get_decision_data()\r\n if decision_data:\r\n self.update_decision_path(decision_data)\r\n\r\n def update_decision_path(self, data):\r\n \"\"\"Updates the content of the persistent step labels and the final action bar.\"\"\"\r\n final_decision = data.get('final_decision', 'N/A')\r\n\r\n self._update_state_step(data.get('inputs', {}))\r\n self._update_urges_step(data.get('weights', {}))\r\n self._update_modifiers_step(data)\r\n self._update_final_decision_step(data, final_decision)\r\n\r\n # Update the bottom bar - translate action name if possible\r\n action_key = final_decision.lower().replace(' ', '_')\r\n translated_action = self.loc.get(action_key)\r\n # If no translation found, use original capitalized\r\n if translated_action == action_key:\r\n translated_action = final_decision.capitalize()\r\n self.final_action_label.setText(translated_action)\r\n\r\n def _translate_object(self, obj_name):\r\n \"\"\"Translate object name (food, rock, poop, plant)\"\"\"\r\n key = obj_name.lower()\r\n translated = self.loc.get(key)\r\n return translated if translated != key else obj_name\r\n\r\n def _translate_action(self, action_name):\r\n \"\"\"Translate action name\"\"\"\r\n key = action_name.lower().replace(' ', '_')\r\n translated = self.loc.get(key)\r\n return translated if translated != key else action_name.capitalize()\r\n\r\n def _update_state_step(self, inputs):\r\n text = f\"{self.loc.get('sensing_condition')}
\"\r\n if not inputs:\r\n text += f\"
{self.loc.get('no_sensory_data')}
\"\r\n else:\r\n visible_items = []\r\n if inputs.get(\"has_food_visible\"):\r\n visible_items.append(self.loc.get(\"food\"))\r\n if inputs.get(\"has_rock_visible\"):\r\n visible_items.append(self.loc.get(\"rock\"))\r\n if inputs.get(\"has_poop_visible\"):\r\n visible_items.append(self.loc.get(\"poop\"))\r\n if inputs.get(\"has_plant_visible\"):\r\n visible_items.append(self.loc.get(\"plant\"))\r\n\r\n if visible_items:\r\n text += f\"
\"\r\n\r\n excluded_keys = {\"has_food_visible\", \"has_rock_visible\", \"has_poop_visible\", \"has_plant_visible\"}\r\n for key, value in sorted(inputs.items()):\r\n if key not in excluded_keys:\r\n formatted_value = f\"{value:.2f}\" if isinstance(value, float) else str(value)\r\n # Try to translate the key\r\n display_key = key.replace('_', ' ').capitalize()\r\n text += f\"
{display_key}: {formatted_value}
\"\r\n text += \"
\"\r\n self.step1_label.setText(text)\r\n\r\n def _update_urges_step(self, weights):\r\n if not weights:\r\n self.step2_label.setText(self.loc.get(\"no_urges\"))\r\n return\r\n\r\n strongest_urge = max(weights, key=weights.get)\r\n translated_urge = self._translate_action(strongest_urge)\r\n text = f\"{self.loc.get('strongest_urge')} {translated_urge}.
{self.loc.get('initial_scores')}\"\r\n text += \"
\"\r\n for action, weight in sorted(weights.items(), key=lambda item: item[1], reverse=True):\r\n translated_action = self._translate_action(action)\r\n text += f\"
\"\r\n for k, v in sorted(categories.items())\r\n )\r\n \r\n stats_html += f\"\"\"\r\n
\r\n
🗂️ Categories
\r\n
{category_html}
\r\n
\r\n \"\"\"\r\n \r\n self.overview_stats.setHtml(stats_html)\r\n\r\n def _clear_layout(self, layout):\r\n \"\"\"Clear all widgets from the given layout\"\"\"\r\n while layout.count():\r\n item = layout.takeAt(0)\r\n widget = item.widget()\r\n if widget is not None:\r\n widget.deleteLater()\r\n\r\n def set_pause_state(self, is_paused):\r\n \"\"\"Set pause state for the brain window and worker thread\"\"\"\r\n self.is_paused = is_paused\r\n \r\n # Set brain widget pause state\r\n if hasattr(self, 'brain_widget'):\r\n self.brain_widget.is_paused = is_paused\r\n \r\n # Control worker thread - CRITICAL for freezing everything\r\n if hasattr(self, 'brain_worker') and self.brain_worker:\r\n if is_paused:\r\n self.brain_worker.pause()\r\n self._pause_start_time = time.time() # Capture time when paused\r\n print(\"⏸️ BrainWorker paused\")\r\n else:\r\n self.brain_worker.resume()\r\n \r\n # Adjust timestamps to account for pause duration\r\n if hasattr(self, '_pause_start_time'):\r\n pause_duration = time.time() - self._pause_start_time\r\n \r\n # 1. Adjust Hebbian timer reference\r\n if hasattr(self.brain_widget, 'last_hebbian_time'):\r\n self.brain_widget.last_hebbian_time += pause_duration\r\n \r\n # 2. Adjust Neurogenesis timer reference\r\n if hasattr(self.brain_widget, 'neurogenesis_data'):\r\n self.brain_widget.neurogenesis_data['last_neuron_time'] += pause_duration\r\n \r\n # 3. Adjust Animation timer references in brain_widget to prevent jumps\r\n if hasattr(self.brain_widget, '_last_animation_time'):\r\n self.brain_widget._last_animation_time += pause_duration\r\n \r\n # 4. Adjust running weight animations\r\n if hasattr(self.brain_widget, 'weight_animations'):\r\n for anim in self.brain_widget.weight_animations:\r\n anim['start_time'] += pause_duration\r\n \r\n # 5. Adjust reveal animations\r\n if hasattr(self.brain_widget, 'neuron_reveal_animations'):\r\n for anim in self.brain_widget.neuron_reveal_animations.values():\r\n anim['start_time'] += pause_duration\r\n \r\n # 6. Adjust neurogenesis highlight\r\n if hasattr(self.brain_widget, 'neurogenesis_highlight'):\r\n self.brain_widget.neurogenesis_highlight['start_time'] += pause_duration\r\n\r\n print(\"▶️ BrainWorker resumed\")\r\n\r\n # Manage timers based on pause state\r\n if is_paused:\r\n if hasattr(self, 'hebbian_timer'):\r\n self.hebbian_timer.stop()\r\n else:\r\n if hasattr(self, 'hebbian_timer'):\r\n self.hebbian_timer.start(self.config.hebbian['learning_interval'])\r\n\r\n def _create_memory_card(self, memory):\r\n \"\"\"Create a styled HTML memory card with tooltip\"\"\"\r\n category = memory.get('category', 'unknown')\r\n value = memory.get('formatted_value', str(memory.get('value', '')))\r\n timestamp = memory.get('timestamp', '')\r\n effects = memory.get('effects', {})\r\n \r\n # Determine card color based on memory type\r\n bg_color, border_color = self._get_memory_colors(memory)\r\n \r\n # Create concise display text\r\n card_html = f\"\"\"\r\n
\r\n
{category.capitalize()}
\r\n
{value[:60]}
\r\n
\r\n {timestamp.split(' ')[-1]}\r\n
\r\n
\r\n \"\"\"\r\n \r\n # Create tooltip with extended info\r\n tooltip = f\"\"\"\r\n Full Content: {value} \r\n Effects: {', '.join(f'{k}: {v}' for k,v in effects.items())} \r\n Last Accessed: {timestamp}\r\n \"\"\"\r\n \r\n # Create widget with HTML and tooltip\r\n card = QtWidgets.QTextEdit()\r\n card.setHtml(card_html)\r\n card.setReadOnly(True)\r\n card.setToolTip(tooltip)\r\n card.setFixedHeight(120)\r\n card.setStyleSheet(\"border: none;\")\r\n \r\n return card\r\n \r\n def _get_card_style(self, memory):\r\n \"\"\"Get CSS style for a memory card based on its valence and importance\"\"\"\r\n # Determine card background color based on memory valence\r\n if memory.get('category') == 'mental_state' and memory.get('key') == 'startled':\r\n background_color = \"#FFD1DC\" # Pastel red for negative\r\n elif isinstance(memory.get('raw_value'), dict):\r\n total_effect = sum(float(val) for val in memory['raw_value'].values() \r\n if isinstance(val, (int, float)))\r\n if total_effect > 0:\r\n background_color = \"#D1FFD1\" # Pastel green for positive\r\n elif total_effect < 0:\r\n background_color = \"#FFD1DC\" # Pastel red for negative\r\n else:\r\n background_color = \"#FFFACD\" # Pastel yellow for neutral\r\n else:\r\n background_color = \"#FFFACD\" # Pastel yellow for neutral\r\n \r\n # Determine border based on importance (only for short-term)\r\n importance = memory.get('importance', 1)\r\n if importance >= 7:\r\n border = \"2px solid #FF5733\" # Important memory\r\n elif importance >= 4:\r\n border = \"1px solid #666\" # Medium importance\r\n else:\r\n border = \"1px solid #ccc\" # Low importance\r\n \r\n return f\"\"\"\r\n background-color: {background_color};\r\n border: {border};\r\n border-radius: 8px;\r\n padding: 8px;\r\n margin: 4px;\r\n \"\"\"\r\n \r\n def _format_memory_content(self, memory):\r\n \"\"\"Format memory content for display in a card\"\"\"\r\n # Get the display text - prefer formatted_value, fall back to value\r\n display_text = memory.get('formatted_value', str(memory.get('value', '')))\r\n \r\n # Skip if the display text contains just a timestamp\r\n if 'timestamp' in display_text.lower() and len(display_text.split()) < 3:\r\n return \"Empty memory\"\r\n \r\n # Make text more concise and readable\r\n # Remove any HTML tags already in the text to avoid nesting issues\r\n import re\r\n display_text = re.sub(r'<[^>]*>', '', display_text)\r\n \r\n # Format based on category\r\n category = memory.get('category', '')\r\n \r\n if category == 'decorations':\r\n # Extract the important parts of decoration interactions\r\n if 'interaction with' in display_text.lower():\r\n parts = display_text.split(':')\r\n if len(parts) >= 2:\r\n item = parts[0].strip()\r\n effects = parts[1].strip()\r\n return f\"{item} {effects}\"\r\n \r\n # Default formatting with bold beginning\r\n words = display_text.split()\r\n if len(words) > 3:\r\n bold_part = ' '.join(words[:3])\r\n rest = ' '.join(words[3:])\r\n return f\"{bold_part} {rest}\"\r\n \r\n return display_text\r\n \r\n def _create_memory_tooltip(self, memory):\r\n \"\"\"Create detailed tooltip for a memory card\"\"\"\r\n tooltip = \"\"\r\n tooltip += f\"Category: {memory.get('category', 'unknown')}\\n\"\r\n tooltip += f\"Key: {memory.get('key', 'unknown')}\\n\"\r\n \r\n timestamp = memory.get('timestamp', '')\r\n if isinstance(timestamp, str):\r\n try:\r\n from datetime import datetime\r\n timestamp = datetime.fromisoformat(timestamp).strftime(\"%H:%M:%S\")\r\n except:\r\n timestamp = \"\"\r\n \r\n tooltip += f\"Time: {timestamp}\\n\"\r\n \r\n if 'importance' in memory:\r\n tooltip += f\"Importance: {memory.get('importance')}\\n\"\r\n \r\n if 'access_count' in memory:\r\n tooltip += f\"Access count: {memory.get('access_count')}\\n\"\r\n \r\n if isinstance(memory.get('raw_value'), dict):\r\n tooltip += \"\\nEffects:\\n\"\r\n for key, value in memory['raw_value'].items():\r\n if isinstance(value, (int, float)):\r\n tooltip += f\" {key}: {value:+.2f}\\n\"\r\n \r\n tooltip += \"\"\r\n return tooltip\r\n \r\n def _get_stm(self):\r\n \"\"\"Get short-term memories from squid's memory manager\"\"\"\r\n if hasattr(self.tamagotchi_logic, 'squid') and hasattr(self.tamagotchi_logic.squid, 'memory_manager'):\r\n return self.tamagotchi_logic.squid.memory_manager.get_all_short_term_memories()\r\n return []\r\n \r\n def _get_ltm(self):\r\n \"\"\"Get long-term memories from squid's memory manager\"\"\"\r\n if hasattr(self.tamagotchi_logic, 'squid') and hasattr(self.tamagotchi_logic.squid, 'memory_manager'):\r\n return self.tamagotchi_logic.squid.memory_manager.get_all_long_term_memories()\r\n return []\r\n \r\n def _is_displayable(self, memory):\r\n \"\"\"Check if a memory should be displayed in the UI\"\"\"\r\n if not isinstance(memory, dict):\r\n return False\r\n \r\n # Skip timestamp-like memories (with numeric keys or timestamp values)\r\n if isinstance(memory.get('key'), str):\r\n # Filter out numeric keys (timestamps)\r\n if memory['key'].replace('.', '', 1).isdigit():\r\n return False\r\n \r\n # Check the value - filter out memories with timestamp values\r\n value = memory.get('value', '')\r\n if isinstance(value, str) and 'timestamp' in value.lower():\r\n return False\r\n \r\n # For memories with formatted_value\r\n formatted_value = memory.get('formatted_value', '')\r\n if isinstance(formatted_value, str):\r\n # If it contains timestamp numbers as part of the interaction\r\n if 'Interaction with' in formatted_value and any(c.isdigit() for c in formatted_value.split('with')[1]):\r\n return False\r\n \r\n # Check for timestamp-like value in the memory\r\n if 'Interaction with' in str(formatted_value) and '.' in str(formatted_value):\r\n timestamp_part = str(formatted_value).split('with')[1].strip()\r\n # If it looks like a float timestamp (e.g., 1744308365.4552662)\r\n if '.' in timestamp_part and any(part.replace('.', '', 1).isdigit() for part in timestamp_part.split()):\r\n return False\r\n \r\n # Skip memories that don't have a proper category or value\r\n if not memory.get('category') or not memory.get('value'):\r\n return False\r\n \r\n # Must have either formatted_value or a displayable string value\r\n if 'formatted_value' not in memory and not isinstance(memory.get('value'), str):\r\n return False\r\n \r\n return True\r\n \r\n def _update_memory_stats(self, short_term_memories, long_term_memories):\r\n \"\"\"Update memory statistics in the overview tab\"\"\"\r\n stats_html = \"
\"\r\n \r\n for level, count in importance_levels.items():\r\n stats_html += f\"
{level}
{count}
\"\r\n \r\n stats_html += \"
\"\r\n \r\n # Update stats display\r\n self.memory_stats_text.setHtml(stats_html)\r\n\r\n\r\n def add_thought(self, thought):\r\n \"\"\"Bridge method to forward thoughts to the decisions tab\"\"\"\r\n if hasattr(self, 'decisions_tab') and self.decisions_tab:\r\n # If we have a decisions tab, forward to its thought log\r\n if hasattr(self.decisions_tab, 'thought_log_text'):\r\n self.decisions_tab.thought_log_text.append(thought)\r\n # Auto-scroll to bottom\r\n scrollbar = self.decisions_tab.thought_log_text.verticalScrollBar()\r\n scrollbar.setValue(scrollbar.maximum())\r\n elif hasattr(self.decisions_tab, 'add_thought'):\r\n # Alternative: if the tab has its own add_thought method\r\n self.decisions_tab.add_thought(thought)\r\n else:\r\n # Fallback: print to console if no UI element available\r\n print(f\"Thought: {thought}\")\r\n\r\n def clear_thoughts(self):\r\n self.thoughts_text.clear()\r\n\r\n def init_decisions_tab(self):\r\n font = QtGui.QFont()\r\n font.setPointSize(self.base_font_size)\r\n # Add a label for decision history\r\n decision_history_label = QtWidgets.QLabel(\"Decision History:\")\r\n self.decisions_tab_layout.addWidget(decision_history_label)\r\n\r\n # Add a text area to display decision history\r\n self.decision_history_text = QtWidgets.QTextEdit()\r\n self.decision_history_text.setReadOnly(True)\r\n self.decisions_tab_layout.addWidget(self.decision_history_text)\r\n\r\n # Add a label for decision inputs\r\n decision_inputs_label = QtWidgets.QLabel(\"Decision Inputs:\")\r\n self.decisions_tab_layout.addWidget(decision_inputs_label)\r\n\r\n # Add a text area to display decision inputs\r\n self.decision_inputs_text = QtWidgets.QTextEdit()\r\n self.decision_inputs_text.setReadOnly(True)\r\n self.decisions_tab_layout.addWidget(self.decision_inputs_text)\r\n\r\n def update_decisions_tab(self, decision, decision_inputs):\r\n # Append the decision to the decision history\r\n self.decision_history_text.append(f\"Decision: {decision}\")\r\n\r\n # Display the decision inputs\r\n self.decision_inputs_text.clear()\r\n for key, value in decision_inputs.items():\r\n self.decision_inputs_text.append(f\"{key}: {value}\")\r\n\r\n def init_associations_tab(self):\r\n font = QtGui.QFont()\r\n font.setPointSize(self.base_font_size)\r\n # Add a checkbox to toggle explanation\r\n self.show_explanation_checkbox = QtWidgets.QCheckBox(\"Show Explanation\")\r\n self.show_explanation_checkbox.stateChanged.connect(self.toggle_explanation)\r\n self.associations_tab_layout.addWidget(self.show_explanation_checkbox)\r\n\r\n # Add explanation text (hidden by default)\r\n self.explanation_text = QtWidgets.QTextEdit()\r\n self.explanation_text.setReadOnly(True)\r\n self.explanation_text.setHidden(True)\r\n self.explanation_text.setPlainText(\r\n \"This tab shows the learned associations between different neural states of the squid. \"\r\n \"These associations are formed through the Hebbian learning process, where 'neurons that fire together, wire together'. \"\r\n \"The strength of an association is determined by how often these states occur together or influence each other. \"\r\n \"Positive associations mean that as one state increases, the other tends to increase as well. \"\r\n \"Negative associations (indicated by 'reduced') mean that as one state increases, the other tends to decrease. \"\r\n \"These associations help us understand how the squid's experiences shape its behavior and decision-making processes.\"\r\n )\r\n self.associations_tab_layout.addWidget(self.explanation_text)\r\n\r\n # Add a label for the associations\r\n label = QtWidgets.QLabel(\"Learned associations:\")\r\n self.associations_tab_layout.addWidget(label)\r\n\r\n # Add a text area to display associations\r\n self.associations_text = QtWidgets.QTextEdit()\r\n self.associations_text.setReadOnly(True)\r\n self.associations_tab_layout.addWidget(self.associations_text)\r\n\r\n # Add export button\r\n self.export_associations_button = QtWidgets.QPushButton(\"Export Associations\")\r\n self.export_associations_button.clicked.connect(self.export_associations)\r\n self.associations_tab_layout.addWidget(self.export_associations_button, alignment=QtCore.Qt.AlignRight)\r\n\r\n def toggle_explanation(self, state):\r\n self.explanation_text.setVisible(state == QtCore.Qt.Checked)\r\n\r\n def update_associations(self):\r\n \"\"\"Update association data if we have the learning tab\"\"\"\r\n if hasattr(self, 'learning_tab'):\r\n # Forward to the tab's update method\r\n current_time = time.time()\r\n if current_time - self.last_update_time > self.update_threshold:\r\n self.last_update_time = current_time\r\n self.learning_tab.update_from_brain_state(self.brain_widget.state)\r\n\r\n def generate_association_summary(self, neuron1, neuron2, weight):\r\n strength = \"strongly\" if abs(weight) > 0.8 else \"moderately\"\r\n if weight > 0:\r\n relation = \"associated with\"\r\n else:\r\n relation = \"associated with reduced\"\r\n\r\n # Correct grammar for specific neurons\r\n neuron1_text = self.get_neuron_display_name(neuron1)\r\n neuron2_text = self.get_neuron_display_name(neuron2)\r\n\r\n summaries = {\r\n \"hunger-satisfaction\": f\"{neuron1_text} is {strength} associated with satisfaction (probably from eating)\",\r\n \"satisfaction-hunger\": f\"Feeling satisfied is {strength} associated with reduced hunger\",\r\n \"cleanliness-anxiety\": f\"{neuron1_text} is {strength} {relation} anxiety\",\r\n \"anxiety-cleanliness\": f\"Feeling anxious is {strength} associated with reduced cleanliness\",\r\n \"curiosity-happiness\": f\"{neuron1_text} is {strength} associated with happiness\",\r\n \"happiness-curiosity\": f\"Being happy is {strength} associated with increased curiosity\",\r\n \"hunger-anxiety\": f\"{neuron1_text} is {strength} associated with increased anxiety\",\r\n \"sleepiness-satisfaction\": f\"{neuron1_text} is {strength} {relation} satisfaction\",\r\n \"happiness-cleanliness\": f\"Being happy is {strength} associated with cleanliness\",\r\n }\r\n\r\n key = f\"{neuron1}-{neuron2}\"\r\n if key in summaries:\r\n return summaries[key]\r\n else:\r\n return f\"{neuron1_text} is {strength} {relation} {neuron2_text}\"\r\n\r\n def get_neuron_display_name(self, neuron):\r\n display_names = {\r\n \"cleanliness\": \"Being clean\",\r\n \"sleepiness\": \"Being sleepy\",\r\n \"happiness\": \"Being happy\",\r\n \"hunger\": \"Being hungry\",\r\n \"satisfaction\": \"Satisfaction\",\r\n \"anxiety\": \"Being anxious\",\r\n \"curiosity\": \"Curiosity\",\r\n \"direction\": \"Direction\"\r\n }\r\n return display_names.get(neuron, f\"{neuron}\")\r\n\r\n\r\n\r\n def update_countdown(self):\r\n \"\"\"Update the Hebbian learning countdown display\"\"\"\r\n # Check if simulation is paused\r\n is_paused = False\r\n if hasattr(self, 'tamagotchi_logic') and hasattr(self.tamagotchi_logic, 'simulation_speed'):\r\n is_paused = (self.tamagotchi_logic.simulation_speed == 0)\r\n \r\n # Calculate time until next learning cycle\r\n if not is_paused and hasattr(self.brain_widget, 'last_hebbian_time'):\r\n elapsed = time.time() - self.brain_widget.last_hebbian_time\r\n interval_sec = self.config.hebbian.get('learning_interval', 30000) / 1000\r\n remaining = max(0, interval_sec - elapsed)\r\n self.brain_widget.hebbian_countdown_seconds = int(remaining)\r\n elif not hasattr(self.brain_widget, 'last_hebbian_time'):\r\n self.brain_widget.hebbian_countdown_seconds = 0\r\n\r\n # Debug print statements\r\n #print(f\"Elapsed time: {elapsed:.1f}s\")\r\n #print(f\"Interval: {interval_sec:.1f}s\")\r\n #print(f\"Remaining: {remaining:.1f}s\")\r\n #print(f\"Hebbian countdown seconds: {self.brain_widget.hebbian_countdown_seconds}\")\r\n\r\n # If we have the neural network visualizer tab initialized, update its countdown\r\n if hasattr(self, 'nn_viz_tab') and hasattr(self.nn_viz_tab, 'countdown_label') and self.nn_viz_tab.countdown_label is not None:\r\n # Update the formatted display\r\n if is_paused:\r\n self.nn_viz_tab.countdown_label.setText(\"PAUSED\")\r\n else:\r\n self.nn_viz_tab.countdown_label.setText(f\"{self.brain_widget.hebbian_countdown_seconds} seconds\")\r\n \r\n # If countdown reached zero and not paused, trigger learning\r\n # (moved outside nn_viz_tab check so learning always fires)\r\n if self.brain_widget.hebbian_countdown_seconds == 0 and not is_paused:\r\n # print(\"brain_tool.py >> Countdown hit zero, calling perform_hebbian_learning()\")\r\n self.brain_widget.perform_hebbian_learning()\r\n\r\n def check_memory_decay(self):\r\n \"\"\"Check for short-term memory decay and transfer important memories to long-term\"\"\"\r\n if not hasattr(self.tamagotchi_logic, 'squid') or not self.tamagotchi_logic.squid:\r\n return\r\n \r\n # Run periodic memory management on the squid's memory manager\r\n if hasattr(self.tamagotchi_logic.squid, 'memory_manager'):\r\n memory_manager = self.tamagotchi_logic.squid.memory_manager\r\n \r\n # Get all short-term memories to check for decay\r\n short_term_memories = memory_manager.get_all_short_term_memories()\r\n \r\n # Process memories that are about to decay (older than 100 seconds)\r\n current_time = datetime.now()\r\n for memory in short_term_memories:\r\n if 'timestamp' in memory:\r\n timestamp = memory['timestamp']\r\n if isinstance(timestamp, str):\r\n timestamp = datetime.fromisoformat(timestamp)\r\n \r\n time_diff = current_time - timestamp\r\n \r\n # If memory is influential or important, make sure it's transferred to long-term\r\n is_influential = False\r\n \r\n # Check if it's an important or influential memory\r\n if 'importance' in memory and memory['importance'] >= 7:\r\n is_influential = True\r\n \r\n # Check if it's about to decay but is important\r\n if time_diff.total_seconds() > 100: # About to decay (120s is default)\r\n category = memory.get('category', '')\r\n key = memory.get('key', '')\r\n \r\n if is_influential:\r\n # Log the memory transfer\r\n self.activity_log.append(f\"\"\"\r\n
\r\n Important Memory Transfer \r\n Category: {category} \r\n Key: {key} \r\n Age: {int(time_diff.total_seconds())} seconds \r\n Importance: {memory.get('importance', 'unknown')}\r\n
\r\n \"\"\")\r\n \r\n # Transfer to long-term memory\r\n memory_manager.transfer_to_long_term_memory(category, key)\r\n\r\n def clear_learning_data(self):\r\n self.weight_changes_text.clear()\r\n self.learning_data_table.setRowCount(0)\r\n self.learning_data = []\r\n print(\"Learning data cleared.\")\r\n\r\n def update_learning_interval(self, seconds):\r\n \"\"\"Update the learning interval when spinbox value changes\"\"\"\r\n # Convert seconds to milliseconds (QTimer uses ms)\r\n interval_ms = seconds * 1000\r\n \r\n # Update config\r\n if hasattr(self.config, 'hebbian'):\r\n self.config.hebbian['learning_interval'] = interval_ms\r\n else:\r\n self.config.hebbian = {'learning_interval': interval_ms}\r\n \r\n # Restart timer with new interval\r\n if hasattr(self, 'hebbian_timer'):\r\n self.hebbian_timer.setInterval(interval_ms)\r\n self.last_hebbian_time = time.time() # Reset countdown\r\n \r\n if self.debug_mode:\r\n print(f\"Learning interval updated to {seconds} seconds ({interval_ms} ms)\")\r\n\r\n \r\n\r\n def deduce_weight_change_reason(self, pair, value1, value2, prev_weight, new_weight, weight_change):\r\n neuron1, neuron2 = pair\r\n threshold_high = 70\r\n threshold_low = 30\r\n\r\n reasons = []\r\n\r\n # Analyze neuron activity levels\r\n if value1 > threshold_high and value2 > threshold_high:\r\n reasons.append(f\"Both {neuron1.upper()} and {neuron2.upper()} were highly active\")\r\n elif value1 < threshold_low and value2 < threshold_low:\r\n reasons.append(f\"Both {neuron1.upper()} and {neuron2.upper()} had low activity\")\r\n elif value1 > threshold_high:\r\n reasons.append(f\"{neuron1.upper()} was highly active\")\r\n elif value2 > threshold_high:\r\n reasons.append(f\"{neuron2.upper()} was highly active\")\r\n\r\n # Analyze weight change\r\n if abs(weight_change) > 0.1:\r\n if weight_change > 0:\r\n reasons.append(\"Strong positive reinforcement\")\r\n else:\r\n reasons.append(\"Strong negative reinforcement\")\r\n elif abs(weight_change) > 0.01:\r\n if weight_change > 0:\r\n reasons.append(\"Moderate positive reinforcement\")\r\n else:\r\n reasons.append(\"Moderate negative reinforcement\")\r\n else:\r\n reasons.append(\"Weak reinforcement\")\r\n\r\n # Analyze the relationship between neurons\r\n if \"hunger\" in pair and \"satisfaction\" in pair:\r\n reasons.append(\"Potential hunger-satisfaction relationship\")\r\n elif \"cleanliness\" in pair and \"happiness\" in pair:\r\n reasons.append(\"Potential cleanliness-happiness relationship\")\r\n\r\n # Analyze the current weight\r\n if abs(new_weight) > 0.8:\r\n reasons.append(\"Strong connection formed\")\r\n elif abs(new_weight) < 0.2:\r\n reasons.append(\"Weak connection\")\r\n\r\n # Analyze learning progress\r\n if abs(prev_weight) < 0.1 and abs(new_weight) > 0.1:\r\n reasons.append(\"New significant connection emerging\")\r\n elif abs(prev_weight) > 0.8 and abs(new_weight) < 0.8:\r\n reasons.append(\"Previously strong connection weakening\")\r\n\r\n # Combine reasons\r\n if len(reasons) > 1:\r\n return \" | \".join(reasons)\r\n elif len(reasons) == 1:\r\n return reasons[0]\r\n else:\r\n return \"Complex interaction with no clear single reason\"\r\n\r\n\r\n def get_neuron_value(self, value):\r\n if isinstance(value, (int, float)):\r\n return float(value)\r\n elif isinstance(value, bool):\r\n return 100.0 if value else 0.0\r\n elif isinstance(value, str):\r\n # For string values (like 'direction'), return a default value\r\n return 75.0\r\n else:\r\n return 0.0\r\n\r\n def update_learning_data_table(self):\r\n self.learning_data_table.setRowCount(len(self.learning_data))\r\n for row, data in enumerate(self.learning_data):\r\n for col, value in enumerate(data):\r\n item = QtWidgets.QTableWidgetItem(str(value))\r\n if col == 3: # Weight change column\r\n item.setData(QtCore.Qt.DisplayRole, f\"{value:.4f}\")\r\n if col == 4: # Direction column\r\n if value == \"increase ⬆️\":\r\n item.setForeground(QtGui.QColor(\"green\"))\r\n elif value == \"⬇️ decrease\":\r\n item.setForeground(QtGui.QColor(\"red\"))\r\n self.learning_data_table.setItem(row, col, item)\r\n self.learning_data_table.scrollToBottom()\r\n\r\n def export_learning_data(self):\r\n # Save the weight changes text to a file\r\n with open(\"learningdata_reasons.txt\", 'w') as file:\r\n file.write(self.weight_changes_text.toPlainText())\r\n\r\n # Save the learning data table to a CSV file\r\n with open(\"learningdata_weights.csv\", 'w', newline='') as file:\r\n writer = csv.writer(file)\r\n writer.writerow([\"Timestamp\", \"Neuron 1\", \"Neuron 2\", \"Weight Change\", \"Direction\"])\r\n for row in range(self.learning_data_table.rowCount()):\r\n row_data = []\r\n for col in range(self.learning_data_table.columnCount()):\r\n item = self.learning_data_table.item(row, col)\r\n row_data.append(item.text() if item else \"\")\r\n writer.writerow(row_data)\r\n\r\n QtWidgets.QMessageBox.information(self, \"Export Successful\", \"Learning data exported to 'weight_changes.txt' and 'learning_data.csv'\")\r\n\r\n def export_learning_tab_contents(self):\r\n file_name, _ = QtWidgets.QFileDialog.getSaveFileName(self, \"Export Learning Tab Contents\", \"\", \"Text Files (*.txt)\")\r\n if file_name:\r\n with open(file_name, 'w') as file:\r\n file.write(\"Learning Data Table:\\n\")\r\n for row in range(self.learning_data_table.rowCount()):\r\n row_data = []\r\n for col in range(self.learning_data_table.columnCount()):\r\n item = self.learning_data_table.item(row, col)\r\n row_data.append(item.text() if item else \"\")\r\n file.write(\"\\t\".join(row_data) + \"\\n\")\r\n\r\n file.write(\"\\nWeight Changes Text:\\n\")\r\n file.write(self.weight_changes_text.toPlainText())\r\n\r\n QtWidgets.QMessageBox.information(self, \"Export Successful\", f\"Learning tab contents exported to {file_name}\")\r\n\r\n def export_associations(self):\r\n file_name, _ = QtWidgets.QFileDialog.getSaveFileName(self, \"Export Associations\", \"\", \"Text Files (*.txt)\")\r\n if file_name:\r\n with open(file_name, 'w') as file:\r\n file.write(self.associations_text.toPlainText())\r\n QtWidgets.QMessageBox.information(self, \"Export Successful\", f\"Associations exported to {file_name}\")\r\n\r\n def update_personality_effects(self, personality, weights, adjusted_weights):\r\n \"\"\"Update the personality modifier display in the thinking tab\"\"\"\r\n # Convert enum to string if needed\r\n personality_str = getattr(personality, 'value', str(personality))\r\n \r\n self.personality_label.setText(f\"Personality: {personality_str.capitalize()}\")\r\n \r\n # Generate effect text based on weight differences\r\n effects_text = []\r\n for action, weight in weights.items():\r\n adjusted = adjusted_weights.get(action, weight)\r\n if abs(adjusted - weight) > 0.01: # If there's a significant difference\r\n direction = \"increases\" if adjusted > weight else \"decreases\"\r\n effect = f\"{action}: {direction} by {abs(adjusted - weight):.2f}\"\r\n effects_text.append(effect)\r\n \r\n if effects_text:\r\n self.personality_effects.setPlainText(\"\\n\".join(effects_text))\r\n else:\r\n self.personality_effects.setPlainText(\"No significant personality effects\")\r\n\r\n def update_brain(self, state):\r\n \"\"\"Main update method to distribute state changes to all tabs\"\"\"\r\n if not self.initialized:\r\n self.initialized = True\r\n return # Skip first update\r\n\r\n # Update the brain widget first\r\n self.brain_widget.update_state(state)\r\n\r\n # Forward updates to each tab that has an update method\r\n tabs_to_update = ['network_tab', 'nn_viz_tab', 'memory_tab', 'decisions_tab', 'personality_tab', 'about_tab'] # Adjusted list\r\n for tab_name in tabs_to_update:\r\n if hasattr(self, tab_name):\r\n tab = getattr(self, tab_name)\r\n if hasattr(tab, 'update_from_brain_state'):\r\n tab.update_from_brain_state(state)\r\n\r\n\r\n def train_hebbian(self):\r\n self.brain_widget.train_hebbian()\r\n #self.update_data_table(self.brain_widget.state)\r\n self.update_training_data_table()\r\n\r\n # Switch to the Console tab\r\n self.tabs.setCurrentWidget(self.console_tab)\r\n\r\n # Print training results to the console\r\n print(\"Hebbian training completed.\")\r\n print(\"Updated association strengths:\")\r\n for i, neuron1 in enumerate(self.brain_widget.neuron_positions.keys()):\r\n for j, neuron2 in enumerate(self.brain_widget.neuron_positions.keys()):\r\n if i < j:\r\n strength = self.brain_widget.get_association_strength(neuron1, neuron2)\r\n print(f\"{neuron1} - {neuron2}: {strength:.2f}\")\r\n\r\n def init_training_data_tab(self):\r\n self.show_overview_checkbox = QtWidgets.QCheckBox(\"Show Training Process Overview\")\r\n self.show_overview_checkbox.stateChanged.connect(self.toggle_overview)\r\n self.training_data_tab_layout.addWidget(self.show_overview_checkbox)\r\n\r\n self.overview_label = QtWidgets.QLabel(\r\n \"Training Process Overview:\\n\\n\"\r\n \"1. Data Capture: When 'Capture training data' is checked, the current state of all neurons is recorded each time the brain is stimulated.\\n\\n\"\r\n \"2. Hebbian Learning: The 'Train Hebbian' button applies the Hebbian learning rule to the captured data.\\n\\n\"\r\n \"3. Association Strength: The learning process strengthens connections between neurons that are frequently active together.\\n\\n\"\r\n \"4. Weight Updates: After training, the weights between neurons are updated based on their co-activation patterns.\\n\\n\"\r\n \"5. Adaptive Behavior: Over time, this process allows the brain to adapt its behavior based on input patterns.\"\r\n )\r\n self.overview_label.setWordWrap(True)\r\n self.overview_label.hide() # Hide by default\r\n self.training_data_tab_layout.addWidget(self.overview_label)\r\n\r\n self.training_data_table = QtWidgets.QTableWidget()\r\n self.training_data_tab_layout.addWidget(self.training_data_table)\r\n\r\n self.training_data_table.setColumnCount(len(self.brain_widget.neuron_positions))\r\n self.training_data_table.setHorizontalHeaderLabels(list(self.brain_widget.neuron_positions.keys()))\r\n\r\n self.training_data_timer = QtCore.QTimer()\r\n self.training_data_timer.timeout.connect(self.update_training_data_table)\r\n self.training_data_timer.start(1000) # Update every second\r\n\r\n self.checkbox_capture_training_data = QtWidgets.QCheckBox(\"Capture training data\")\r\n self.checkbox_capture_training_data.stateChanged.connect(self.toggle_capture_training_data)\r\n self.training_data_tab_layout.addWidget(self.checkbox_capture_training_data)\r\n\r\n self.train_button = self.create_button(\"Train Hebbian\", self.train_hebbian, \"#ADD8E6\")\r\n self.train_button.setEnabled(False) # Initially grey out the train button\r\n self.training_data_tab_layout.addWidget(self.train_button)\r\n\r\n def toggle_overview(self, state):\r\n if state == QtCore.Qt.Checked:\r\n self.overview_label.show()\r\n else:\r\n self.overview_label.hide()\r\n\r\n def toggle_capture_training_data(self, state):\r\n self.brain_widget.toggle_capture_training_data(state)\r\n if state == QtCore.Qt.Checked:\r\n os.makedirs('training_data', exist_ok=True)\r\n\r\n def update_training_data_table(self):\r\n self.training_data_table.setRowCount(len(self.brain_widget.training_data))\r\n for row, sample in enumerate(self.brain_widget.training_data):\r\n for col, value in enumerate(sample):\r\n self.training_data_table.setItem(row, col, QtWidgets.QTableWidgetItem(str(value)))\r\n\r\n if len(self.brain_widget.training_data) > 0:\r\n self.train_button.setEnabled(True)\r\n\r\n # Save raw data to file\r\n if self.checkbox_capture_training_data.isChecked():\r\n with open(os.path.join('training_data', 'raw_data.json'), 'w') as f:\r\n json.dump(self.brain_widget.training_data, f)\r\n\r\n def save_brain_state(self):\r\n file_name, _ = QtWidgets.QFileDialog.getSaveFileName(self, \"Save Brain State\", \"\", \"JSON Files (*.json)\")\r\n if file_name:\r\n with open(file_name, 'w') as f:\r\n json.dump(self.brain_widget.state, f)\r\n\r\n def load_brain_state(self):\r\n file_name, _ = QtWidgets.QFileDialog.getOpenFileName(self, \"Load Brain State\", \"\", \"JSON Files (*.json)\")\r\n if file_name:\r\n with open(file_name, 'r') as f:\r\n state = json.load(f)\r\n self.brain_widget.update_state(state)\r\n\r\n def export_brain_weights_text(self):\r\n \"\"\"Return a human-readable block with every connection.\"\"\"\r\n lines = [\"# Squid brain weights – saved {}\\n\".format(\r\n QtCore.QDateTime.currentDateTime().toString())]\r\n for (src, dst), w in sorted(self.brain_widget.weights.items(),\r\n key=lambda kv: abs(kv[1]), reverse=True):\r\n lines.append(f\"{src:20} → {dst:20} {w:+.4f}\")\r\n return \"\\n\".join(lines)\r\n\r\n def export_hebbian_json(self):\r\n \"\"\"Return a JSON-serialisable list with the *entire* learning log.\"\"\"\r\n # learning_data is already a list of lists:\r\n # [timestamp, n1, n2, Δw, direction]\r\n return {\r\n \"saved_at\": time.time(),\r\n \"learning_interval_ms\": self.config.hebbian.get('learning_interval', 30000),\r\n \"history\": getattr(self.brain_widget, 'learning_data', [])\r\n }\r\n \r\n def export_decision_engine_json(self):\r\n \"\"\"Ask the DecisionEngine to serialise itself.\"\"\"\r\n if not hasattr(self.tamagotchi_logic, 'squid') or \\\r\n not hasattr(self.tamagotchi_logic.squid, 'decision_engine'):\r\n return {}\r\n engine = self.tamagotchi_logic.squid.decision_engine\r\n # Minimal example – extend as needed\r\n return {\r\n \"epsilon\": getattr(engine, 'epsilon', 0.1),\r\n \"learning_rate\": getattr(engine, 'learning_rate', 0.05),\r\n \"q_table\": getattr(engine, 'q_table', {}).copy()\r\n }\r\n\r\n def init_console(self):\r\n self.console_output = QtWidgets.QTextEdit()\r\n self.console_output.setReadOnly(True)\r\n self.console_tab_layout.addWidget(self.console_output)\r\n self.console = ConsoleOutput(self.console_output)\r\n\r\n def create_button(self, text, callback, color):\r\n button = QtWidgets.QPushButton(text)\r\n button.clicked.connect(callback)\r\n button.setStyleSheet(f\"background-color: {color}; border: 1px solid black; padding: 5px;\")\r\n button.setFixedSize(200, 50)\r\n return button\r\n\r\n def stimulate_brain(self):\r\n dialog = StimulateDialog(self)\r\n if dialog.exec_() == QtWidgets.QDialog.Accepted:\r\n stimulation_values = dialog.get_stimulation_values()\r\n if stimulation_values is not None:\r\n self.brain_widget.update_state(stimulation_values)\r\n if self.tamagotchi_logic:\r\n self.tamagotchi_logic.update_from_brain(stimulation_values)\r\n else:\r\n print(\"Warning: tamagotchi_logic is not set. Brain stimulation will not affect the squid.\")\r\n\r\n\r\n def update_neural_visualization(self, inputs):\r\n \"\"\"Update the neural network visualization with current input values\"\"\"\r\n if not hasattr(self, 'neuron_items') or not self.neuron_items:\r\n self.setup_neural_visualization()\r\n return\r\n \r\n # Update neuron colors based on activation values\r\n for neuron, value in inputs.items():\r\n if neuron in self.neuron_items:\r\n # Only update numerical values\r\n if isinstance(value, (int, float)):\r\n # Update stored value\r\n self.neuron_items[neuron][\"value\"] = value\r\n \r\n # Calculate color based on value (0-100)\r\n intensity = int(value * 2.55) # Scale 0-100 to 0-255\r\n \r\n if neuron in [\"hunger\", \"sleepiness\", \"anxiety\"]:\r\n # Red-based for \"negative\" neurons (more red = higher activation)\r\n color = QtGui.QColor(255, 255 - intensity, 255 - intensity)\r\n else:\r\n # Blue/green-based for \"positive\" neurons (more color = higher activation)\r\n color = QtGui.QColor(100, intensity, 255)\r\n \r\n # Update neuron ellipse color\r\n self.neuron_items[neuron][\"shape\"].setBrush(QtGui.QBrush(color))\r\n \r\n # Make neurons pulse slightly based on value\r\n scale = 1.0 + (value / 200) # 1.0 to 1.5\r\n rect = self.neuron_items[neuron][\"shape\"].rect()\r\n center_x = rect.x() + rect.width()/2\r\n center_y = rect.y() + rect.height()/2\r\n new_width = 40 * scale\r\n new_height = 40 * scale\r\n self.neuron_items[neuron][\"shape\"].setRect(\r\n center_x - new_width/2,\r\n center_y - new_height/2,\r\n new_width,\r\n new_height\r\n )\r\n \r\n # Update connection line widths and colors based on neuron activations\r\n for connection, items in self.connection_items.items():\r\n source, target = connection\r\n source_value = self.neuron_items.get(source, {}).get(\"value\", 50)\r\n target_value = self.neuron_items.get(target, {}).get(\"value\", 50)\r\n \r\n # Calculate connection strength based on both neuron activations\r\n # Higher when both neurons are highly activated\r\n connection_strength = (source_value * target_value) / 10000 # Scale to 0-1\r\n \r\n # Update line width and color\r\n pen_width = 1 + 3 * connection_strength\r\n \r\n # Get current brain connection weight if available\r\n weight = items.get(\"weight\", 0)\r\n \r\n # Color based on weight (green for positive, red for negative)\r\n if weight > 0:\r\n pen_color = QtGui.QColor(0, 150, 0, 50 + int(200 * connection_strength))\r\n else:\r\n pen_color = QtGui.QColor(150, 0, 0, 50 + int(200 * connection_strength))\r\n \r\n items[\"line\"].setPen(QtGui.QPen(pen_color, pen_width))\r\n \r\n # Update the weight display\r\n items[\"text\"].setPlainText(f\"{weight:.1f}\")\r\n\r\n\r\n def update_brain_weights(self, weights_data):\r\n \"\"\"Update the brain connection weights based on current neural network weights\"\"\"\r\n if not hasattr(self, 'connection_items'):\r\n return\r\n \r\n # Update connection weights\r\n for (src, dst), weight in weights_data.items():\r\n # Look for the connection in either direction\r\n connection = (src, dst)\r\n if connection in self.connection_items:\r\n self.connection_items[connection][\"weight\"] = weight\r\n else:\r\n # Try the reverse connection\r\n connection = (dst, src)\r\n if connection in self.connection_items:\r\n self.connection_items[connection][\"weight\"] = weight\r\n \r\n\r\n def animate_decision_process(self, decision_data):\r\n \"\"\"Animate the decision-making process with visual effects\"\"\"\r\n if not hasattr(self, 'processing_animation'):\r\n return\r\n \r\n # Get the decision information\r\n decision = decision_data.get('final_decision', 'unknown')\r\n processing_time = decision_data.get('processing_time', 1000)\r\n \r\n # Display processing text\r\n self.processing_text.setText(f\"Processing decision ({processing_time}ms)...\")\r\n \r\n # Start the animation with a brief delay to show processing\r\n QtCore.QTimer.singleShot(300, lambda: self.highlight_decision_in_ui(decision))\r\n\r\n\r\n def highlight_decision_in_ui(self, decision):\r\n \"\"\"Highlight the chosen decision in the UI\"\"\"\r\n # Update decision output with animation effect\r\n self.decision_output.setText(decision.capitalize())\r\n \r\n # Flash the decision with a highlight animation\r\n original_style = self.decision_output.styleSheet()\r\n self.decision_output.setStyleSheet(\"font-size: 18px; font-weight: bold; color: white; background-color: green; padding: 5px; border-radius: 5px;\")\r\n \r\n # Reset after brief highlight\r\n QtCore.QTimer.singleShot(500, lambda: self.decision_output.setStyleSheet(original_style))\r\n \r\n # Update processing text\r\n self.processing_text.setText(f\"Decision made: {decision.capitalize()}\")\r\n\r\n def update_learning_status(self, is_active):\r\n \"\"\"Update the learning status indicator\"\"\"\r\n if is_active:\r\n self.learning_status.setText(\"Learning Status: Active\")\r\n self.learning_status.setStyleSheet(\"\"\"\r\n font-size: 14px;\r\n padding: 5px;\r\n background-color: #d4edda;\r\n border-radius: 4px;\r\n border: 1px solid #c3e6cb;\r\n color: #155724;\r\n font-weight: bold;\r\n \"\"\")\r\n else:\r\n self.learning_status.setText(\"Learning Status: Inactive\")\r\n self.learning_status.setStyleSheet(\"\"\"\r\n font-size: 14px;\r\n padding: 5px;\r\n background-color: #f8f9fa;\r\n border-radius: 4px;\r\n border: 1px solid #e9ecef;\r\n color: #495057;\r\n \"\"\")\r\n\r\n def update_learning_interval(self, seconds):\r\n \"\"\"Update the learning interval when spinbox value changes\"\"\"\r\n # Convert seconds to milliseconds (QTimer uses ms)\r\n interval_ms = seconds * 1000\r\n \r\n # Update config\r\n if hasattr(self.config, 'hebbian'):\r\n self.config.hebbian['learning_interval'] = interval_ms\r\n else:\r\n self.config.hebbian = {'learning_interval': interval_ms}\r\n \r\n # Restart timer with new interval\r\n if hasattr(self, 'hebbian_timer'):\r\n self.hebbian_timer.setInterval(interval_ms)\r\n self.brain_widget.last_hebbian_time = time.time() # Reset countdown\r\n \r\n # Log the change\r\n self.activity_log.append(f\"\"\"\r\n
\r\n \"\"\")\r\n \r\n # Force update of countdown\r\n self.update_countdown()\r\n\r\n def trigger_learning_cycle(self):\r\n \"\"\"Force an immediate Hebbian learning cycle\"\"\"\r\n if hasattr(self.brain_widget, 'perform_hebbian_learning'):\r\n # Record the current state for before/after comparison\r\n old_weights = {k: v for k, v in self.brain_widget.weights.items()}\r\n \r\n # Perform the learning\r\n self.brain_widget.perform_hebbian_learning()\r\n \r\n # Find changed weights\r\n changes = []\r\n for k, v in self.brain_widget.weights.items():\r\n if k in old_weights and abs(v - old_weights[k]) > 0.001:\r\n changes.append((k, old_weights[k], v))\r\n \r\n # Log the forced learning event\r\n log_html = f\"\"\"\r\n
\"\r\n for (source, target), old_val, new_val in changes[:5]: # Show top 5 changes\r\n direction = \"+\" if new_val > old_val else \"\"\r\n log_html += f\"\"\"\r\n
This is an inhibitory connection. When {source} is active, it will tend to decrease the activity of {target}.
\r\n \"\"\"\r\n \r\n # Check if either neuron is from neurogenesis\r\n if source in self.brain_widget.neurogenesis_data.get('new_neurons', []) or target in self.brain_widget.neurogenesis_data.get('new_neurons', []):\r\n details_html += \"\"\"\r\n
\r\n Note: This connection involves a neuron created through neurogenesis!\r\n
\r\n \"\"\"\r\n \r\n details_html += \"
\"\r\n \r\n # Update the details widget\r\n self.connection_details.setHtml(details_html)\r\n\r\n def apply_neurogenesis_settings(self):\r\n \"\"\"Apply changes to neurogenesis settings\"\"\"\r\n # Validate and update the neurogenesis configuration\r\n if not hasattr(self.config, 'neurogenesis'):\r\n self.config.neurogenesis = {}\r\n \r\n # Get current values from UI\r\n self.config.neurogenesis['novelty_threshold'] = self.novelty_threshold.value()\r\n self.config.neurogenesis['stress_threshold'] = self.stress_threshold.value()\r\n self.config.neurogenesis['reward_threshold'] = self.reward_threshold.value()\r\n self.config.neurogenesis['cooldown'] = self.cooldown_spinbox.value()\r\n \r\n # Log the changes\r\n self.activity_log.append(f\"\"\"\r\n
\r\n \"\"\"\r\n add_stat_box(\"Connection Statistics\", connection_stats, \"#e3f2fd\")\r\n \r\n # 2. Neuron Statistics\r\n all_neurons = self.brain_widget.neuron_positions.keys()\r\n neurons = [n for n in all_neurons if n not in excluded_neurons]\r\n original_neurons = [n for n in neurons if n in getattr(self.brain_widget, 'original_neuron_positions', {})]\r\n new_neurons = [n for n in neurons if n in self.brain_widget.neurogenesis_data.get('new_neurons', [])]\r\n \r\n neuron_stats = f\"\"\"\r\n
\r\n \"\"\"\r\n add_stat_box(\"Learning Parameters\", learning_params, \"#fff3e0\")\r\n \r\n # 4. Strong Influence Neurons\r\n # Find neurons with strongest outgoing connections\r\n neuron_influence = {}\r\n for neuron in neurons:\r\n outgoing_sum = 0\r\n outgoing_count = 0\r\n for (src, dst), weight in filtered_weights.items():\r\n if src == neuron:\r\n outgoing_sum += abs(weight)\r\n outgoing_count += 1\r\n \r\n if outgoing_count > 0:\r\n neuron_influence[neuron] = outgoing_sum / outgoing_count\r\n \r\n top_influence = sorted(neuron_influence.items(), key=lambda x: x[1], reverse=True)[:5]\r\n \r\n influence_stats = \"
\"\r\n for neuron, influence in top_influence:\r\n influence_stats += f\"\"\"\r\n
\r\n
{neuron}
\r\n
{influence:.3f}
\r\n
\r\n \"\"\"\r\n influence_stats += \"
\"\r\n \r\n add_stat_box(\"Top Influential Neurons\", influence_stats, \"#f3e5f5\")\r\n \r\n # 5. Recently Created Neurons\r\n if self.brain_widget.neurogenesis_data.get('new_neurons'):\r\n new_neurons = [n for n in self.brain_widget.neurogenesis_data.get('new_neurons', []) \r\n if n not in excluded_neurons]\r\n last_time = self.brain_widget.neurogenesis_data.get('last_neuron_time', 0)\r\n time_ago = time.time() - last_time\r\n \r\n neurogenesis_stats = f\"\"\"\r\n
Most recent neuron created {int(time_ago/60)} minutes ago.
\r\n
Recent neurons (newest first):
\r\n
\r\n \"\"\"\r\n \r\n for neuron in reversed(new_neurons[-5:]):\r\n neurogenesis_stats += f\"
{neuron}
\"\r\n \r\n neurogenesis_stats += \"
\"\r\n \r\n add_stat_box(\"Neurogenesis\", neurogenesis_stats, \"#ffebee\")\r\n \r\n # Add a stretch to push all boxes to the top\r\n self.stats_box_layout.addStretch()\r\n\r\n def zoom_heatmap(self, value):\r\n \"\"\"Zoom the heatmap view based on slider value\"\"\"\r\n scale = value / 100.0\r\n \r\n # Get current transform\r\n transform = QtGui.QTransform()\r\n transform.scale(scale, scale)\r\n \r\n # Apply new transform\r\n self.heatmap_view.setTransform(transform)\r\n\r\n \r\n\r\n def export_learning_data(self):\r\n \"\"\"Export learning data with all available information\"\"\"\r\n file_name, _ = QtWidgets.QFileDialog.getSaveFileName(\r\n self, \"Export Learning Data\", \"\", \"HTML Files (*.html);;CSV Files (*.csv);;Text Files (*.txt)\")\r\n \r\n if not file_name:\r\n return\r\n \r\n try:\r\n if file_name.endswith('.html'):\r\n self.export_learning_data_html(file_name)\r\n elif file_name.endswith('.csv'):\r\n self.export_learning_data_csv(file_name)\r\n else:\r\n self.export_learning_data_text(file_name)\r\n \r\n # Show success message\r\n QtWidgets.QMessageBox.information(\r\n self, \"Export Successful\", f\"Learning data exported to {file_name}\")\r\n except Exception as e:\r\n QtWidgets.QMessageBox.critical(\r\n self, \"Export Error\", f\"Error exporting data: {str(e)}\")\r\n\r\n def export_learning_data_html(self, file_name):\r\n \"\"\"Export learning data as rich HTML report\"\"\"\r\n with open(file_name, 'w') as f:\r\n # Start HTML document\r\n f.write(\"\"\"\r\n \r\n \r\n Squid Brain Learning Data\r\n \r\n \r\n \r\n
\r\n \"\"\")\r\n \r\n if hasattr(self.config, 'hebbian'):\r\n for param, value in self.config.hebbian.items():\r\n if param == 'learning_interval':\r\n value = f\"{value/1000} seconds\"\r\n f.write(f\"
Total neurons: \"\"\" + str(len(neurons)) + \"\"\"
\r\n
\r\n
\r\n
Neuron
\r\n
Position
\r\n
Type
\r\n
Current Value
\r\n
\r\n \"\"\")\r\n \r\n for neuron in neurons:\r\n neuron_type = \"Original\" if neuron in getattr(self.brain_widget, 'original_neuron_positions', {}) else \"New\"\r\n value = self.brain_widget.state.get(neuron, 0)\r\n position = self.brain_widget.neuron_positions.get(neuron, (0, 0))\r\n \r\n f.write(f\"\"\"\r\n
\r\n \"\"\")\r\n \r\n # End HTML document\r\n f.write(\"\"\"\r\n \r\n \r\n \"\"\")\r\n\r\n def export_learning_data_csv(self, file_name):\r\n \"\"\"Export learning data as CSV\"\"\"\r\n with open(file_name, 'w', newline='') as f:\r\n writer = csv.writer(f)\r\n \r\n # Write neurons section\r\n writer.writerow([\"NEURONS\"])\r\n writer.writerow([\"Neuron\", \"Position X\", \"Position Y\", \"Type\", \"Current Value\"])\r\n \r\n for neuron in sorted(self.brain_widget.neuron_positions.keys()):\r\n neuron_type = \"Original\" if neuron in getattr(self.brain_widget, 'original_neuron_positions', {}) else \"New\"\r\n value = self.brain_widget.state.get(neuron, 0)\r\n position = self.brain_widget.neuron_positions.get(neuron, (0, 0))\r\n \r\n writer.writerow([neuron, position[0], position[1], neuron_type, value])\r\n \r\n # Blank row\r\n writer.writerow([])\r\n \r\n # Write connections section\r\n writer.writerow([\"CONNECTIONS\"])\r\n writer.writerow([\"Source\", \"Target\", \"Weight\"])\r\n \r\n for (source, target), weight in sorted(self.brain_widget.weights.items(), key=lambda x: abs(x[1]), reverse=True):\r\n writer.writerow([source, target, weight])\r\n \r\n # Blank row\r\n writer.writerow([])\r\n \r\n # Write learning parameters\r\n writer.writerow([\"LEARNING PARAMETERS\"])\r\n if hasattr(self.config, 'hebbian'):\r\n for param, value in self.config.hebbian.items():\r\n writer.writerow([param, value])\r\n\r\n def export_learning_data_text(self, file_name):\r\n \"\"\"Export learning data as plain text\"\"\"\r\n with open(file_name, 'w') as f:\r\n f.write(\"SQUID BRAIN LEARNING DATA\\n\")\r\n f.write(\"=========================\\n\")\r\n f.write(f\"Export time: {time.strftime('%Y-%m-%d %H:%M:%S')}\\n\\n\")\r\n \r\n # Learning parameters\r\n f.write(\"LEARNING PARAMETERS\\n\")\r\n f.write(\"-----------------\\n\")\r\n if hasattr(self.config, 'hebbian'):\r\n for param, value in self.config.hebbian.items():\r\n if param == 'learning_interval':\r\n value = f\"{value/1000} seconds\"\r\n f.write(f\"{param}: {value}\\n\")\r\n \r\n f.write(\"\\n\")\r\n \r\n # Neuron information\r\n neurons = sorted(self.brain_widget.neuron_positions.keys())\r\n f.write(f\"NEURONS ({len(neurons)} total)\\n\")\r\n f.write(\"-----------------\\n\")\r\n \r\n for neuron in neurons:\r\n neuron_type = \"Original\" if neuron in getattr(self.brain_widget, 'original_neuron_positions', {}) else \"New\"\r\n value = self.brain_widget.state.get(neuron, 0)\r\n position = self.brain_widget.neuron_positions.get(neuron, (0, 0))\r\n \r\n f.write(f\"{neuron}: Position ({position[0]:.1f}, {position[1]:.1f}), Type: {neuron_type}, Value: {value:.1f}\\n\")\r\n \r\n f.write(\"\\n\")\r\n \r\n # Connection weights\r\n f.write(f\"CONNECTION WEIGHTS ({len(self.brain_widget.weights)} total)\\n\")\r\n f.write(\"-----------------\\n\")\r\n \r\n for (source, target), weight in sorted(self.brain_widget.weights.items(), key=lambda x: abs(x[1]), reverse=True):\r\n f.write(f\"{source} → {target}: {weight:.3f}\\n\")\r\n\r\n def clear_learning_log(self):\r\n \"\"\"Clear the activity log\"\"\"\r\n reply = QtWidgets.QMessageBox.question(\r\n self, \"Clear Log\", \r\n \"Are you sure you want to clear the learning activity log?\",\r\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No\r\n )\r\n \r\n if reply == QtWidgets.QMessageBox.Yes:\r\n self.activity_log.clear()\r\n\r\n# brain_tool.py\r\n\r\n# ... (other imports at the top of brain_tool.py, ensure these are present)\r\n# from PyQt5 import QtCore, QtGui, QtWidgets\r\n# from PyQt5.QtWidgets import QSplitter, QTabWidget, QTableWidget, QTableWidgetItem, QFormLayout, QGroupBox # Explicitly ensure these\r\n# import time # For time.time() in neurogenesis details\r\n# from datetime import datetime # For formatting timestamps\r\n\r\n# ... (SquidBrainWindow class and other preceding code) ...\r\n\r\nclass NeuronInspector(QtWidgets.QDialog):\r\n def __init__(self, brain_tool_window, brain_widget_ref, parent=None): # brain_tool_window is the SquidBrainWindow instance\r\n super().__init__(brain_tool_window) # Set parent to brain_tool_window\r\n self.brain_tool_window = brain_tool_window \r\n self.brain_widget = brain_widget_ref \r\n\r\n self.setWindowTitle(\"Neuron Inspector\")\r\n # Portrait orientation, larger size\r\n self.setFixedSize(450, 700) # Width, Height\r\n\r\n self.main_layout = QtWidgets.QVBoxLayout()\r\n self.setLayout(self.main_layout)\r\n\r\n # Neuron selector\r\n self.neuron_combo = QtWidgets.QComboBox()\r\n self.neuron_combo.setToolTip(\"Select a neuron to inspect or click one in the visualizer.\")\r\n self.main_layout.addWidget(self.neuron_combo)\r\n\r\n # Tab widget\r\n self.tabs = QtWidgets.QTabWidget() #\r\n self.main_layout.addWidget(self.tabs)\r\n\r\n # --- Tab 1: Overview ---\r\n self.overview_tab = QtWidgets.QWidget()\r\n self.overview_layout = QtWidgets.QFormLayout(self.overview_tab) \r\n self.overview_tab.setLayout(self.overview_layout)\r\n self.tabs.addTab(self.overview_tab, \"Overview\")\r\n\r\n self.name_label = QtWidgets.QLabel()\r\n self.value_label = QtWidgets.QLabel()\r\n self.position_label = QtWidgets.QLabel()\r\n self.type_label = QtWidgets.QLabel() # Core or Neurogenesis\r\n\r\n self.overview_layout.addRow(\"Name:\", self.name_label)\r\n self.overview_layout.addRow(\"Current Value:\", self.value_label)\r\n self.overview_layout.addRow(\"Position (X,Y):\", self.position_label)\r\n self.overview_layout.addRow(\"Type:\", self.type_label)\r\n\r\n # Placeholder for neurogenesis info\r\n self.neurogenesis_group = QtWidgets.QGroupBox(\"Neurogenesis Details\") \r\n self.neurogenesis_layout = QtWidgets.QFormLayout() \r\n self.neurogenesis_group.setLayout(self.neurogenesis_layout)\r\n self.neurogenesis_group.setVisible(False) # Hidden by default\r\n\r\n self.created_at_label = QtWidgets.QLabel()\r\n self.trigger_type_label = QtWidgets.QLabel()\r\n self.trigger_value_label = QtWidgets.QLabel()\r\n self.associated_state_label = QtWidgets.QLabel()\r\n self.associated_state_label.setWordWrap(True)\r\n\r\n self.neurogenesis_layout.addRow(\"Created At:\", self.created_at_label)\r\n self.neurogenesis_layout.addRow(\"Trigger Type:\", self.trigger_type_label)\r\n self.neurogenesis_layout.addRow(\"Trigger Value:\", self.trigger_value_label)\r\n self.neurogenesis_layout.addRow(\"Associated State:\", self.associated_state_label)\r\n self.overview_layout.addWidget(self.neurogenesis_group)\r\n\r\n\r\n # --- Tab 2: Connections ---\r\n self.connections_tab = QtWidgets.QWidget()\r\n self.connections_layout = QtWidgets.QVBoxLayout(self.connections_tab)\r\n self.tabs.addTab(self.connections_tab, \"Connections\")\r\n\r\n self.connections_table = QtWidgets.QTableWidget() \r\n self.connections_table.setColumnCount(3)\r\n self.connections_table.setHorizontalHeaderLabels([\"Connected To\", \"Weight\", \"Direction\"])\r\n self.connections_table.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)\r\n self.connections_table.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)\r\n self.connections_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)\r\n self.connections_layout.addWidget(self.connections_table)\r\n\r\n # --- Tab 3: Activity (Placeholder) ---\r\n self.activity_tab = QtWidgets.QWidget()\r\n self.activity_layout = QtWidgets.QVBoxLayout(self.activity_tab)\r\n self.activity_info_label = QtWidgets.QLabel(\"Detailed activity logging and graphing coming soon.\")\r\n self.activity_info_label.setAlignment(QtCore.Qt.AlignCenter)\r\n self.activity_layout.addWidget(self.activity_info_label)\r\n self.tabs.addTab(self.activity_tab, \"Activity\")\r\n\r\n # --- Refresh Button (optional, as it updates on click) ---\r\n self.refresh_btn = QtWidgets.QPushButton(\"Refresh Data\")\r\n self.refresh_btn.clicked.connect(self.update_info)\r\n self.main_layout.addWidget(self.refresh_btn)\r\n\r\n # Connect to brain widget's neuronClicked signal\r\n if hasattr(self.brain_widget, 'neuronClicked'):\r\n self.brain_widget.neuronClicked.connect(self.inspect_neuron_by_name) #\r\n\r\n self.neuron_combo.currentIndexChanged.connect(self.update_info_from_combo)\r\n\r\n self.update_neuron_list()\r\n if self.neuron_combo.count() > 0:\r\n self.update_info() # Initial update\r\n\r\n def update_neuron_list(self):\r\n if not self.brain_widget: return\r\n current_selection = self.neuron_combo.currentText()\r\n self.neuron_combo.clear()\r\n # Sort neuron names for consistent order\r\n neuron_names = sorted(self.brain_widget.neuron_positions.keys())\r\n self.neuron_combo.addItems(neuron_names)\r\n if current_selection in neuron_names:\r\n self.neuron_combo.setCurrentText(current_selection)\r\n elif neuron_names:\r\n self.neuron_combo.setCurrentIndex(0)\r\n\r\n\r\n def inspect_neuron_by_name(self, neuron_name):\r\n \"\"\"Slot to handle neuronClicked signal from BrainWidget.\"\"\"\r\n index = self.neuron_combo.findText(neuron_name)\r\n if index >= 0:\r\n # Block signals temporarily to prevent double update if setCurrentIndex triggers update_info\r\n self.neuron_combo.blockSignals(True)\r\n self.neuron_combo.setCurrentIndex(index)\r\n self.neuron_combo.blockSignals(False)\r\n self.update_info() # Explicitly update after setting index\r\n self.show()\r\n self.raise_()\r\n self.activateWindow()\r\n\r\n\r\n def update_info_from_combo(self):\r\n # This is called when combobox selection changes\r\n self.update_info()\r\n\r\n def update_info(self):\r\n \"\"\"Update all display elements for the currently selected neuron.\"\"\"\r\n if not self.brain_widget:\r\n self.name_label.setText(\"\")\r\n # Clear other fields\r\n self.value_label.setText(\"\")\r\n self.position_label.setText(\"\")\r\n self.type_label.setText(\"\")\r\n self.neurogenesis_group.setVisible(False)\r\n if hasattr(self, 'connections_table'): self.connections_table.setRowCount(0)\r\n return\r\n\r\n neuron_name = self.neuron_combo.currentText()\r\n if not neuron_name or neuron_name not in self.brain_widget.neuron_positions:\r\n # Clear all fields if no valid neuron is selected\r\n self.name_label.setText(\"\")\r\n self.value_label.setText(\"\")\r\n self.position_label.setText(\"\")\r\n self.type_label.setText(\"\")\r\n self.neurogenesis_group.setVisible(False)\r\n if hasattr(self, 'connections_table'): self.connections_table.setRowCount(0)\r\n return\r\n\r\n # --- Overview Tab Data ---\r\n self.name_label.setText(f\"{neuron_name}\")\r\n\r\n value = self.brain_widget.state.get(neuron_name, \"N/A\")\r\n self.value_label.setText(str(round(value, 2) if isinstance(value, (float, int)) else value))\r\n\r\n pos = self.brain_widget.neuron_positions.get(neuron_name, (\"N/A\", \"N/A\"))\r\n self.position_label.setText(f\"({pos[0]:.1f}, {pos[1]:.1f})\" if isinstance(pos, tuple) and len(pos) == 2 and all(isinstance(p, (int,float)) for p in pos) else \"N/A\")\r\n\r\n\r\n # Check if new_neurons_details exists and then if neuron_name is in it\r\n is_neurogenesis = False\r\n if hasattr(self.brain_widget, 'neurogenesis_data') and \\\r\n 'new_neurons_details' in self.brain_widget.neurogenesis_data and \\\r\n neuron_name in self.brain_widget.neurogenesis_data.get('new_neurons_details', {}):\r\n is_neurogenesis = True\r\n\r\n neuron_kind = \"Neurogenesis\" if is_neurogenesis else \"Core\"\r\n if neuron_name in self.brain_widget.excluded_neurons: \r\n neuron_kind = \"System Status\"\r\n self.type_label.setText(neuron_kind)\r\n\r\n if is_neurogenesis:\r\n details = self.brain_widget.neurogenesis_data['new_neurons_details'].get(neuron_name, {})\r\n created_timestamp = details.get('created_at')\r\n if created_timestamp:\r\n # Ensure datetime is imported if not already: from datetime import datetime\r\n from datetime import datetime # Local import for safety\r\n self.created_at_label.setText(datetime.fromtimestamp(created_timestamp).strftime('%Y-%m-%d %H:%M:%S'))\r\n else:\r\n self.created_at_label.setText(\"Unknown\")\r\n self.trigger_type_label.setText(str(details.get('trigger_type', \"N/A\")).capitalize())\r\n \r\n trigger_val = details.get('trigger_value_at_creation', \"N/A\")\r\n self.trigger_value_label.setText(f\"{trigger_val:.2f}\" if isinstance(trigger_val, float) else str(trigger_val))\r\n\r\n\r\n snapshot = details.get('associated_state_snapshot', {})\r\n snapshot_text = \", \".join([f\"{k.capitalize()}: {v}\" for k, v in snapshot.items() if v is not None])\r\n self.associated_state_label.setText(snapshot_text if snapshot_text else \"No specific state captured.\")\r\n self.neurogenesis_group.setVisible(True)\r\n else:\r\n self.neurogenesis_group.setVisible(False)\r\n\r\n # --- Connections Tab Data ---\r\n self.connections_table.setRowCount(0) # Clear previous\r\n connections_data = []\r\n # Ensure brain_widget.weights exists and is a dictionary\r\n if hasattr(self.brain_widget, 'weights') and isinstance(self.brain_widget.weights, dict):\r\n for conn_key, weight_val in self.brain_widget.weights.items():\r\n # Ensure conn_key is a tuple of two strings (neuron names)\r\n if isinstance(conn_key, tuple) and len(conn_key) == 2:\r\n src, dst = conn_key\r\n if src == neuron_name:\r\n connections_data.append({'target': dst, 'weight': weight_val, 'direction': \"Outgoing\"})\r\n elif dst == neuron_name:\r\n connections_data.append({'target': src, 'weight': weight_val, 'direction': \"Incoming\"})\r\n # else:\r\n # print(f\"Skipping malformed weight key: {conn_key}\")\r\n\r\n\r\n self.connections_table.setRowCount(len(connections_data))\r\n for row, conn_info in enumerate(connections_data):\r\n self.connections_table.setItem(row, 0, QtWidgets.QTableWidgetItem(conn_info['target'])) #\r\n item_weight = QtWidgets.QTableWidgetItem(f\"{conn_info['weight']:.3f}\") #\r\n item_weight.setForeground(QtGui.QColor(\"green\") if conn_info['weight'] > 0 else QtGui.QColor(\"red\"))\r\n self.connections_table.setItem(row, 1, item_weight)\r\n self.connections_table.setItem(row, 2, QtWidgets.QTableWidgetItem(conn_info['direction'])) #\r\n\r\n\r\n # Refresh neuron list only if necessary (e.g., if current neuron disappeared)\r\n # This check was simplified; if it causes issues, it might need refinement.\r\n # The primary update path is now through the combobox or direct neuron click.\r\n if self.neuron_combo.findText(neuron_name) == -1 and neuron_name in self.brain_widget.neuron_positions :\r\n self.update_neuron_list()\r\n\r\n\r\n"
},
{
"path": "src/brain_tooltips.py",
"content": "from PyQt5 import QtCore, QtGui, QtWidgets\r\nfrom .display_scaling import DisplayScaling\r\nfrom .localisation import loc \r\nimport time\r\n\r\n\r\nclass EnhancedBrainTooltips:\r\n \"\"\"Scale-aware tooltips for every neuron.\"\"\"\r\n\r\n def __init__(self, brain_widget):\r\n self.brain_widget = brain_widget\r\n self.current_tooltip_neuron = None\r\n self.last_tooltip_time = 0\r\n self.tooltip_delay = 0.3 # seconds\r\n\r\n # ------------------------------------------------------------------\r\n # Safe helpers for optional FunctionalNeuronData attributes\r\n # ------------------------------------------------------------------\r\n def _get_creation_time(self, func_neuron):\r\n if hasattr(func_neuron, 'creation_context'):\r\n return func_neuron.creation_context.timestamp\r\n return time.time()\r\n\r\n def _get_last_activated(self, func_neuron):\r\n return getattr(func_neuron, 'last_activated', 0)\r\n\r\n def _get_neuron_type(self, func_neuron):\r\n if hasattr(func_neuron, \"neuron_type\"):\r\n return func_neuron.neuron_type\r\n if hasattr(func_neuron, \"specialization\"):\r\n return func_neuron.specialization\r\n return loc(\"tooltip_functional\", default=\"functional\")\r\n\r\n # ------------------------------------------------------------------\r\n # Public entry point — keeps old signature for compatibility\r\n # ------------------------------------------------------------------\r\n def show_tooltip_for_position(self, event):\r\n \"\"\"Legacy entry — we ignore event.pos() and use neuron centre.\"\"\"\r\n neuron_name = self.brain_widget.get_neuron_at_pos(event.pos())\r\n if neuron_name:\r\n self.show_tooltip_for_neuron(neuron_name, event.pos())\r\n else:\r\n QtWidgets.QToolTip.hideText()\r\n self.current_tooltip_neuron = None\r\n\r\n # ------------------------------------------------------------------\r\n # New scale-aware tooltip\r\n # ------------------------------------------------------------------\r\n \r\n def show_tooltip_for_neuron(self, neuron_name, _unused_pos):\r\n \"\"\"Show tooltip exactly above the neuron, matching paintEvent coordinates.\"\"\"\r\n if not neuron_name:\r\n self.hide_tooltip()\r\n return\r\n\r\n # Binary neurons will show ON/OFF, continuous neurons show numeric values.\r\n\r\n # 1. Get neuron's logical position\r\n x_logic, y_logic = self.brain_widget.neuron_positions[neuron_name]\r\n \r\n # 2. Calculate layout scale EXACTLY as paintEvent/render worker does\r\n indicator_space = 0 \r\n base_width = 1024\r\n base_height = 768 - indicator_space\r\n \r\n # Use dimensions from the widget\r\n widget_width = self.brain_widget.width()\r\n widget_height = self.brain_widget.height()\r\n \r\n scale_x = widget_width / base_width\r\n scale_y = (widget_height - indicator_space) / max(1, base_height)\r\n scale = max(0.01, min(scale_x, scale_y))\r\n \r\n offset_x = 0\r\n if scale_x > scale_y:\r\n content_width = base_width * scale\r\n offset_x = (widget_width - content_width) / 2\r\n \r\n # 3. Transform logical coordinates to widget coordinates\r\n # Formula: Logical * Scale + Offset\r\n widget_x = int(x_logic * scale + offset_x)\r\n widget_y = int(y_logic * scale + indicator_space)\r\n \r\n # 4. Position tooltip 40px above neuron (visual offset - NOT scaled)\r\n tooltip_pos_widget = QtCore.QPoint(widget_x, widget_y - 40)\r\n \r\n # 5. Convert to global screen coordinates for QToolTip\r\n tooltip_pos_global = self.brain_widget.mapToGlobal(tooltip_pos_widget)\r\n \r\n # 6. Generate and show tooltip (scale only the HTML content)\r\n html = self._generate_tooltip(neuron_name)\r\n scaled_html = DisplayScaling.scale_css(html)\r\n \r\n QtWidgets.QToolTip.showText(tooltip_pos_global, scaled_html, self.brain_widget)\r\n self.current_tooltip_neuron = neuron_name\r\n\r\n def hide_tooltip(self):\r\n QtWidgets.QToolTip.hideText()\r\n self.current_tooltip_neuron = None\r\n\r\n def _generate_tooltip(self, neuron_name):\r\n bw = self.brain_widget\r\n is_functional = (\r\n hasattr(bw, 'enhanced_neurogenesis') and\r\n neuron_name in bw.enhanced_neurogenesis.functional_neurons\r\n )\r\n return (\r\n self._generate_functional_tooltip(neuron_name)\r\n if is_functional\r\n else self._generate_basic_tooltip(neuron_name)\r\n )\r\n\r\n def _generate_functional_tooltip(self, neuron_name):\r\n bw = self.brain_widget\r\n current_value = bw.state.get(neuron_name, 50)\r\n \r\n val_display = f\"{current_value:.1f}\"\r\n \r\n return f\"\"\"\r\n
\r\n {val_display}\r\n
\r\n \"\"\"\r\n\r\n def _is_binary_neuron(self, neuron_name):\r\n \"\"\"\r\n Check if a neuron is binary (outputs only 0 or 100).\r\n \r\n Priority order (first explicit value wins):\r\n 1. neuron_details from loaded brain file (most authoritative)\r\n 2. neurons dict with is_binary field\r\n 3. BINARY_NEURONS constant\r\n 4. Known binary sensors (hardcoded fallback)\r\n \r\n We do NOT use brain_widget.is_binary_neuron() as it may have incorrect logic.\r\n \"\"\"\r\n bw = self.brain_widget\r\n \r\n # Priority 1: Check neuron_details (from loaded brain JSON) - MOST AUTHORITATIVE\r\n if hasattr(bw, 'neuron_details') and neuron_name in bw.neuron_details:\r\n details = bw.neuron_details[neuron_name]\r\n if isinstance(details, dict) and 'is_binary' in details:\r\n return details['is_binary']\r\n \r\n # Priority 2: Check neurons dict (alternative storage in some brain formats)\r\n if hasattr(bw, 'neurons') and neuron_name in bw.neurons:\r\n neuron_data = bw.neurons[neuron_name]\r\n if isinstance(neuron_data, dict) and 'is_binary' in neuron_data:\r\n return neuron_data['is_binary']\r\n \r\n # Priority 3: Check config's neuron definitions\r\n if hasattr(bw, 'config') and bw.config:\r\n try:\r\n neurons_config = bw.config.get_neurogenesis_config().get('neurons', {})\r\n if neuron_name in neurons_config:\r\n neuron_cfg = neurons_config[neuron_name]\r\n if 'is_binary' in neuron_cfg:\r\n return neuron_cfg['is_binary']\r\n except:\r\n pass\r\n \r\n # Priority 4: Check BINARY_NEURONS constant\r\n try:\r\n from .brain_constants import BINARY_NEURONS\r\n if neuron_name in BINARY_NEURONS:\r\n return True\r\n except ImportError:\r\n pass\r\n \r\n # Priority 5: Known binary sensors (hardcoded fallback for core sensors)\r\n # NOTE: plant_proximity is NOT in this list - it's continuous!\r\n KNOWN_BINARY = {\r\n 'can_see_food', 'is_eating', 'is_sleeping', 'is_sick',\r\n 'pursuing_food', 'is_fleeing', 'is_startled'\r\n }\r\n if neuron_name in KNOWN_BINARY:\r\n return True\r\n \r\n # Default: assume continuous (not binary)\r\n return False\r\n\r\n def _generate_basic_tooltip(self, neuron_name):\r\n bw = self.brain_widget\r\n current_value = bw.state.get(neuron_name, 0)\r\n \r\n # Check if this is a binary neuron using comprehensive check\r\n is_binary = self._is_binary_neuron(neuron_name)\r\n \r\n if is_binary:\r\n # For binary neurons, show localized ON/OFF\r\n val_display = loc(\"state_on\") if current_value > 50 else loc(\"state_off\")\r\n else:\r\n # For continuous neurons (including plant_proximity), show numeric value\r\n val_display = f\"{current_value:.1f}\"\r\n \r\n # Minimal black rectangle with white text (matching weight overlay style)\r\n return f\"\"\"\r\n
\r\n {val_display}\r\n
\r\n \"\"\"\r\n\r\n # ------------------------------------------------------------------\r\n # Helpers \r\n # ------------------------------------------------------------------\r\n def _get_connection_summary(self, neuron_name):\r\n bw = self.brain_widget\r\n incoming = [(b, w) for (a, b), w in bw.weights.items() if a == neuron_name]\r\n outgoing = [(b, w) for (a, b), w in bw.weights.items() if b == neuron_name]\r\n top_in = sorted(incoming, key=lambda x: abs(x[1]), reverse=True)[:3]\r\n top_out = sorted(outgoing, key=lambda x: abs(x[1]), reverse=True)[:3]\r\n \r\n lbl_conn_header = loc(\"tooltip_connections_header\")\r\n # Ensure we pass named arguments for formatting\r\n conn_stats = loc(\"tooltip_connections_stats\", incoming=len(incoming), outgoing=len(outgoing))\r\n \r\n lbl_top_in = loc(\"tooltip_top_incoming\")\r\n lbl_top_out = loc(\"tooltip_top_outgoing\")\r\n\r\n html = f\"
\"\r\n html += f\"
\"\r\n html += f\"{lbl_conn_header}: {conn_stats}
\"\r\n\r\n if top_in:\r\n html += f\"
\"\r\n html += f\"⬅️ {lbl_top_in}: \"\r\n for src, wt in top_in:\r\n arrow, color = (\"→\", \"#4CAF50\") if wt > 0 else (\"⊣\", \"#f44336\")\r\n html += f\"{src} {arrow} {wt:.2f} \"\r\n html += \"
\"\r\n\r\n if top_out:\r\n html += f\"
\"\r\n html += f\"➡️ {lbl_top_out}: \"\r\n for tgt, wt in top_out:\r\n arrow, color = (\"→\", \"#4CAF50\") if wt > 0 else (\"⊣\", \"#f44336\")\r\n html += f\"{arrow} {tgt} {wt:.2f} \"\r\n html += \"
\"\r\n\r\n html += \"
\"\r\n return html\r\n\r\n def _get_utility_color(self, utility):\r\n if utility > 0.7:\r\n return \"#4CAF50\"\r\n elif utility > 0.4:\r\n return \"#FFC107\"\r\n elif utility > 0.2:\r\n return \"#FF9800\"\r\n return \"#F44336\"\r\n\r\n def _get_activation_color(self, activation):\r\n deviation = abs(activation - 50)\r\n return \"#F44336\" if deviation > 30 else \"#FF9800\" if deviation > 15 else \"#4CAF50\"\r\n\r\n def _get_utility_indicator(self, utility):\r\n if utility > 0.7:\r\n return \"⭐⭐⭐\"\r\n elif utility > 0.4:\r\n return \"⭐⭐\"\r\n elif utility > 0.2:\r\n return \"⭐\"\r\n return \"⚠️\"\r\n"
},
{
"path": "src/brain_ui_utils.py",
"content": "from datetime import datetime\r\nfrom PyQt5 import QtCore, QtGui, QtWidgets\r\n\r\nclass UiUtils:\r\n @staticmethod\r\n def create_styled_button(text, callback, color, size=(200, 50), font_size=10):\r\n \"\"\"Create a button with consistent styling\"\"\"\r\n button = QtWidgets.QPushButton(text)\r\n button.clicked.connect(callback)\r\n button.setStyleSheet(f\"\"\"\r\n QPushButton {{\r\n background-color: {color}; \r\n border: 1px solid black; \r\n padding: 5px;\r\n font-size: {font_size}px;\r\n border-radius: 5px;\r\n }}\r\n QPushButton:hover {{\r\n background-color: {darken_color(color, 20)};\r\n }}\r\n \"\"\")\r\n button.setFixedSize(size[0], size[1])\r\n return button\r\n \r\n @staticmethod\r\n def format_memory_display(memory):\r\n \"\"\"Format a memory dictionary for display with colored boxes based on valence\"\"\"\r\n if not UiUtils.is_displayable_memory(memory):\r\n return \"\"\r\n \r\n # Get the display text - prefer formatted_value, fall back to value\r\n display_text = memory.get('formatted_value', str(memory.get('value', '')))\r\n \r\n # Skip if the display text contains just a timestamp\r\n if 'timestamp' in display_text.lower() and len(display_text.split()) < 3:\r\n return \"\"\r\n \r\n timestamp = memory.get('timestamp', '')\r\n if isinstance(timestamp, str):\r\n try:\r\n timestamp = datetime.fromisoformat(timestamp).strftime(\"%H:%M:%S\")\r\n except:\r\n timestamp = \"\"\r\n \r\n # Determine valence and color\r\n if memory.get('category') == 'mental_state' and memory.get('key') == 'startled':\r\n interaction_type = \"Negative\"\r\n background_color = \"#FFD1DC\" # Pastel red\r\n elif isinstance(memory.get('raw_value'), dict):\r\n total_effect = sum(float(val) for val in memory['raw_value'].values() \r\n if isinstance(val, (int, float)))\r\n if total_effect > 0:\r\n interaction_type = \"Positive\"\r\n background_color = \"#D1FFD1\" # Pastel green\r\n elif total_effect < 0:\r\n interaction_type = \"Negative\"\r\n background_color = \"#FFD1DC\" # Pastel red\r\n else:\r\n interaction_type = \"Neutral\"\r\n background_color = \"#FFFACD\" # Pastel yellow\r\n else:\r\n interaction_type = \"Neutral\"\r\n background_color = \"#FFFACD\" # Pastel yellow\r\n \r\n # Create HTML formatted memory box\r\n formatted_memory = f\"\"\"\r\n
\r\n
{interaction_type}
\r\n
{display_text}
\r\n
{timestamp}
\r\n
\r\n \"\"\"\r\n \r\n return formatted_memory\r\n \r\n @staticmethod\r\n def _is_displayable_memory(self, memory):\r\n \"\"\"Check if a memory should be displayed in the UI\"\"\"\r\n if not isinstance(memory, dict):\r\n return False\r\n \r\n # Skip timestamp-only memories (they have numeric keys)\r\n if isinstance(memory.get('key'), str) and memory['key'].isdigit():\r\n return False\r\n \r\n # Skip memories that don't have a proper category or value\r\n if not memory.get('category') or not memory.get('value'):\r\n return False\r\n \r\n # Skip memories where the value is just a timestamp number\r\n if isinstance(memory.get('value'), (int, float)) and 'timestamp' in str(memory['value']).lower():\r\n return False\r\n \r\n # Must have either formatted_value or a displayable string value\r\n if 'formatted_value' not in memory and not isinstance(memory.get('value'), str):\r\n return False\r\n \r\n return True\r\n \r\n @staticmethod\r\n def create_memory_card(memory):\r\n \"\"\"Create a styled HTML memory card\"\"\"\r\n # Determine card style\r\n bg_color, border_color = UiUtils.get_memory_colors(memory)\r\n \r\n # Format card HTML\r\n card_html = f\"\"\"\r\n
\r\n \"\"\"\r\n \r\n return card_html\r\n\r\n @staticmethod\r\n def get_memory_colors(memory):\r\n \"\"\"Determine colors based on memory content\"\"\"\r\n if 'positive' in memory.get('tags', []):\r\n return \"#E8F5E9\", \"#C8E6C9\" # Green shades\r\n elif 'negative' in memory.get('tags', []):\r\n return \"#FFEBEE\", \"#FFCDD2\" # Red shades\r\n elif 'novelty' in memory.get('tags', []):\r\n return \"#FFFDE7\", \"#FFF9C4\" # Yellow shades\r\n return \"#F5F5F5\", \"#EEEEEE\" # Default gray\r\n\r\n @staticmethod\r\n def create_info_box(title, content, icon_path=None, bg_color=\"#f8f9fa\"):\r\n \"\"\"Create a styled information box with optional icon\"\"\"\r\n box = QtWidgets.QGroupBox(title)\r\n box.setStyleSheet(f\"\"\"\r\n QGroupBox {{\r\n background-color: {bg_color};\r\n border-radius: 8px;\r\n border: 1px solid #dee2e6;\r\n margin-top: 15px;\r\n padding: 10px;\r\n font-weight: bold;\r\n }}\r\n QGroupBox::title {{\r\n subcontrol-origin: margin;\r\n left: 10px;\r\n padding: 0 5px;\r\n color: #495057;\r\n }}\r\n \"\"\")\r\n \r\n box_layout = QtWidgets.QVBoxLayout(box)\r\n \r\n # Add icon if provided\r\n if icon_path:\r\n icon_label = QtWidgets.QLabel()\r\n icon_label.setPixmap(QtGui.QPixmap(icon_path).scaled(24, 24, QtCore.Qt.KeepAspectRatio))\r\n box_layout.addWidget(icon_label, alignment=QtCore.Qt.AlignRight)\r\n \r\n # Add content\r\n content_label = QtWidgets.QLabel(content)\r\n content_label.setTextFormat(QtCore.Qt.RichText)\r\n content_label.setWordWrap(True)\r\n content_label.setStyleSheet(\"font-weight: normal; color: #343a40;\")\r\n box_layout.addWidget(content_label)\r\n \r\n return box\r\n\r\n# Utility functions\r\ndef darken_color(color, amount=20):\r\n \"\"\"Darken a hex color by the specified amount\"\"\"\r\n # Remove # if present\r\n color = color.lstrip('#')\r\n \r\n # Convert to RGB\r\n r, g, b = tuple(int(color[i:i+2], 16) for i in (0, 2, 4))\r\n \r\n # Darken\r\n r = max(0, r - amount)\r\n g = max(0, g - amount)\r\n b = max(0, b - amount)\r\n \r\n # Convert back to hex\r\n return f\"#{r:02x}{g:02x}{b:02x}\""
},
{
"path": "src/brain_utils.py",
"content": "from PyQt5 import QtCore, QtGui, QtWidgets\r\n\r\nclass ConsoleOutput:\r\n def __init__(self, text_edit):\r\n self.text_edit = text_edit\r\n\r\n def write(self, text):\r\n cursor = self.text_edit.textCursor()\r\n format = QtGui.QTextCharFormat()\r\n\r\n if text.startswith(\"Previous value:\"):\r\n format.setForeground(QtGui.QColor(\"red\"))\r\n elif text.startswith(\"New value:\"):\r\n format.setForeground(QtGui.QColor(\"green\"))\r\n else:\r\n format.setForeground(QtGui.QColor(\"black\"))\r\n\r\n cursor.insertText(text, format)\r\n self.text_edit.setTextCursor(cursor)\r\n self.text_edit.ensureCursorVisible()\r\n\r\n def flush(self):\r\n pass\r\n\r\n"
},
{
"path": "src/brain_widget.py",
"content": "import sys\r\nimport csv\r\nimport os\r\nimport re\r\nimport time\r\nimport math\r\nimport random\r\nimport numpy as np\r\nimport json\r\n\r\n# This is the biggest, messiest and most shameful of all the files in this project\r\n# I express my condolences to future devs that curse the mighty brain_widget on late nights as I do\r\n\r\nfrom PyQt5 import QtCore, QtGui, QtWidgets\r\nfrom PyQt5.QtWidgets import QSplitter\r\nfrom PyQt5.QtGui import QPixmap, QFont, QImage\r\nfrom datetime import datetime\r\n\r\nfrom .brain_render_worker import BrainRenderWorker, create_render_state_from_widget, RenderState\r\nfrom .brain_worker import BrainWorker\r\nfrom .compute_backend import get_backend\r\nfrom .neurogenesis import EnhancedNeurogenesis, ExperienceBuffer\r\nfrom .brain_tooltips import EnhancedBrainTooltips\r\nfrom .brain_constants import CORE_NEURONS, INPUT_SENSORS, is_core_neuron\r\nfrom .personality import Personality\r\nfrom .learning import LearningConfig\r\nfrom .laboratory import NeuronLaboratory\r\nfrom .localisation import Localisation\r\nfrom typing import Dict, Optional\r\n\r\n# Brain state bridge for designer communication\r\ntry:\r\n from .brain_state_bridge import (\r\n export_brain_state,\r\n set_game_running,\r\n update_brain_state_from_widget\r\n )\r\n _HAS_BRAIN_BRIDGE = True\r\nexcept ImportError:\r\n try:\r\n # Try without relative import for standalone testing\r\n from brain_state_bridge import (\r\n export_brain_state,\r\n set_game_running,\r\n update_brain_state_from_widget\r\n )\r\n _HAS_BRAIN_BRIDGE = True\r\n except ImportError:\r\n _HAS_BRAIN_BRIDGE = False\r\n print(\"[BrainWidget] Warning: brain_state_bridge not found, designer sync disabled\")\r\n\r\nfrom .animation_styles import (\r\n AnimationStyle, VibrantStyle, SubtleStyle,\r\n get_animation_style, get_available_styles, get_style_info,\r\n ANIMATION_STYLES\r\n)\r\n\r\n# Performance tracking for Task Manager\r\ntry:\r\n from .task_manager import perf_tracker\r\n _PERF_TRACKING_AVAILABLE = True\r\nexcept ImportError:\r\n _PERF_TRACKING_AVAILABLE = False\r\n\r\nclass BrainWidget(QtWidgets.QWidget):\r\n \r\n neuronClicked = QtCore.pyqtSignal(str)\r\n animationStyleChanged = QtCore.pyqtSignal(str) # Emitted when style changes\r\n neuronCreated = QtCore.pyqtSignal(str) # Emitted when neurogenesis creates a new neuron\r\n\r\n def __init__(self, config=None, debug_mode=False, tamagotchi_logic=None,\r\n animation_style: str = \"vibrant\"):\r\n self.resolution_scale = 1.0 # Default resolution scale\r\n self.config = config if config else LearningConfig()\r\n self._laboratory = None\r\n self._last_lang = Localisation.instance().current_language\r\n \r\n # ===== ANIMATION STYLE INITIALIZATION =====\r\n self._animation_style_name = animation_style\r\n self._animation_style: AnimationStyle = get_animation_style(animation_style)\r\n self.layers = []\r\n\r\n # State update batching\r\n self._pending_state_update = False\r\n self.state_update_queue = []\r\n \r\n # Caches for neuron data\r\n self.neurons = {}\r\n self.state_colors = {}\r\n \r\n # Hover tracking\r\n self.hovered_neuron = None\r\n self.hovered_connection = None\r\n self.hover_value_display_active = False\r\n self.hover_value_opacity = 0.0\r\n self.hover_value_animation_time = 0.0\r\n self.hover_animation_time = 0\r\n if not hasattr(self.config, 'hebbian'): #\r\n self.config.hebbian = { #\r\n 'learning_interval': 30000, #\r\n 'weight_decay': 0.01, #\r\n 'active_threshold': 50 #\r\n }\r\n super().__init__() #\r\n\r\n # Get neuron label font size from config (single source of truth)\r\n display_config = self.config.get_display_config()\r\n self.neuron_label_font_size = display_config['neuron_label_font_size']\r\n\r\n # Tutorial glow effect properties\r\n self.tutorial_glow_active = False\r\n self.tutorial_glow_timer = None\r\n self.tutorial_glow_animation = None\r\n self._tutorial_glow_opacity = 0.0\r\n self._link_fade_speeds = {} # (src,dst) → fade speed per link\r\n self._link_start_times = {} # (src,dst) → when this link should start\r\n\r\n from .neurogenesis_show import ShowmanNeurogenesis\r\n real_engine = EnhancedNeurogenesis(self, config)\r\n self.enhanced_neurogenesis = ShowmanNeurogenesis(real_engine)\r\n self.excluded_neurons = ['is_sick', 'is_eating', 'pursuing_food', 'direction', 'is_sleeping']\r\n \r\n # Build animation palette from selected style\r\n self._build_animation_palette()\r\n \r\n self.hebbian_countdown_seconds = 30 # Default duration\r\n self.learning_active = True #\r\n self.pruning_enabled = True #\r\n self.debug_mode = debug_mode # Initialize debug_mode\r\n self.is_paused = False #\r\n self.weights = {} # Init weights early\r\n self.last_hebbian_time = time.time() #\r\n self.last_neurogenesis_type = None\r\n self.tamagotchi_logic = tamagotchi_logic #\r\n self.recently_updated_neuron_pairs = [] #\r\n self.neuron_shapes = {} #\r\n \r\n\r\n # Neural communication tracking system\r\n self.communication_events = {} #\r\n self.communication_highlight_duration = 0.5 #\r\n self.weight_change_events = {} #\r\n self.activity_duration = 0.5 #\r\n\r\n # ADDED IN 2.4.5.0: Replace simple neurogenesis_data with enhanced system\r\n self.enhanced_neurogenesis = EnhancedNeurogenesis(self, self.config)\r\n self.experience_buffer = self.enhanced_neurogenesis.experience_buffer\r\n\r\n # Ensure neurogenesis config exists\r\n if not hasattr(self.config, 'neurogenesis'): #\r\n self.config.neurogenesis = {\r\n 'decay_rate': 0.75, # Default decay rate if not specified\r\n 'novelty_threshold': 3.0, #\r\n 'stress_threshold': 1.2, #\r\n 'reward_threshold': 3.5, #\r\n 'cooldown': 180, #\r\n 'highlight_duration': 5.0, #\r\n 'max_neurons': 50\r\n }\r\n\r\n self.neurogenesis_config = self.config.neurogenesis \r\n self.neurogenesis_data = {\r\n 'new_neurons': [],\r\n 'last_neuron_time': time.time(),\r\n 'new_neurons_details': {} # used by inspector / logging\r\n }\r\n\r\n # Neural state initialization\r\n self.state = { #\r\n \"can_see_food\": 0,\r\n \"hunger\": 50, #\r\n \"happiness\": 50, #\r\n \"cleanliness\": 50, #\r\n \"sleepiness\": 50, #\r\n \"satisfaction\": 50, #\r\n \"anxiety\": 50, #\r\n \"curiosity\": 50, #\r\n \"is_sick\": False, #\r\n \"is_eating\": False, #\r\n \"is_sleeping\": False, #\r\n \"pursuing_food\": False, #\r\n \"direction\": \"up\", #\r\n \"position\": (0, 0), #\r\n \"is_startled\": False, #\r\n \"is_fleeing\": False, #\r\n 'neurogenesis_active': True\r\n }\r\n\r\n # Neuron position configuration\r\n self.original_neuron_positions = { #\r\n \"can_see_food\": (50, 200),\r\n \"hunger\": (127, 81), #\r\n \"happiness\": (361, 81), #\r\n \"cleanliness\": (627, 81), #\r\n \"sleepiness\": (840, 81), #\r\n \"satisfaction\": (271, 380), #\r\n \"anxiety\": (491, 389), #\r\n \"curiosity\": (701, 386) #\r\n }\r\n self.neuron_positions = self.original_neuron_positions.copy() \r\n\r\n # Randomize positions if configured ---\r\n neuron_props = self.config.neurogenesis.get('neuron_properties', {})\r\n if neuron_props.get('randomize_start_positions', False):\r\n self._randomize_all_positions()\r\n\r\n # Ensure connection to hunger exists (always)\r\n self.weights[(\"can_see_food\", \"hunger\")] = 0.2 # Seeing food increases hunger slightly\r\n\r\n # Random chance (50%) for happiness connection\r\n if random.random() < 0.5:\r\n self.weights[(\"can_see_food\", \"happiness\")] = 0.5 # Seeing food can increase happiness\r\n\r\n # Track which neurons are visible (for animated reveal on new game)\r\n self.visible_neurons = set()\r\n # List of core neurons in reveal order\r\n self.original_neurons = [\"can_see_food\", \"hunger\", \"happiness\", \"cleanliness\", \"sleepiness\", \r\n \"satisfaction\", \"anxiety\", \"curiosity\"]\r\n # Animation state for neuron reveals\r\n self.neuron_reveal_animations = {} # {neuron_name: {'start_time': float, 'progress': float}}\r\n # --- link fade animation ---\r\n self._link_opacities = {} # (src,dst) → current opacity 0.0-1.0\r\n self._link_targets = {} # (src,dst) → target opacity 0 or 1\r\n self._link_fade_timer = QtCore.QTimer(self)\r\n self._link_fade_timer.setInterval(16) # ~60 FPS\r\n self._link_fade_timer.timeout.connect(self._advance_link_fades)\r\n self._auto_fade_links_pending = False \r\n \r\n # Tutorial mode flag\r\n self.is_tutorial_mode = False\r\n \r\n # Track revealed neurons and connections for synced count display during animation\r\n # NOTE: These should ONLY be used when is_tutorial_mode is True\r\n self.revealed_neurons = set()\r\n self.revealed_connections = set()\r\n\r\n # Initialize communication events for all neurons\r\n for neuron in self.neuron_positions.keys(): #\r\n self.communication_events[neuron] = 0 #\r\n\r\n # Animation control variables\r\n self.animation_timer = QtCore.QTimer(self)\r\n self.animation_timer.timeout.connect(self.update_animations)\r\n\r\n # ===== PERFORMANCE FIX: Don't create BrainWorker here =====\r\n # BrainWorker will be provided externally via set_brain_worker()\r\n # This prevents multiple worker threads competing for CPU\r\n self.brain_worker = None # Will be set by SquidBrainWindow\r\n print(\"🧵 BrainWorker will be set externally\")\r\n \r\n # Threading control flags\r\n self._use_threaded_processing = True\r\n self._pending_neurogenesis_check = False\r\n self._pending_hebbian_learning = False\r\n\r\n # NEUROGENESIS FIX: Start monitoring timer\r\n self.neurogenesis_timer = QtCore.QTimer(self)\r\n self.neurogenesis_timer.timeout.connect(self._periodic_neurogenesis_check)\r\n self.neurogenesis_timer.start(2000) # Check every 2 seconds\r\n print(\"🧬 Neurogenesis monitoring timer started\")\r\n \r\n # Brain state bridge: export state for designer synchronization\r\n if _HAS_BRAIN_BRIDGE:\r\n self._brain_export_timer = QtCore.QTimer(self)\r\n self._brain_export_timer.timeout.connect(self.export_brain_state_for_designer)\r\n self._brain_export_timer.start(5000) # Export every 5 seconds\r\n set_game_running(True) # Mark game as running\r\n print(\"🔗 Brain state export enabled for designer sync\")\r\n \r\n self.animation_timer.start(40) # 2.5.0.0 performance fix\r\n self._last_animation_update = 0 # For throttling\r\n \r\n # ===== PERFORMANCE FIX: Cache for expensive paint objects =====\r\n self._cached_fonts = {}\r\n self._cached_pens = {}\r\n \r\n self.neuron_sizes = {} # For smooth size transitions\r\n self.weight_animations = [] # Track multiple weight changes\r\n self.neurogenesis_highlight = {\r\n 'neuron': None,\r\n 'start_time': 0,\r\n 'duration': 5.0,\r\n 'pulse_phase': 0\r\n }\r\n\r\n # Add neurogenesis visualization tracking\r\n self.neurogenesis_highlight = { #\r\n 'neuron': None, #\r\n 'start_time': 0, #\r\n 'duration': 5.0 # seconds\r\n }\r\n\r\n # Connection and weight initialization\r\n self.connections = self.initialize_connections() #\r\n self.initialize_weights() # Populate weights\r\n \r\n self.show_links = True #\r\n self.frozen_weights = None #\r\n self.history = [] #\r\n self.training_data = [] #\r\n self.learning_rate = 0.1 #\r\n\r\n # --- Compute backend (NumPy default, optional ONNX for NPU support) ---\r\n self.compute_backend = get_backend()\r\n self.associations = self.compute_backend.zeros(\r\n (len(self.neuron_positions), len(self.neuron_positions))\r\n ) #\r\n self.capture_training_data_enabled = False #\r\n self.dragging = False #\r\n self.dragged_neuron = None #\r\n self.drag_start_pos = None #\r\n self.tooltip_manager = EnhancedBrainTooltips(self)\r\n self.setMouseTracking(True)\r\n self.show_weights = False\r\n\r\n # Ensure connections to hunger and happiness exist with initial weights\r\n self.weights[(\"can_see_food\", \"hunger\")] = 0.2 # Seeing food increases hunger slightly\r\n self.weights[(\"can_see_food\", \"happiness\")] = 0.5\r\n _link_fade_speed = 3.0 # opacity units per second (tweak for faster/slower)\r\n\r\n # ===== OFFSCREEN RENDERING SETUP =====\r\n # Initialize render worker for background rendering\r\n self._render_worker = BrainRenderWorker(self)\r\n self._render_worker.render_complete.connect(self._on_render_complete)\r\n self._render_worker.start()\r\n \r\n # Cached rendered image\r\n self._cached_render: Optional[QImage] = None\r\n self._render_dirty = True\r\n \r\n # Render throttling\r\n self._last_render_request = 0.0\r\n self._render_interval = 1.0 / 10.0 # 10 FPS target\r\n \r\n # State change tracking for smart re-rendering\r\n self._last_state_hash = None\r\n \r\n # Timer for periodic render requests (catches animation updates)\r\n self._render_timer = QtCore.QTimer(self)\r\n self._render_timer.timeout.connect(self._request_render_if_dirty)\r\n self._render_timer.start(100) # 10 FPS\r\n\r\n def set_brain_worker(self, worker):\r\n \"\"\"Accept an external BrainWorker instance.\"\"\"\r\n \r\n self.brain_worker = worker # Always set the new worker\r\n \r\n # Reconnect signals (disconnect old ones first to avoid duplicates)\r\n if hasattr(self, 'brain_worker'):\r\n try:\r\n self.brain_worker.neurogenesis_result.disconnect(self._on_neurogenesis_complete)\r\n self.brain_worker.hebbian_result.disconnect(self._on_hebbian_complete)\r\n self.brain_worker.state_update_result.disconnect(self._on_state_update_complete)\r\n self.brain_worker.error_occurred.disconnect(self._on_worker_error)\r\n except:\r\n pass # Ignore if signals weren't connected\r\n \r\n # Connect new signals\r\n self.brain_worker.neurogenesis_result.connect(self._on_neurogenesis_complete)\r\n self.brain_worker.hebbian_result.connect(self._on_hebbian_complete)\r\n self.brain_worker.state_update_result.connect(self._on_state_update_complete)\r\n self.brain_worker.error_occurred.connect(self._on_worker_error)\r\n \r\n print(\"🧵 BrainWidget received external BrainWorker\")\r\n\r\n # =========================================================================\r\n # BRAIN STATE BRIDGE METHODS (for designer synchronization)\r\n # =========================================================================\r\n def showEvent(self, event):\r\n \"\"\"Ensure render is requested when widget becomes visible.\"\"\"\r\n super().showEvent(event)\r\n self.mark_render_dirty()\r\n # Reset render throttle to force immediate update\r\n self._last_render_request = 0\r\n self._request_render()\r\n \r\n def export_brain_state_for_designer(self):\r\n \"\"\"\r\n Export current brain state to shared file for designer import.\r\n Public method - can be called by NetworkTab before launching designer.\r\n \"\"\"\r\n if not _HAS_BRAIN_BRIDGE:\r\n return\r\n \r\n try:\r\n # Ensure the game lock exists\r\n set_game_running(True)\r\n \r\n # Export the actual data\r\n update_brain_state_from_widget(self)\r\n except Exception as e:\r\n # Silent failure - don't spam console\r\n pass\r\n \r\n def cleanup_brain_bridge(self):\r\n \"\"\"\r\n Clean up brain bridge files when widget is destroyed.\r\n Should be called when the game exits.\r\n \"\"\"\r\n if _HAS_BRAIN_BRIDGE:\r\n try:\r\n set_game_running(False)\r\n print(\"🔗 Brain state bridge cleaned up\")\r\n except Exception:\r\n pass\r\n \r\n def closeEvent(self, event):\r\n \"\"\"Handle widget close - clean up brain bridge.\"\"\"\r\n self.cleanup_brain_bridge()\r\n self._cleanup_render_worker()\r\n super().closeEvent(event) if hasattr(super(), 'closeEvent') else None\r\n event.accept()\r\n\r\n\r\n def set_debug_mode(self, enabled):\r\n \"\"\"Set debug mode without causing circular callbacks\"\"\"\r\n # Only proceed if there's an actual change\r\n if self.debug_mode == enabled:\r\n return\r\n\r\n # Update our own state\r\n self.debug_mode = enabled\r\n\r\n # Update brain widget\r\n if hasattr(self, 'brain_widget'):\r\n self.brain_widget.debug_mode = enabled\r\n\r\n # Update tabs\r\n for tab_name in ['network_tab', 'nn_viz_tab', 'memory_tab', 'decisions_tab', 'about_tab']:\r\n if hasattr(self, tab_name):\r\n tab = getattr(self, tab_name)\r\n if hasattr(tab, 'debug_mode'):\r\n tab.debug_mode = enabled\r\n\r\n # Enable/disable debug-specific UI elements\r\n if hasattr(self, 'stimulate_button'):\r\n self.stimulate_button.setEnabled(enabled)\r\n\r\n print(f\"Brain window debug mode set to: {enabled}\")\r\n\r\n \r\n def _request_render_if_dirty(self):\r\n \"\"\"Called by timer to request render if state has changed\"\"\"\r\n if self._render_dirty or self._has_active_animations():\r\n self._request_render()\r\n\r\n def _has_active_animations(self) -> bool:\r\n \"\"\"Check if there are active animations requiring re-render\"\"\"\r\n current_time = time.time()\r\n \r\n # Check communication events (connection animations)\r\n for neuron, event_time in self.communication_events.items():\r\n if current_time - event_time < 0.5: # 500ms animation\r\n return True\r\n \r\n # Check link fade animations\r\n for key, opacity in getattr(self, '_link_opacities', {}).items():\r\n target = getattr(self, '_link_targets', {}).get(key, opacity)\r\n if abs(opacity - target) > 0.01:\r\n return True\r\n \r\n return False\r\n \r\n def _request_render(self):\r\n \"\"\"Request a new render from the worker thread\"\"\"\r\n current_time = time.time()\r\n \r\n # Throttle requests\r\n if current_time - self._last_render_request < self._render_interval:\r\n return\r\n \r\n self._last_render_request = current_time\r\n \r\n # Create state snapshot and send to worker\r\n try:\r\n state = create_render_state_from_widget(self)\r\n self._render_worker.request_render(state)\r\n self._render_dirty = False\r\n except Exception as e:\r\n print(f\"Error creating render state: {e}\")\r\n\r\n def _on_render_complete(self, image: QImage, render_time: float):\r\n \"\"\"Called when render worker completes a frame\"\"\"\r\n self._cached_render = image\r\n # Trigger a lightweight repaint to show the new image\r\n self.update()\r\n\r\n def mark_render_dirty(self):\r\n \"\"\"Call this when state changes that require re-render\"\"\"\r\n self._render_dirty = True\r\n\r\n def _cleanup_render_worker(self):\r\n \"\"\"Clean up the render worker - call on widget destruction\"\"\"\r\n if hasattr(self, '_render_worker') and self._render_worker:\r\n self._render_worker.stop()\r\n self._render_worker.wait(1000) # Wait up to 1 second\r\n self._render_worker = None\r\n \r\n if hasattr(self, '_render_timer') and self._render_timer:\r\n self._render_timer.stop()\r\n\r\n # =========================================================================\r\n # ANIMATION STYLE METHODS\r\n # =========================================================================\r\n \r\n def _build_animation_palette(self):\r\n \"\"\"\r\n Load visual settings from the current animation style.\r\n Called during init and when style changes.\r\n \"\"\"\r\n style = self._animation_style\r\n \r\n # Connection line settings\r\n self.anim_line_base_width = style.line_base_width\r\n self.anim_line_col_pos = style.line_colour_positive\r\n self.anim_line_col_neg = style.line_colour_negative\r\n self.anim_line_alpha = style.line_alpha\r\n self.anim_use_thick_lines = style.use_thick_lines\r\n \r\n # [NEW] Weight-based thickness settings (MISSING IN PREVIOUS VERSION)\r\n self.weight_thickness_enabled = getattr(style, 'weight_thickness_enabled', False)\r\n self.weight_thickness_min = getattr(style, 'weight_thickness_min', 1.0)\r\n self.weight_thickness_max = getattr(style, 'weight_thickness_max', 2.0)\r\n self.weight_thickness_power = getattr(style, 'weight_thickness_power', 1.0)\r\n \r\n # Stress-anxiety connection\r\n self.anim_stress_width = style.stress_anxiety_width\r\n self.anim_stress_colour = style.stress_anxiety_colour\r\n self.anim_stress_dashed = style.stress_anxiety_dashed\r\n \r\n # Pulse/travelling dot settings\r\n self.anim_pulse_enabled = style.pulse_enabled\r\n self.anim_pulse_colour = style.pulse_colour\r\n self.anim_pulse_alpha = style.pulse_alpha\r\n self.anim_pulse_duration = style.pulse_duration\r\n self.anim_pulse_speed = style.pulse_speed\r\n self.anim_pulse_diameter = style.pulse_diameter\r\n \r\n # Glow effect settings\r\n self.anim_glow_enabled = style.glow_enabled\r\n self.anim_glow_colour = style.glow_colour\r\n self.anim_glow_alpha = style.glow_alpha\r\n self.anim_glow_fade_threshold = style.glow_fade_threshold\r\n \r\n # Hover effect settings\r\n self.anim_hover_enabled = style.hover_enabled\r\n self.anim_hover_scale = style.hover_scale\r\n self.anim_hover_duration = style.hover_animation_duration\r\n \r\n # Activity highlight settings\r\n self.anim_activity_enabled = style.activity_highlight_enabled\r\n self.anim_activity_colour = style.activity_highlight_colour\r\n self.anim_activity_alpha = style.activity_highlight_alpha\r\n self.anim_activity_pulse_speed = style.activity_pulse_speed\r\n \r\n # Neurogenesis highlight settings\r\n self.anim_neurogenesis_colour = style.neurogenesis_highlight_colour\r\n self.anim_neurogenesis_alpha = style.neurogenesis_highlight_alpha\r\n self.anim_neurogenesis_duration = style.neurogenesis_highlight_duration\r\n \r\n # Background color\r\n self.anim_background_colour = style.background_colour\r\n \r\n # ===== VIBRANT STYLE: AMBIENT PULSING =====\r\n self.anim_ambient_pulse_enabled = style.ambient_pulse_enabled\r\n self.anim_ambient_pulse_width_range = style.ambient_pulse_width_range\r\n self.anim_ambient_pulse_alpha_range = style.ambient_pulse_alpha_range\r\n self.anim_ambient_pulse_freq_range = style.ambient_pulse_freq_range\r\n self.anim_ambient_pulse_phase_drift = style.ambient_pulse_phase_drift\r\n \r\n # ===== SUBTLE STYLE: COMMUNICATION GLOWS =====\r\n self.anim_comm_glow_enabled = style.comm_glow_enabled\r\n self.anim_comm_glow_colour = style.comm_glow_colour\r\n self.anim_comm_glow_alpha = style.comm_glow_alpha\r\n self.anim_comm_glow_size = style.comm_glow_size\r\n self.anim_comm_glow_tail_length = style.comm_glow_tail_length\r\n self.anim_comm_glow_speed_range = style.comm_glow_speed_range\r\n self.anim_comm_glow_fade_in = style.comm_glow_fade_in\r\n self.anim_comm_glow_fade_out = style.comm_glow_fade_out\r\n self.anim_comm_glow_spawn_on_activity = style.comm_glow_spawn_on_activity\r\n self.anim_comm_glow_spawn_on_weight_change = style.comm_glow_spawn_on_weight_change\r\n self.anim_comm_glow_max_per_connection = style.comm_glow_max_per_connection\r\n\r\n # ===== SUBTLE STYLE: SCROLLING DOTS =====\r\n # [NEW] Ensure scrolling settings are mapped\r\n self.anim_scroll_enabled = getattr(style, 'scroll_enabled', False)\r\n self.anim_scroll_dot_count = getattr(style, 'scroll_dot_count', 3)\r\n self.anim_scroll_dot_size = getattr(style, 'scroll_dot_size', 6.0)\r\n self.anim_scroll_dot_colour = getattr(style, 'scroll_dot_colour', (255, 255, 255))\r\n self.anim_scroll_dot_alpha = getattr(style, 'scroll_dot_alpha', 200)\r\n self.anim_scroll_speed_range = getattr(style, 'scroll_speed_range', (1.5, 4.0))\r\n \r\n # ===== NEURAL STYLE: ACTIVATION PULSES =====\r\n self.anim_neural_pulse_enabled = style.neural_pulse_enabled\r\n self.anim_neural_pulse_duration = style.neural_pulse_duration\r\n self.anim_neural_pulse_width = style.neural_pulse_width\r\n self.anim_neural_pulse_colour_pos = style.neural_pulse_colour_positive\r\n self.anim_neural_pulse_colour_neg = style.neural_pulse_colour_negative\r\n self.anim_neural_weight_thickness = style.neural_weight_thickness\r\n self.anim_neural_weight_thickness_mult = style.neural_weight_thickness_mult\r\n self.anim_neural_base_colour_pos = style.neural_base_colour_positive\r\n self.anim_neural_base_colour_neg = style.neural_base_colour_negative\r\n self.anim_neural_base_alpha = style.neural_base_alpha\r\n \r\n # Initialize style-specific animation state\r\n self._init_style_animation_state()\r\n \r\n print(f\"🎨 Animation palette built for style: {style.display_name}\")\r\n\r\n def is_binary_neuron(self, neuron_name: str) -> bool:\r\n \"\"\"Return True if neuron represents a binary (on/off) state.\"\"\"\r\n binary_neurons = {\r\n 'can_see_food',\r\n 'is_eating',\r\n 'is_sleeping',\r\n 'is_sick',\r\n 'pursuing_food',\r\n 'is_fleeing',\r\n 'is_startled',\r\n 'external_stimulus', # usually high/low, treat as binary-ish\r\n 'plant_proximity', # 2.6.0.2 consider this could be analog\r\n }\r\n return neuron_name in binary_neurons\r\n \r\n def get_animation_style(self) -> str:\r\n \"\"\"Get the current animation style name.\"\"\"\r\n return self._animation_style_name\r\n \r\n def get_animation_style_info(self) -> tuple:\r\n \"\"\"Get (name, display_name, description) for current style.\"\"\"\r\n style = self._animation_style\r\n return (style.name, style.display_name, style.description)\r\n \r\n def set_animation_style(self, style_name: str) -> bool:\r\n \"\"\"\r\n Switch to a different animation style at runtime.\r\n \r\n Args:\r\n style_name: One of 'classic', 'vibrant', or 'subtle'\r\n \r\n Returns:\r\n True if style was changed, False if style name is invalid\r\n \"\"\"\r\n try:\r\n new_style = get_animation_style(style_name)\r\n except KeyError:\r\n print(f\"⚠️ Unknown animation style: {style_name}. \"\r\n f\"Available: {get_available_styles()}\")\r\n return False\r\n \r\n if style_name == self._animation_style_name:\r\n return True # Already using this style\r\n \r\n old_style = self._animation_style_name\r\n self._animation_style_name = style_name\r\n self._animation_style = new_style\r\n self._build_animation_palette()\r\n \r\n # Trigger repaint with new style\r\n self.update()\r\n \r\n # Emit signal for any listeners\r\n self.animationStyleChanged.emit(style_name)\r\n \r\n print(f\"🎨 Animation style changed: {old_style} → {style_name}\")\r\n return True\r\n \r\n @staticmethod\r\n def get_available_animation_styles() -> list:\r\n \"\"\"Get list of available animation style names.\"\"\"\r\n return get_available_styles()\r\n \r\n @staticmethod\r\n def get_animation_styles_info() -> list:\r\n \"\"\"Get list of (name, display_name, description) for all styles.\"\"\"\r\n return get_style_info()\r\n\r\n def _init_style_animation_state(self):\r\n \"\"\"\r\n Initialize state tracking for style-specific animations.\r\n Called when style changes or on startup.\r\n \"\"\"\r\n # ===== VIBRANT: Ambient pulse state =====\r\n # Each connection gets its own phase and frequency for organic pulsing\r\n if not hasattr(self, '_ambient_pulse_state'):\r\n self._ambient_pulse_state = {} # key: (src, dst) -> {phase, freq, phase_drift_dir}\r\n \r\n # ===== SUBTLE: Communication glow state =====\r\n # Each connection has a list of traveling glow packets\r\n if not hasattr(self, '_comm_glow_packets'):\r\n self._comm_glow_packets = {} # key: (src, dst) -> [{progress, speed, direction}]\r\n \r\n # Track last spawn times to prevent glow spam\r\n if not hasattr(self, '_comm_glow_last_spawn'):\r\n self._comm_glow_last_spawn = {} # key: (src, dst) -> timestamp\r\n \r\n # ===== NEURAL: Activation pulse state =====\r\n # Tracks traveling activation pulses for the neural style\r\n if not hasattr(self, '_neural_pulses'):\r\n self._neural_pulses = {} # key: (src, dst) -> [{start_time, color}]\r\n \r\n def _get_or_create_ambient_pulse(self, conn_key):\r\n \"\"\"\r\n Get or create ambient pulse state for a connection.\r\n Each connection pulses at its own unique rate.\r\n \"\"\"\r\n if conn_key not in self._ambient_pulse_state:\r\n # Assign random frequency and starting phase\r\n freq_min, freq_max = self.anim_ambient_pulse_freq_range\r\n self._ambient_pulse_state[conn_key] = {\r\n 'phase': random.uniform(0, 2 * math.pi), # Random starting phase\r\n 'freq': random.uniform(freq_min, freq_max), # Random frequency\r\n 'phase_drift_dir': random.choice([-1, 1]), # Drift direction\r\n 'drift_timer': random.uniform(0, 5) # When to change drift\r\n }\r\n return self._ambient_pulse_state[conn_key]\r\n \r\n def _update_ambient_pulses(self, dt):\r\n \"\"\"\r\n Update all ambient pulse phases. Called from update_animations().\r\n Each connection's phase advances at its own rate with subtle drift.\r\n \"\"\"\r\n if not self.anim_ambient_pulse_enabled:\r\n return\r\n \r\n for conn_key, state in self._ambient_pulse_state.items():\r\n # Advance phase based on frequency\r\n state['phase'] += 2 * math.pi * state['freq'] * dt\r\n \r\n # Keep phase in reasonable range\r\n if state['phase'] > 100 * math.pi:\r\n state['phase'] -= 100 * math.pi\r\n \r\n # Occasionally change drift direction for organic feel\r\n state['drift_timer'] -= dt\r\n if state['drift_timer'] <= 0:\r\n state['phase_drift_dir'] = random.choice([-1, 1])\r\n state['drift_timer'] = random.uniform(3, 8)\r\n \r\n # Apply subtle phase drift\r\n state['phase'] += state['phase_drift_dir'] * self.anim_ambient_pulse_phase_drift * dt\r\n \r\n def _spawn_comm_glow(self, source, target):\r\n \"\"\"\r\n Spawn a new communication glow packet traveling from source to target.\r\n \"\"\"\r\n if not self.anim_comm_glow_enabled:\r\n return\r\n \r\n conn_key = (source, target)\r\n current_time = time.time()\r\n \r\n # Check spawn cooldown (min 0.1 seconds between spawns on same connection)\r\n last_spawn = self._comm_glow_last_spawn.get(conn_key, 0)\r\n if current_time - last_spawn < 0.1:\r\n return\r\n \r\n # Initialize packet list if needed\r\n if conn_key not in self._comm_glow_packets:\r\n self._comm_glow_packets[conn_key] = []\r\n \r\n # Check max packets per connection\r\n if len(self._comm_glow_packets[conn_key]) >= self.anim_comm_glow_max_per_connection:\r\n return\r\n \r\n # Create new packet with random speed (for chaotic, organic movement)\r\n speed_min, speed_max = self.anim_comm_glow_speed_range\r\n duration = random.uniform(speed_min, speed_max)\r\n \r\n self._comm_glow_packets[conn_key].append({\r\n 'progress': 0.0, # 0 = at source, 1 = at target\r\n 'speed': 1.0 / duration, # Progress per second\r\n 'start_time': current_time\r\n })\r\n \r\n self._comm_glow_last_spawn[conn_key] = current_time\r\n\r\n def find_orphan_neurons(self):\r\n \"\"\"Find neurons with no connections in the weights dictionary\"\"\"\r\n orphans = []\r\n \r\n # Define neurons that should be checked even if they are in excluded_neurons\r\n explicitly_allowed = {'can_see_food', 'plant_proximity', 'is_fleeing'}\r\n \r\n for neuron in self.neuron_positions.keys():\r\n # Skip if the neuron is excluded, unless it's in our allowed list\r\n if neuron in self.excluded_neurons and neuron not in explicitly_allowed:\r\n continue\r\n \r\n # Check for any connection (incoming or outgoing)\r\n has_connection = any(src == neuron or dst == neuron \r\n for (src, dst) in self.weights.keys())\r\n \r\n if not has_connection:\r\n orphans.append(neuron)\r\n \r\n return orphans\r\n\r\n \r\n def _update_comm_glows(self, dt):\r\n \"\"\"\r\n Update all communication glow packets. Called from update_animations().\r\n \"\"\"\r\n if not self.anim_comm_glow_enabled:\r\n return\r\n \r\n # Update each connection's glow packets\r\n for conn_key in list(self._comm_glow_packets.keys()):\r\n packets = self._comm_glow_packets[conn_key]\r\n \r\n # Update each packet\r\n surviving_packets = []\r\n for packet in packets:\r\n packet['progress'] += packet['speed'] * dt\r\n \r\n # Keep packet if not yet complete\r\n if packet['progress'] < 1.0:\r\n surviving_packets.append(packet)\r\n \r\n # Update packet list (remove completed ones)\r\n if surviving_packets:\r\n self._comm_glow_packets[conn_key] = surviving_packets\r\n else:\r\n del self._comm_glow_packets[conn_key]\r\n \r\n def _spawn_activity_glows(self, current_time):\r\n \"\"\"\r\n Spawn communication glows based on neuron activity.\r\n Called from update_animations() when in subtle mode.\r\n \"\"\"\r\n if not self.anim_comm_glow_spawn_on_activity:\r\n return\r\n \r\n # Check which neurons are currently active (significant deviation from baseline)\r\n active_neurons = []\r\n for neuron, value in self.state.items():\r\n if isinstance(value, (int, float)) and neuron in self.neuron_positions:\r\n if neuron not in self.excluded_neurons:\r\n # Consider active if significantly away from baseline (50)\r\n if abs(value - 50) > 25:\r\n active_neurons.append(neuron)\r\n \r\n # For active neurons, randomly spawn glows on their connections\r\n for neuron in active_neurons:\r\n # Random chance to spawn (don't spam every frame)\r\n if random.random() > 0.02: # ~2% chance per frame per active neuron\r\n continue\r\n \r\n # Find connections involving this neuron\r\n for (src, dst), weight in self.weights.items():\r\n if src == neuron or dst == neuron:\r\n # Determine glow direction based on weight sign and which end is active\r\n if src == neuron:\r\n self._spawn_comm_glow(src, dst)\r\n else:\r\n self._spawn_comm_glow(dst, src)\r\n \r\n def _draw_comm_glows_for_connection(self, painter, scale, conn_key, start_point, end_point):\r\n \"\"\"\r\n Draw all communication glow packets traveling along a connection.\r\n Each glow is a soft glowing orb that travels from source to target.\r\n \"\"\"\r\n # Check both directions for packets\r\n reverse_key = (conn_key[1], conn_key[0])\r\n \r\n for key, direction in [(conn_key, 1), (reverse_key, -1)]:\r\n if key not in self._comm_glow_packets:\r\n continue\r\n \r\n packets = self._comm_glow_packets[key]\r\n \r\n for packet in packets:\r\n progress = packet['progress']\r\n \r\n # Calculate fade based on position (fade in at start, fade out at end)\r\n if progress < self.anim_comm_glow_fade_in:\r\n # Fade in\r\n alpha_mult = progress / self.anim_comm_glow_fade_in\r\n elif progress > (1.0 - self.anim_comm_glow_fade_out):\r\n # Fade out\r\n alpha_mult = (1.0 - progress) / self.anim_comm_glow_fade_out\r\n else:\r\n alpha_mult = 1.0\r\n \r\n # Clamp alpha multiplier\r\n alpha_mult = max(0.0, min(1.0, alpha_mult))\r\n \r\n # Calculate position along the line\r\n if direction == 1:\r\n # Forward direction\r\n glow_x = start_point.x() + progress * (end_point.x() - start_point.x())\r\n glow_y = start_point.y() + progress * (end_point.y() - start_point.y())\r\n else:\r\n # Reverse direction (packet traveling backward)\r\n glow_x = end_point.x() + progress * (start_point.x() - end_point.x())\r\n glow_y = end_point.y() + progress * (start_point.y() - end_point.y())\r\n \r\n glow_pos = QtCore.QPointF(glow_x, glow_y)\r\n \r\n # Draw the glow with multiple layers for soft appearance\r\n glow_size = self.anim_comm_glow_size * scale\r\n r, g, b = self.anim_comm_glow_colour\r\n \r\n # Outer glow (larger, more transparent)\r\n outer_alpha = int(self.anim_comm_glow_alpha * 0.3 * alpha_mult)\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(r, g, b, outer_alpha)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawEllipse(glow_pos, glow_size * 1.5, glow_size * 1.5)\r\n \r\n # Middle glow\r\n mid_alpha = int(self.anim_comm_glow_alpha * 0.6 * alpha_mult)\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(r, g, b, mid_alpha)))\r\n painter.drawEllipse(glow_pos, glow_size, glow_size)\r\n \r\n # Inner core (brightest)\r\n inner_alpha = int(self.anim_comm_glow_alpha * alpha_mult)\r\n # Slightly whiter core\r\n core_r = min(255, r + 50)\r\n core_g = min(255, g + 50)\r\n core_b = min(255, b + 50)\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(core_r, core_g, core_b, inner_alpha)))\r\n painter.drawEllipse(glow_pos, glow_size * 0.5, glow_size * 0.5)\r\n \r\n # Draw tail (trailing glow particles)\r\n if self.anim_comm_glow_tail_length > 0:\r\n tail_steps = 3\r\n for i in range(1, tail_steps + 1):\r\n tail_progress = progress - (self.anim_comm_glow_tail_length * i / tail_steps)\r\n if tail_progress < 0:\r\n continue\r\n \r\n # Calculate tail position\r\n if direction == 1:\r\n tail_x = start_point.x() + tail_progress * (end_point.x() - start_point.x())\r\n tail_y = start_point.y() + tail_progress * (end_point.y() - start_point.y())\r\n else:\r\n tail_x = end_point.x() + tail_progress * (start_point.x() - end_point.x())\r\n tail_y = end_point.y() + tail_progress * (start_point.y() - end_point.y())\r\n \r\n tail_pos = QtCore.QPointF(tail_x, tail_y)\r\n \r\n # Tail gets smaller and more transparent\r\n tail_size = glow_size * 0.6 * (1.0 - i / (tail_steps + 1))\r\n tail_alpha = int(outer_alpha * (1.0 - i / (tail_steps + 1)))\r\n \r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(r, g, b, tail_alpha)))\r\n painter.drawEllipse(tail_pos, tail_size, tail_size)\r\n \r\n def _spawn_neural_pulse(self, source, target, color=None):\r\n \"\"\"\r\n Spawn a neural activation pulse traveling from source to target.\r\n Used by the Neural style.\r\n \"\"\"\r\n if not self.anim_neural_pulse_enabled:\r\n return\r\n \r\n conn_key = (source, target)\r\n current_time = time.time()\r\n \r\n # Initialize pulse list if needed\r\n if conn_key not in self._neural_pulses:\r\n self._neural_pulses[conn_key] = []\r\n \r\n # Limit concurrent pulses per connection\r\n if len(self._neural_pulses[conn_key]) >= 3:\r\n return\r\n \r\n # Determine pulse color based on weight if not specified\r\n if color is None:\r\n weight = self.weights.get(conn_key, self.weights.get((target, source), 0))\r\n if weight >= 0:\r\n color = self.anim_neural_pulse_colour_pos\r\n else:\r\n color = self.anim_neural_pulse_colour_neg\r\n \r\n self._neural_pulses[conn_key].append({\r\n 'start_time': current_time,\r\n 'color': color\r\n })\r\n \r\n def _update_neural_pulses(self, current_time):\r\n \"\"\"\r\n Update neural activation pulses, removing completed ones.\r\n \"\"\"\r\n if not self.anim_neural_pulse_enabled:\r\n return\r\n \r\n duration = self.anim_neural_pulse_duration\r\n \r\n for conn_key in list(self._neural_pulses.keys()):\r\n pulses = self._neural_pulses[conn_key]\r\n \r\n # Filter out completed pulses\r\n surviving = [p for p in pulses if (current_time - p['start_time']) < duration]\r\n \r\n if surviving:\r\n self._neural_pulses[conn_key] = surviving\r\n else:\r\n del self._neural_pulses[conn_key]\r\n \r\n def _spawn_neural_pulses_from_activity(self, current_time):\r\n \"\"\"\r\n Spawn neural pulses based on neuron activity and weight changes.\r\n \"\"\"\r\n if not self.anim_neural_pulse_enabled:\r\n return\r\n \r\n # Spawn pulses from weight change events\r\n if hasattr(self, 'weight_change_events'):\r\n for neuron, event_time in list(self.weight_change_events.items()):\r\n # Only process recent events (within last 0.1 seconds)\r\n if current_time - event_time > 0.1:\r\n continue\r\n \r\n # Find connections from this neuron\r\n for (src, dst), weight in self.weights.items():\r\n if src == neuron:\r\n self._spawn_neural_pulse(src, dst)\r\n \r\n def _draw_neural_connections(self, painter, scale):\r\n \"\"\"\r\n Draw connections in Neural style with weight-based thickness\r\n and traveling activation pulses.\r\n \"\"\"\r\n if not self.show_links:\r\n return\r\n \r\n current_time = time.time()\r\n duration = self.anim_neural_pulse_duration\r\n \r\n # Pre-calculate scaled positions\r\n scaled_positions = {}\r\n for name, (x, y) in self.neuron_positions.items():\r\n if name not in self.excluded_neurons:\r\n scaled_positions[name] = (x * scale, y * scale)\r\n \r\n # === 1. Draw all static connections (base layer) ===\r\n for (src, dst), weight in self.weights.items():\r\n if src not in scaled_positions or dst not in scaled_positions:\r\n continue\r\n \r\n x1, y1 = scaled_positions[src]\r\n x2, y2 = scaled_positions[dst]\r\n \r\n # Base opacity from toggle fade system\r\n base_opacity = self._link_opacities.get((src, dst), 1.0)\r\n if base_opacity <= 0:\r\n continue\r\n \r\n # Weight-based thickness\r\n if self.anim_neural_weight_thickness:\r\n thickness = max(1.0, abs(weight) * self.anim_neural_weight_thickness_mult)\r\n else:\r\n thickness = self.anim_line_base_width\r\n pen_width = max(1, int(thickness * scale))\r\n \r\n # Color based on weight sign\r\n alpha = int(self.anim_neural_base_alpha * base_opacity)\r\n if weight >= 0:\r\n r, g, b = self.anim_neural_base_colour_pos\r\n else:\r\n r, g, b = self.anim_neural_base_colour_neg\r\n \r\n color = QtGui.QColor(r, g, b, alpha)\r\n pen = QtGui.QPen(color, pen_width, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap)\r\n painter.setPen(pen)\r\n painter.drawLine(QtCore.QLineF(x1, y1, x2, y2))\r\n \r\n # === 2. Draw activation pulses on top (traveling lights) ===\r\n for (src, dst), pulses in self._neural_pulses.items():\r\n if src not in scaled_positions or dst not in scaled_positions:\r\n continue\r\n \r\n x1, y1 = scaled_positions[src]\r\n x2, y2 = scaled_positions[dst]\r\n \r\n for pulse in pulses:\r\n elapsed = current_time - pulse['start_time']\r\n progress = elapsed / duration\r\n \r\n if progress > 1.0:\r\n continue\r\n \r\n # Sinusoidal fade (glow in → peak → fade out)\r\n opacity = math.sin(progress * math.pi)\r\n \r\n # Get pulse color\r\n r, g, b = pulse['color']\r\n final_alpha = int(255 * opacity * 0.95)\r\n \r\n pulse_color = QtGui.QColor(r, g, b, final_alpha)\r\n \r\n # Thick glowing pulse line\r\n pulse_width = max(1, int(self.anim_neural_pulse_width * scale))\r\n pen = QtGui.QPen(pulse_color, pulse_width, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap)\r\n painter.setPen(pen)\r\n \r\n # Traveling light effect - pulse moves along connection\r\n segment_progress = progress * 1.35\r\n if segment_progress <= 1.0:\r\n # First phase: light travels from source toward destination\r\n t = min(1.0, segment_progress)\r\n px = x1 + t * (x2 - x1)\r\n py = y1 + t * (y2 - y1)\r\n painter.drawLine(QtCore.QLineF(x1, y1, px, py))\r\n else:\r\n # Second phase: light \"drains\" toward destination\r\n t = min(1.0, segment_progress - 0.35)\r\n px = x1 + t * (x2 - x1)\r\n py = y1 + t * (y2 - y1)\r\n painter.drawLine(QtCore.QLineF(px, py, x2, y2))\r\n\r\n\r\n # =========================================================================\r\n # Worker thread signal handlers\r\n # =========================================================================\r\n \r\n def _on_neurogenesis_complete(self, result: dict):\r\n \"\"\"Handle neurogenesis result from worker thread (called on main thread).\r\n \r\n The worker thread performs preliminary checks and signals whether creation\r\n should proceed. Actual neuron creation happens here on the main thread\r\n via the EnhancedNeurogenesis system.\r\n \"\"\"\r\n self._pending_neurogenesis_check = False\r\n \r\n # Check if worker signaled that we should create a neuron\r\n if not result.get('should_create', False):\r\n return\r\n \r\n # Get the context from worker result\r\n neuron_type = result.get('neuron_type')\r\n trigger_value = result.get('trigger_value', 0)\r\n state_context = result.get('state_context', {})\r\n is_emergency = result.get('is_emergency', False)\r\n \r\n if not neuron_type:\r\n return\r\n \r\n # print(f\"🧵 Worker signaled neurogenesis: type={neuron_type}, emergency={is_emergency}\")\r\n \r\n # Build environment from state context\r\n environment = {\r\n 'food_count': state_context.get('food_count', 0),\r\n 'poop_count': state_context.get('poop_count', 0),\r\n 'is_sick': state_context.get('is_sick', False),\r\n 'is_eating': state_context.get('is_eating', False),\r\n 'has_rock': state_context.get('carrying_rock', False),\r\n 'new_object_encountered': state_context.get('new_object_encountered', False),\r\n 'recent_positive_outcome': state_context.get('recent_positive_outcome', False)\r\n }\r\n \r\n # Use the EnhancedNeurogenesis system to create the neuron properly\r\n try:\r\n # Capture experience context\r\n context = self.enhanced_neurogenesis.capture_experience_context(\r\n trigger_type=neuron_type,\r\n brain_state=state_context,\r\n recent_actions=state_context.get('recent_actions', []),\r\n environment=environment\r\n )\r\n \r\n # For emergency creation, skip the normal checks\r\n if is_emergency:\r\n neuron_name = self.enhanced_neurogenesis.create_functional_neuron(context, is_emergency=True)\r\n else:\r\n # Normal path: check if we should create based on pattern recurrence\r\n if self.enhanced_neurogenesis.should_create_neuron(context):\r\n neuron_name = self.enhanced_neurogenesis.create_functional_neuron(context)\r\n else:\r\n # Experience captured but not enough pattern recurrence yet\r\n return\r\n \r\n if neuron_name:\r\n print(f\"✨ Main thread: Created neuron {neuron_name}\")\r\n \r\n # Emit signal to notify listeners (e.g., NetworkTab) of new neuron\r\n self.neuronCreated.emit(neuron_name)\r\n \r\n # Handle pruning if needed\r\n if self.pruning_enabled:\r\n current_count = len(self.neuron_positions) - len(self.excluded_neurons)\r\n max_neurons = self.neurogenesis_config.get('max_neurons', 32)\r\n if current_count > max_neurons * 0.85:\r\n self.enhanced_neurogenesis.intelligent_pruning()\r\n \r\n self.update()\r\n \r\n except Exception as e:\r\n print(f\"⚠️ Error during neuron creation on main thread: {e}\")\r\n import traceback\r\n traceback.print_exc()\r\n \r\n def _on_hebbian_complete(self, result: dict):\r\n \"\"\"Handle Hebbian learning result from worker thread (called on main thread).\"\"\"\r\n self._pending_hebbian_learning = False\r\n \r\n # Always reset the timer so countdown restarts properly\r\n self.last_hebbian_time = time.time()\r\n \r\n updated_pairs = result.get('updated_pairs', [])\r\n weight_updates = result.get('weight_updates', {})\r\n \r\n if not weight_updates:\r\n self.update()\r\n return\r\n \r\n # [NEW] Pre-generate distinct colors for this batch to ensure uniqueness\r\n import random\r\n from PyQt5.QtGui import QColor\r\n \r\n new_connections_created = [] # Track newly formed connections\r\n \r\n # Apply the weight updates (main thread only)\r\n for i, (pair_str, update_data) in enumerate(weight_updates.items()):\r\n # Convert string key back to tuple if needed\r\n if isinstance(pair_str, str):\r\n pair = tuple(pair_str.split(','))\r\n else:\r\n pair = pair_str\r\n \r\n # Check if this is a new connection being created by Hebbian learning\r\n is_new_connection = update_data.get('is_new_connection', False)\r\n \r\n if is_new_connection and pair not in self.weights:\r\n # Create the new connection - Hebbian learning forming new pathways!\r\n self.weights[pair] = 0.0 # Initialize with zero weight\r\n new_connections_created.append(pair)\r\n \r\n if pair in self.weights:\r\n old_weight = update_data['old_weight']\r\n new_weight = update_data['new_weight']\r\n self.weights[pair] = new_weight\r\n \r\n # [NEW] Generate unique vibrant color using HSL (Hue, Saturation, Lightness)\r\n # Offset hue by index to ensure pairs get different colors\r\n hue = (random.random() + (i * 0.618033988749895)) % 1.0 # Golden ratio spacing\r\n unique_color = QColor.fromHslF(hue, 0.95, 0.6).toRgb()\r\n color_tuple = (unique_color.red(), unique_color.green(), unique_color.blue())\r\n \r\n # [NEW] Randomize speed (duration) between 0.8s (fast) and 2.0s (slow)\r\n unique_duration = random.uniform(0.8, 2.0)\r\n \r\n # Add animation for visual feedback with custom parameters\r\n n1, n2 = pair\r\n self.add_weight_animation(\r\n n1, n2, old_weight, new_weight, \r\n custom_color=color_tuple, \r\n custom_duration=unique_duration\r\n )\r\n \r\n # Update tracking (convert lists to tuples for consistency)\r\n self.recently_updated_neuron_pairs = [tuple(p) if isinstance(p, list) else p for p in updated_pairs]\r\n self.last_hebbian_time = time.time()\r\n \r\n # Console output\r\n if updated_pairs:\r\n COLORS = [\"\\033[96m\", \"\\033[93m\", \"\\033[95m\", \"\\033[92m\", \"\\033[94m\"]\r\n RESET = \"\\033[0m\"\r\n colored = []\r\n for i, pair in enumerate(updated_pairs):\r\n if isinstance(pair, (list, tuple)) and len(pair) == 2:\r\n a, b = pair\r\n color = COLORS[i % len(COLORS)]\r\n # Mark new connections with a ✨\r\n marker = \" ✨\" if pair in new_connections_created else \"\"\r\n colored.append(f\"{color}{a} ↔ {b}{marker}{RESET}\")\r\n if colored:\r\n print(\" Hebbian learning chosen pairs: \" + \" \".join(colored))\r\n \r\n # Log new connections formed\r\n if new_connections_created:\r\n print(f\" 🔗 New connections formed: {len(new_connections_created)}\")\r\n # Sync connections list from weights after creating new connections\r\n self.sync_connections_from_weights()\r\n \r\n self.update()\r\n \r\n\r\n def _on_state_update_complete(self, result: dict):\r\n \"\"\"Handle state-update results from the worker thread (main thread).\"\"\"\r\n self._pending_state_update = False\r\n\r\n if result.get('health_check'):\r\n return\r\n\r\n processed_state = result.get('processed_state', {})\r\n \r\n # [CRITICAL FIX] Filter out INPUT SENSORS so the worker cannot overwrite them.\r\n # The worker operates on slightly old data. For sensors, the Main Thread \r\n # (Environment) is the single source of truth.\r\n INPUT_SENSORS = {\r\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\",\r\n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\",\r\n \"plant_proximity\"\r\n }\r\n \r\n # Remove sensors from the update packet before applying it\r\n for sensor in INPUT_SENSORS:\r\n if sensor in processed_state:\r\n del processed_state[sensor]\r\n\r\n # Now it is safe to update. Only hidden/output neurons will be affected.\r\n self.state.update(processed_state)\r\n\r\n # Update communication events for glow effects\r\n comm_events = result.get('communication_events', {})\r\n self.communication_events.update(comm_events)\r\n\r\n # Optional decay pre-application (Tamagotchi logic)\r\n decay_updates = result.get('decay_updates', {})\r\n if decay_updates and hasattr(self, 'tamagotchi_logic') and self.tamagotchi_logic:\r\n if hasattr(self.tamagotchi_logic, 'brain_hooks'):\r\n for neuron, decayed_val in decay_updates.items():\r\n if neuron in self.state:\r\n # [CRITICAL FIX] Don't let decay logic touch sensors\r\n if neuron not in INPUT_SENSORS:\r\n self.state[neuron] = decayed_val\r\n\r\n # [NEW] Run Enhanced Neurogenesis logic (Stress reduction, etc.)\r\n if hasattr(self, 'enhanced_neurogenesis'):\r\n self.enhanced_neurogenesis.update_neuron_activations(self.state)\r\n\r\n self.update() # Repaint\r\n\r\n # Queue next update if any\r\n if self.state_update_queue:\r\n next_data = self.state_update_queue.pop(0)\r\n if hasattr(self, 'brain_worker') and self.brain_worker:\r\n self.brain_worker.queue_state_update(next_data)\r\n self._pending_state_update = True\r\n \r\n def _on_worker_error(self, error_msg: str):\r\n \"\"\"Handle errors from the worker thread.\"\"\"\r\n print(f\"⚠️ BrainWorker error: {error_msg}\")\r\n \r\n def _update_worker_cache(self):\r\n \"\"\"Update the worker's cached data for thread-safe access.\"\"\"\r\n if hasattr(self, 'brain_worker') and self.brain_worker:\r\n # Get connector neurons for Hebbian learning exclusion\r\n connector_neurons = {name for name, fn in self.enhanced_neurogenesis.functional_neurons.items()\r\n if fn.neuron_type == 'connector'}\r\n \r\n # Get new neurons for learning rate boost\r\n new_neurons = set()\r\n if hasattr(self, 'new_neurons'):\r\n new_neurons = set(self.new_neurons.keys()) if isinstance(self.new_neurons, dict) else set(self.new_neurons)\r\n \r\n self.brain_worker.update_cache(\r\n self.state,\r\n self.weights,\r\n self.neuron_positions,\r\n self.config,\r\n excluded_neurons=self.excluded_neurons,\r\n connector_neurons=connector_neurons, # Pass connector neurons separately\r\n learning_rate=getattr(self, 'learning_rate', 0.1),\r\n new_neurons=new_neurons\r\n )\r\n \r\n def stop_worker(self):\r\n \"\"\"Stop the worker thread gracefully (call on application exit).\"\"\"\r\n if hasattr(self, 'brain_worker') and self.brain_worker:\r\n self.brain_worker.stop()\r\n self.brain_worker.wait(2000) # Wait up to 2 seconds\r\n print(\"🧵 BrainWorker thread stopped\")\r\n \r\n # =========================================================================\r\n # End worker thread signal handlers\r\n # =========================================================================\r\n\r\n \r\n def is_neuron_revealed(self, name):\r\n \"\"\"Return True if the neuron has finished its reveal animation.\r\n Only checks revealed tracking during tutorial mode.\"\"\"\r\n # In normal gameplay (not tutorial), all neurons are considered revealed\r\n if not self.is_tutorial_mode:\r\n return True\r\n \r\n # During tutorial, check if neuron has completed its animation\r\n if name not in self.neuron_reveal_animations:\r\n return name in self.visible_neurons # never animated = already visible\r\n anim = self.neuron_reveal_animations[name]\r\n elapsed = time.time() - anim['start_time']\r\n return elapsed >= 0.4 # same duration used in draw_neurons\r\n \r\n\r\n def _advance_link_fades(self):\r\n \"\"\"Called every 16 ms while any line is still moving.\"\"\"\r\n dt = 0.016\r\n still_animating = False\r\n now = time.time()\r\n\r\n for key, target in list(self._link_targets.items()):\r\n # Check if this link's delay has passed\r\n start_time = self._link_start_times.get(key, 0)\r\n if now < start_time:\r\n still_animating = True\r\n continue\r\n \r\n current = self._link_opacities.get(key, 0.0)\r\n # Use per-link speed for individual animation timing\r\n speed = self._link_fade_speeds.get(key, 3.0)\r\n step = speed * dt\r\n \r\n if abs(target - current) <= step: # arrived\r\n self._link_opacities[key] = target\r\n del self._link_targets[key] # stop tracking this one\r\n if key in self._link_start_times:\r\n del self._link_start_times[key]\r\n if key in self._link_fade_speeds:\r\n del self._link_fade_speeds[key]\r\n else: # move one step\r\n self._link_opacities[key] = current + step * (1 if target > current else -1)\r\n still_animating = True\r\n\r\n self.update() # repaint with new alphas\r\n\r\n if not still_animating: # all lines finished\r\n self._link_fade_timer.stop()\r\n\r\n def update_animations(self):\r\n \"\"\"Update all animation states with smarter dirty-checking.\"\"\"\r\n \r\n current_lang = Localisation.instance().current_language\r\n if getattr(self, '_last_lang', None) != current_lang:\r\n self._last_lang = current_lang\r\n self.mark_render_dirty()\r\n self.update()\r\n\r\n if self.is_paused:\r\n return\r\n\r\n current_time = time.time()\r\n \r\n # Performance tracking (keep if using task manager)\r\n if _PERF_TRACKING_AVAILABLE:\r\n _anim_start = time.perf_counter()\r\n perf_tracker.increment(\"animation_frames\")\r\n \r\n # Frame rate limiting - skip if called too soon\r\n if hasattr(self, '_last_animation_update'):\r\n elapsed = current_time - self._last_animation_update\r\n if elapsed < 0.04: # 25fps cap (40ms) - reduced from 30fps\r\n return\r\n self._last_animation_update = current_time\r\n \r\n # Calculate dt\r\n if not hasattr(self, '_last_animation_time'):\r\n self._last_animation_time = current_time\r\n dt = min(current_time - self._last_animation_time, 0.1)\r\n self._last_animation_time = current_time\r\n\r\n # SMARTER dirty tracking\r\n needs_repaint = False\r\n\r\n # 1. Neurogenesis pulse - only repaint if active\r\n if self.neurogenesis_highlight['neuron']:\r\n elapsed = current_time - self.neurogenesis_highlight['start_time']\r\n if elapsed < self.neurogenesis_highlight['duration']:\r\n self.neurogenesis_highlight['pulse_phase'] = elapsed * 15\r\n needs_repaint = True\r\n else:\r\n self.neurogenesis_highlight['neuron'] = None\r\n needs_repaint = True # One final repaint to clear\r\n\r\n # 2. Neuron reveal animations - only if we have any\r\n if self.neuron_reveal_animations:\r\n completed_reveals = []\r\n for neuron_name, anim_data in self.neuron_reveal_animations.items():\r\n elapsed = current_time - anim_data['start_time']\r\n if elapsed >= 0.4:\r\n anim_data['progress'] = 1.0\r\n completed_reveals.append(neuron_name)\r\n else:\r\n anim_data['progress'] = 1 - (1 - elapsed / 0.4) ** 3\r\n\r\n for neuron_name in completed_reveals:\r\n del self.neuron_reveal_animations[neuron_name]\r\n \r\n needs_repaint = True\r\n \r\n # Enable links after last reveal\r\n if (len(self.visible_neurons) == len(self.original_neurons) and\r\n not self.neuron_reveal_animations and not self.show_links):\r\n self._enable_links_after_reveal()\r\n\r\n # 3. Weight animations - check if any are active\r\n if self.weight_animations:\r\n old_count = len(self.weight_animations)\r\n self.weight_animations = [\r\n anim for anim in self.weight_animations\r\n if current_time - anim['start_time'] < anim['duration']\r\n ]\r\n if self.weight_animations or old_count > 0:\r\n needs_repaint = True\r\n \r\n # 4. VIBRANT: Ambient pulses - only update if enabled AND we have connections\r\n if self.anim_ambient_pulse_enabled and self._ambient_pulse_state:\r\n self._update_ambient_pulses(dt)\r\n needs_repaint = True\r\n \r\n # 5. SUBTLE: Communication glows - only if packets exist\r\n if self.anim_comm_glow_enabled:\r\n had_packets = bool(self._comm_glow_packets)\r\n self._update_comm_glows(dt)\r\n self._spawn_activity_glows(current_time)\r\n # Only repaint if we had or now have packets\r\n if had_packets or self._comm_glow_packets:\r\n needs_repaint = True\r\n \r\n # 6. NEURAL: Activation pulses - only if pulses exist \r\n if self.anim_neural_pulse_enabled:\r\n had_pulses = bool(self._neural_pulses)\r\n self._update_neural_pulses(current_time)\r\n self._spawn_neural_pulses_from_activity(current_time)\r\n if had_pulses or self._neural_pulses:\r\n needs_repaint = True\r\n \r\n # Only trigger repaint when needed\r\n if needs_repaint:\r\n self.update()\r\n \r\n # Performance tracking end\r\n if _PERF_TRACKING_AVAILABLE:\r\n _anim_elapsed = (time.perf_counter() - _anim_start) * 1000\r\n perf_tracker.record(\"update_animations\", _anim_elapsed)\r\n\r\n def _get_cached_font(self, size, bold=False):\r\n \"\"\"Return cached QFont to avoid recreation every paint.\"\"\"\r\n key = (size, bold)\r\n if key not in self._cached_fonts:\r\n font = QtGui.QFont(\"Arial\", size)\r\n if bold:\r\n font.setBold(True)\r\n self._cached_fonts[key] = font\r\n return self._cached_fonts[key]\r\n \r\n def _get_cached_pen(self, color_tuple, width=1):\r\n \"\"\"Return cached QPen to avoid recreation every paint.\"\"\"\r\n key = (*color_tuple, width)\r\n if key not in self._cached_pens:\r\n color = QtGui.QColor(*color_tuple[:3])\r\n if len(color_tuple) > 3:\r\n color.setAlpha(color_tuple[3])\r\n self._cached_pens[key] = QtGui.QPen(color, width)\r\n return self._cached_pens[key]\r\n\r\n def reveal_neuron(self, neuron_name):\r\n \"\"\"Reveal a neuron with an expand animation – forces links OFF during reveal.\"\"\"\r\n import time\r\n \r\n if neuron_name not in self.original_neurons:\r\n return\r\n if neuron_name in self.visible_neurons:\r\n return\r\n if neuron_name not in self.neuron_positions:\r\n print(f\"❌ ERROR: Neuron {neuron_name} has no position defined!\")\r\n return\r\n\r\n # First reveal → force links OFF\r\n if not self.visible_neurons:\r\n self.show_links = False\r\n if hasattr(self, 'parent') and hasattr(self.parent(), 'network_tab'):\r\n nt = self.parent().network_tab\r\n nt.checkbox_links.setChecked(False)\r\n nt.checkbox_links.setEnabled(False)\r\n\r\n # Staggered start\r\n stagger = 0.4\r\n delay = len(self.visible_neurons) * stagger\r\n\r\n self.visible_neurons.add(neuron_name)\r\n\r\n # Track this neuron as revealed for count display (tutorial only)\r\n if self.is_tutorial_mode:\r\n self.revealed_neurons.add(neuron_name)\r\n self._reveal_connections_for_neuron(neuron_name)\r\n\r\n # Trigger immediate metrics update\r\n self._update_network_metrics()\r\n\r\n self.neuron_reveal_animations[neuron_name] = {\r\n 'start_time': time.time() + delay,\r\n 'progress': 0.0\r\n }\r\n\r\n pos = self.neuron_positions[neuron_name]\r\n self.mark_render_dirty()\r\n\r\n def _enable_links_after_reveal(self):\r\n \"\"\"Re-enable checkbox, tick it, and kick off the existing link-fade engine.\"\"\"\r\n self.show_links = True\r\n \r\n # Populate link targets for all weights\r\n for key in self.weights.keys():\r\n self._link_targets[key] = 1.0\r\n if key not in self._link_opacities:\r\n self._link_opacities[key] = 0.0\r\n \r\n # Set fade speed\r\n self._link_fade_speed = 3.0\r\n \r\n # Re-enable and check the checkbox\r\n if hasattr(self, 'parent') and hasattr(self.parent(), 'network_tab'):\r\n nt = self.parent().network_tab\r\n nt.checkbox_links.setEnabled(True)\r\n nt.checkbox_links.setChecked(True)\r\n\r\n # Start the fade timer\r\n if not self._link_fade_timer.isActive():\r\n self._link_fade_timer.start()\r\n \r\n self.mark_render_dirty()\r\n \r\n def reveal_all_core_neurons(self):\r\n \"\"\"Make all core neurons visible immediately (for loaded games)\"\"\"\r\n for neuron_name in self.original_neurons:\r\n self.visible_neurons.add(neuron_name)\r\n # For loaded games, remove tracking attributes immediately\r\n if hasattr(self, 'revealed_neurons'):\r\n delattr(self, 'revealed_neurons')\r\n if hasattr(self, 'revealed_connections'):\r\n delattr(self, 'revealed_connections')\r\n # Ensure tutorial mode is disabled for loaded games\r\n self.is_tutorial_mode = False\r\n \r\n # Mark render dirty and trigger update\r\n self.mark_render_dirty()\r\n self.update()\r\n \r\n def _reveal_connections_for_neuron(self, neuron_name):\r\n \"\"\"Reveal connections between this neuron and other revealed neurons\r\n NOTE: This should only be called during tutorial mode\"\"\"\r\n if not self.is_tutorial_mode:\r\n return\r\n if not hasattr(self, 'weights'):\r\n return\r\n if not hasattr(self, 'revealed_neurons') or not hasattr(self, 'revealed_connections'):\r\n return\r\n \r\n # Check all weights to find connections involving this neuron\r\n for (source, target), weight in self.weights.items():\r\n # If both ends of the connection are revealed, track it\r\n if source in self.revealed_neurons and target in self.revealed_neurons:\r\n edge_key = f\"{source}->{target}\"\r\n if edge_key not in self.revealed_connections:\r\n self.revealed_connections.add(edge_key)\r\n \r\n def _update_network_metrics(self):\r\n \"\"\"Update the network tab metrics display\"\"\"\r\n try:\r\n # Try to get the parent window (SquidBrainWindow)\r\n parent = self.parent()\r\n if parent and hasattr(parent, 'network_tab'):\r\n parent.network_tab.update_metrics_display()\r\n except Exception as e:\r\n pass # Silently fail if we can't update - not critical\r\n \r\n def finish_reveal_animation(self):\r\n \"\"\"Called when the reveal animation completes - cleanup tracking attributes\"\"\"\r\n # Remove reveal tracking so normal counting resumes\r\n if hasattr(self, 'revealed_neurons'):\r\n delattr(self, 'revealed_neurons')\r\n if hasattr(self, 'revealed_connections'):\r\n delattr(self, 'revealed_connections')\r\n\r\n # Exit tutorial mode\r\n self.is_tutorial_mode = False\r\n\r\n # AUTO-ENABLE links now that all neurons are revealed\r\n self.show_links = True\r\n if hasattr(self, 'parent') and hasattr(self.parent(), 'network_tab'):\r\n nt = self.parent().network_tab\r\n nt.checkbox_links.setEnabled(True)\r\n nt.checkbox_links.setChecked(True) # tick the box\r\n\r\n # Fade-in the links smoothly\r\n if self.show_links and self._link_targets:\r\n self._auto_fade_links_pending = True\r\n if not self._link_fade_timer.isActive():\r\n self._advance_link_fades()\r\n\r\n def add_weight_animation(self, neuron1, neuron2, old_weight, new_weight, \r\n custom_color=None, custom_duration=3.0):\r\n \"\"\"Add animation for a weight change with organic staggering through connectors\"\"\"\r\n current_time = time.time()\r\n \r\n # Determine color based on weight change direction if not custom\r\n if custom_color:\r\n color = custom_color\r\n else:\r\n color = (0, 255, 0) if new_weight > old_weight else (255, 0, 0)\r\n \r\n # Check if there's a connector neuron in the path\r\n # A connector is in the path if:\r\n # 1. It has connections to both neuron1 and neuron2\r\n # 2. It's a connector type neuron\r\n connector_in_path = None\r\n possible_connectors = []\r\n \r\n # Find all connector neurons that connect to both\r\n for (src, dst), weight in self.weights.items():\r\n # Check if this is a connector neuron connection\r\n is_connector = (src.startswith('connector_') or \r\n (src in self.neuron_shapes and self.neuron_shapes[src] == 'hexagon'))\r\n \r\n if is_connector:\r\n # Check if connector connects to both neurons\r\n conn_to_n1 = (src == neuron1 or dst == neuron1)\r\n conn_to_n2 = (src == neuron2 or dst == neuron2)\r\n \r\n if conn_to_n1 and conn_to_n2:\r\n # This connector is between our two neurons\r\n connector_in_path = src if src.startswith('connector_') else dst\r\n break\r\n \r\n # Create staggered animations for organic feel\r\n if connector_in_path:\r\n # Two-segment animation: neuron1 → connector → neuron2\r\n # Add random delay at connector for organic relay effect\r\n \r\n # First segment: neuron1 → connector\r\n self.weight_animations.append({\r\n 'pair': (neuron1, connector_in_path),\r\n 'start_time': current_time,\r\n 'duration': custom_duration * 0.45, # Slightly shorter for first half\r\n 'start_weight': old_weight,\r\n 'end_weight': new_weight,\r\n 'neuron1': neuron1,\r\n 'neuron2': connector_in_path,\r\n 'color': color,\r\n 'is_segment': True,\r\n 'final_target': neuron2\r\n })\r\n \r\n # Second segment: connector → neuron2 (with stagger delay)\r\n stagger_delay = random.uniform(0.15, 0.25) # 150-250ms pause at connector\r\n self.weight_animations.append({\r\n 'pair': (connector_in_path, neuron2),\r\n 'start_time': current_time + stagger_delay,\r\n 'duration': custom_duration * 0.45,\r\n 'start_weight': old_weight,\r\n 'end_weight': new_weight,\r\n 'neuron1': connector_in_path,\r\n 'neuron2': neuron2,\r\n 'color': color,\r\n 'is_segment': True,\r\n 'final_target': neuron2,\r\n 'stagger_delay': stagger_delay\r\n })\r\n \r\n print(f\"🎨 Staggered animation: {neuron1} → {connector_in_path} → {neuron2} \"\r\n f\"(delay: {stagger_delay:.2f}s)\")\r\n else:\r\n # Direct connection - single animation as before\r\n self.weight_animations.append({\r\n 'pair': (neuron1, neuron2),\r\n 'start_time': current_time,\r\n 'duration': custom_duration,\r\n 'start_weight': old_weight,\r\n 'end_weight': new_weight,\r\n 'neuron1': neuron1,\r\n 'neuron2': neuron2,\r\n 'color': color,\r\n 'is_segment': False\r\n })\r\n \r\n # Record communication events\r\n self.weight_change_events[neuron1] = current_time\r\n self.weight_change_events[neuron2] = current_time\r\n \r\n # Add to recently updated pairs (store original pair)\r\n if (neuron1, neuron2) not in self.recently_updated_neuron_pairs and \\\r\n (neuron2, neuron1) not in self.recently_updated_neuron_pairs:\r\n self.recently_updated_neuron_pairs.append((neuron1, neuron2))\r\n \r\n # Mark render dirty immediately\r\n self.mark_render_dirty()\r\n self.update()\r\n\r\n def is_neurogenesis_neuron(self, neuron_name: str) -> bool:\r\n \"\"\"\r\n Check if a neuron was created through neurogenesis (and can be dragged).\r\n TO BE REMOVED IN FUTURE VERSION - depreceted\r\n \"\"\"\r\n \r\n if not neuron_name:\r\n return False\r\n \r\n # Core neurons that should NOT be draggable\r\n if neuron_name in self.original_neurons:\r\n return True # HACK make it True anyway\r\n \r\n # ANY neuron not in original_neurons is draggable (including circular ones)\r\n return True\r\n\r\n def _periodic_neurogenesis_check(self):\r\n \"\"\"Periodic check for neurogenesis triggers and orphans.\"\"\"\r\n if not hasattr(self, 'check_neurogenesis_triggers'):\r\n return\r\n \r\n # Skip if a check is already pending\r\n if self._pending_neurogenesis_check:\r\n return\r\n \r\n # Prioritise Orphan Rescue ---\r\n if hasattr(self, 'enhanced_neurogenesis') and hasattr(self.enhanced_neurogenesis, 'rescue_orphan'):\r\n orphans = self.find_orphan_neurons()\r\n if orphans:\r\n orphan = orphans[0]\r\n print(f\"🚑 Orphan detected: {orphan}. Creating connector neuron...\")\r\n \r\n # ADD ERROR HANDLING\r\n try:\r\n self.enhanced_neurogenesis.rescue_orphan(orphan)\r\n self.update()\r\n return # Skip normal neurogenesis this tick\r\n except Exception as e:\r\n print(f\"⚠️ Failed to rescue orphan {orphan}: {e}\")\r\n import traceback\r\n traceback.print_exc()\r\n \r\n # Build state with context and check neurogenesis triggers\r\n state_with_context = self.state.copy()\r\n self._pending_neurogenesis_check = True\r\n \r\n # Queue to worker thread if available\r\n if self._use_threaded_processing and hasattr(self, 'brain_worker') and self.brain_worker.isRunning():\r\n self.brain_worker.queue_neurogenesis_check(state_with_context)\r\n else:\r\n # Fallback: synchronous check\r\n try:\r\n result = self.check_neurogenesis_triggers(state_with_context)\r\n if result:\r\n self._on_neurogenesis_complete({'should_create': True, **result})\r\n except Exception as e:\r\n print(f\"⚠️ Error in neurogenesis check: {e}\")\r\n import traceback\r\n traceback.print_exc()\r\n finally:\r\n self._pending_neurogenesis_check = False\r\n\r\n def toggle_pruning(self, enabled):\r\n \"\"\"Enable or disable the pruning mechanisms for neurogenesis\"\"\"\r\n previous = self.pruning_enabled\r\n self.pruning_enabled = enabled\r\n\r\n if previous != enabled:\r\n print(f\"\\x1b[{'42' if enabled else '41'}mPruning {'enabled' if enabled else 'disabled'}\\x1b[0m - Neurogenesis {'constrained' if enabled else 'unconstrained'}\")\r\n\r\n if not enabled:\r\n print(\"\\x1b[31mWARNING: Disabling pruning may lead to network instability\\x1b[0m\")\r\n\r\n return self.pruning_enabled\r\n \r\n def get_stress_neuron_count(self):\r\n \"\"\"Counts the number of neurons that start with the name 'stress'.\"\"\"\r\n return len([name for name in self.neuron_positions if name.startswith('stress')])\r\n\r\n def stop_hebbian_learning(self):\r\n \"\"\"Stop Hebbian learning immediately\"\"\"\r\n self.learning_active = False\r\n self.hebbian_countdown_seconds = 0\r\n print(\"++ Hebbian learning stopped\")\r\n\r\n def start_hebbian_learning(self, duration_seconds=30):\r\n \"\"\"Start Hebbian learning with a specified duration\"\"\"\r\n self.hebbian_countdown_seconds = duration_seconds\r\n self.learning_active = True\r\n self.is_paused = False\r\n print(f\"++ Hebbian learning started for {duration_seconds} seconds\")\r\n\r\n def _update_communication_events(self):\r\n \"\"\"Clean up old communication events that have expired\"\"\"\r\n current_time = time.time()\r\n # Remove events older than the highlight duration\r\n expired_neurons = [\r\n neuron for neuron, event_time in self.communication_events.items()\r\n if current_time - event_time > self.communication_highlight_duration\r\n ]\r\n for neuron in expired_neurons:\r\n del self.communication_events[neuron]\r\n\r\n def get_neuron_value(self, value):\r\n \"\"\"\r\n Convert a neuron value to a numerical format for Hebbian learning.\r\n\r\n Args:\r\n value: The value of the neuron, which can be int, float, bool, or str.\r\n\r\n Returns:\r\n float: The numerical value of the neuron.\r\n \"\"\"\r\n if isinstance(value, (int, float)):\r\n return float(value)\r\n elif isinstance(value, bool):\r\n return 100.0 if value else 0.0\r\n elif isinstance(value, str):\r\n # For string values (like 'direction'), return a default value\r\n return 75.0\r\n else:\r\n return 0.0\r\n \r\n def is_new_neuron(self, neuron_name, newness_duration_sec=300): # 300s = 5 minutes\r\n \"\"\"Check if a neuron was created within the newness duration.\"\"\"\r\n # Check if it's in the primary neurogenesis data\r\n if neuron_name in self.neurogenesis_data.get('new_neurons', []):\r\n details = self.neurogenesis_data.get('new_neurons_details', {}).get(neuron_name)\r\n if details:\r\n created_at = details.get('created_at')\r\n if created_at and (time.time() - created_at) < newness_duration_sec:\r\n return True # It's new based on details\r\n else:\r\n # If it's in the list and < 5 mins, assume new.\r\n pass\r\n return False\r\n\r\n\r\n def update_connection(self, neuron1, neuron2, value1, value2):\r\n \"\"\"Update connection weight and trigger animations, with connector limits.\"\"\"\r\n import time\r\n \r\n current_time = time.time()\r\n pair = (neuron1, neuron2)\r\n reverse_pair = (neuron2, neuron1)\r\n\r\n # Check if connection exists\r\n exists = pair in self.weights or reverse_pair in self.weights\r\n use_pair = pair if pair in self.weights else reverse_pair\r\n\r\n # --- CONNECTOR LIMIT CHECK ---\r\n # If this is a NEW connection, check if either party is a maxed-out connector\r\n if not exists:\r\n # Check Neuron 1\r\n if self.is_connector_neuron(neuron1):\r\n if self.get_neuron_degree(neuron1) >= 3:\r\n # print(f\"🚫 Blocked new connection to connector {neuron1} (Max 3 reached)\")\r\n return\r\n \r\n # Check Neuron 2\r\n if self.is_connector_neuron(neuron2):\r\n if self.get_neuron_degree(neuron2) >= 3:\r\n # print(f\"🚫 Blocked new connection to connector {neuron2} (Max 3 reached)\")\r\n return\r\n\r\n # Initialize if new\r\n if not exists:\r\n if neuron1 in self.neuron_positions and neuron2 in self.neuron_positions:\r\n self.weights[pair] = 0.0\r\n use_pair = pair\r\n print(f\" 🆕 Created new connection: {neuron1} ↔ {neuron2}\")\r\n else:\r\n return\r\n\r\n prev_weight = self.weights[use_pair]\r\n\r\n # Learning Rate Calculation\r\n base_lr = self.learning_rate\r\n newness_boost = 2.0\r\n effective_lr = base_lr\r\n\r\n is_n1_new = self.is_new_neuron(neuron1)\r\n is_n2_new = self.is_new_neuron(neuron2)\r\n\r\n if is_n1_new or is_n2_new:\r\n effective_lr = base_lr * newness_boost\r\n\r\n # Calculate weight change (basic Hebbian)\r\n weight_change = effective_lr * (value1 / 100.0) * (value2 / 100.0)\r\n \r\n # Add weight decay\r\n decay_rate = self.config.hebbian.get('weight_decay', 0.01) * 0.1\r\n new_weight = prev_weight + weight_change - (prev_weight * decay_rate)\r\n \r\n # Clamp weight to [-1, 1] range\r\n new_weight = min(max(new_weight, -1.0), 1.0)\r\n self.weights[use_pair] = new_weight\r\n\r\n # Add animation using helper method\r\n self.add_weight_animation(neuron1, neuron2, prev_weight, new_weight)\r\n\r\n # Record weight change time\r\n if abs(new_weight - prev_weight) > 0.001:\r\n self.weight_change_events[neuron1] = current_time\r\n self.weight_change_events[neuron2] = current_time\r\n \r\n if (neuron1, neuron2) not in self.recently_updated_neuron_pairs and \\\r\n (neuron2, neuron1) not in self.recently_updated_neuron_pairs:\r\n self.recently_updated_neuron_pairs.append((neuron1, neuron2))\r\n \r\n self.mark_render_dirty()\r\n self.update()\r\n\r\n self.communication_events[neuron1] = current_time\r\n self.communication_events[neuron2] = current_time\r\n\r\n def is_connector_neuron(self, neuron_name: str) -> bool:\r\n \"\"\"\r\n Check if a neuron is a connector neuron.\r\n Checks multiple sources to ensure robustness across save/load states.\r\n \"\"\"\r\n if not neuron_name:\r\n return False\r\n \r\n # 1. Check visual shape (Primary persistence mechanism)\r\n if self.neuron_shapes.get(neuron_name) == 'hexagon':\r\n return True\r\n \r\n # 2. Check naming convention\r\n if neuron_name.startswith('connector_'):\r\n return True\r\n \r\n # 3. Check enhanced neurogenesis registry (Runtime logic)\r\n if hasattr(self, 'enhanced_neurogenesis') and self.enhanced_neurogenesis:\r\n fn = self.enhanced_neurogenesis.functional_neurons.get(neuron_name)\r\n if fn and fn.neuron_type == 'connector':\r\n return True\r\n \r\n return False\r\n\r\n def get_neuron_degree(self, neuron_name: str) -> int:\r\n \"\"\"Count the number of active connections for a specific neuron.\"\"\"\r\n count = 0\r\n for (u, v) in self.weights.keys():\r\n if u == neuron_name or v == neuron_name:\r\n count += 1\r\n return count\r\n\r\n def prune_weak_connections(self, threshold=0.05, min_age_sec=600):\r\n \"\"\"Removes connections with absolute weight below threshold, ignoring connectors.\"\"\"\r\n if not self.pruning_enabled:\r\n return 0\r\n\r\n to_delete = []\r\n\r\n for pair, weight in list(self.weights.items()):\r\n if not (isinstance(pair, tuple) and len(pair) == 2):\r\n continue\r\n\r\n neuron1, neuron2 = pair\r\n\r\n # IMMUNITY: Never prune connections attached to connector neurons\r\n if self.is_connector_neuron(neuron1) or self.is_connector_neuron(neuron2):\r\n continue\r\n\r\n # IMMUNITY: New neurons\r\n if self.is_new_neuron(neuron1, min_age_sec) or self.is_new_neuron(neuron2, min_age_sec):\r\n continue\r\n\r\n if abs(weight) < threshold:\r\n to_delete.append(pair)\r\n\r\n for pair in to_delete:\r\n if pair in self.weights:\r\n del self.weights[pair]\r\n\r\n if len(to_delete) > 0:\r\n print(f\"\\x1b[33mPruned {len(to_delete)} weak connections.\\x1b[0m\")\r\n self.mark_render_dirty()\r\n self.update()\r\n \r\n return len(to_delete)\r\n\r\n\r\n def perform_hebbian_learning(self):\r\n \"\"\"\r\n One full Hebbian update cycle.\r\n Queues work to background thread for non-blocking operation.\r\n \"\"\"\r\n # === Disable Hebbian while squid is sleeping ===\r\n if (hasattr(self, 'tamagotchi_logic') and self.tamagotchi_logic and\r\n hasattr(self.tamagotchi_logic.squid, 'is_sleeping') and\r\n self.tamagotchi_logic.squid.is_sleeping):\r\n # print(\"DEBUG: Hebbian learning skipped - squid is sleeping\")\r\n return\r\n\r\n # Skip if already pending\r\n if self._pending_hebbian_learning:\r\n return\r\n \r\n # CRITICAL: Update cache BEFORE queueing work\r\n self._update_worker_cache()\r\n \r\n if self._use_threaded_processing and hasattr(self, 'brain_worker') and self.brain_worker.isRunning():\r\n # Queue the work to the background thread\r\n self._pending_hebbian_learning = True\r\n self.brain_worker.queue_hebbian_learning()\r\n else:\r\n # Fallback: synchronous processing\r\n self._perform_hebbian_learning_sync()\r\n\r\n\r\n def _perform_hebbian_learning_sync(self):\r\n \"\"\"Original synchronous Hebbian learning (fallback if threading disabled).\"\"\"\r\n from heapq import nlargest\r\n\r\n print(f\"++ [Sync] Hebbian learning cycle triggered\")\r\n\r\n COLORS = [\"\\033[96m\", \"\\033[93m\", \"\\033[95m\", \"\\033[92m\", \"\\033[94m\"]\r\n RESET = \"\\033[0m\"\r\n\r\n if not hasattr(self, 'weights'):\r\n self.weights = {}\r\n \r\n # Ensure list exists (used for history tracking in sync mode)\r\n if not hasattr(self, 'recently_updated_neuron_pairs'):\r\n self.recently_updated_neuron_pairs = []\r\n\r\n # NEW: Get connector neurons to exclude from learning\r\n connector_neurons = set()\r\n if hasattr(self, 'enhanced_neurogenesis') and self.enhanced_neurogenesis:\r\n connector_neurons = {name for name, fn in self.enhanced_neurogenesis.functional_neurons.items()\r\n if fn.neuron_type == 'connector'}\r\n \r\n # PURE_INPUTS (Sensors) - Do not include in Hebbian learning\r\n PURE_INPUTS = {\r\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\", \r\n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\", \r\n \"plant_proximity\"\r\n }\r\n\r\n # Combine excluded neurons, connector neurons, and pure inputs\r\n learning_excluded = set(self.excluded_neurons) | connector_neurons | PURE_INPUTS\r\n \r\n neurons = [n for n in self.neuron_positions.keys() if n not in learning_excluded]\r\n print(f\" [Sync] Neurons available: {len(neurons)} (excluded {len(connector_neurons)} connectors + inputs), \"\r\n f\"Weights tracked: {len(self.weights)}\")\r\n\r\n scored_pairs = []\r\n \r\n # Prepare history for quick lookup (ensure sorted tuples)\r\n recent_history_sorted = set()\r\n for p in self.recently_updated_neuron_pairs:\r\n if isinstance(p, (list, tuple)) and len(p) == 2:\r\n recent_history_sorted.add(tuple(sorted(p)))\r\n\r\n for i, n1 in enumerate(neurons):\r\n for n2 in neurons[i + 1:]:\r\n v1 = self.get_neuron_value(self.state.get(n1, 50))\r\n v2 = self.get_neuron_value(self.state.get(n2, 50))\r\n \r\n # Base Score\r\n score = v1 + v2\r\n \r\n # 1. Add Random Noise to break deterministic loops\r\n score += random.uniform(0, 40)\r\n \r\n # 2. Penalize recently updated pairs to prevent loops\r\n current_pair = tuple(sorted((n1, n2)))\r\n \r\n if current_pair in recent_history_sorted:\r\n score -= 500 # Heavy penalty\r\n\r\n scored_pairs.append((score, n1, n2, v1, v2))\r\n top_k = self.config.neurogenesis.get('max_hebbian_pairs', 2)\r\n top_pairs = nlargest(top_k, scored_pairs)\r\n print(f\" [Sync] Top {top_k} pairs selected from {len(scored_pairs)} candidates\")\r\n\r\n updated_pairs = []\r\n\r\n for _, n1, n2, v1, v2 in top_pairs:\r\n base_lr = self.learning_rate\r\n decay_rate = self.config.hebbian.get('weight_decay', 0.01)\r\n\r\n if self.is_new_neuron(n1) or self.is_new_neuron(n2):\r\n base_lr *= 2.0\r\n\r\n delta = base_lr * (v1 / 100.0) * (v2 / 100.0)\r\n\r\n pair = (n1, n2)\r\n reverse_pair = (n2, n1)\r\n use_pair = pair if pair in self.weights else reverse_pair\r\n\r\n if use_pair not in self.weights:\r\n print(f\" [Sync] Skipping pair {n1}-{n2}: not in weights dict\")\r\n continue\r\n\r\n old_w = self.weights[use_pair]\r\n new_w = old_w + delta - (old_w * decay_rate)\r\n new_w = max(self.config.hebbian.get('min_weight', -1.0),\r\n min(self.config.hebbian.get('max_weight', 1.0), new_w))\r\n\r\n self.weights[use_pair] = new_w\r\n self.add_weight_animation(n1, n2, old_w, new_w)\r\n updated_pairs.append((n1, n2))\r\n\r\n if updated_pairs:\r\n colored = []\r\n for i, (a, b) in enumerate(updated_pairs):\r\n color = COLORS[i % len(COLORS)]\r\n colored.append(f\"{color}{a} ↔ {b}{RESET}\")\r\n print(\" Hebbian learning chosen pairs: \" + \" \".join(colored))\r\n else:\r\n print(\" [Sync] No pairs were updated this cycle\")\r\n\r\n self.recently_updated_neuron_pairs = updated_pairs\r\n self.last_hebbian_time = time.time()\r\n self.update()\r\n\r\n\r\n def get_recently_updated_neurons(self):\r\n \"\"\"Return the list of neuron pairs updated in the last learning cycle\"\"\"\r\n return self.recently_updated_neuron_pairs\r\n\r\n\r\n def resizeEvent(self, event):\r\n \"\"\"Handle window resize events - startles squid and enforces minimum size\"\"\"\r\n super().resizeEvent(event)\r\n\r\n # Only trigger startle if we're actually resizing (not just moving)\r\n old_size = event.oldSize()\r\n if (old_size.isValid() and\r\n hasattr(self, 'tamagotchi_logic') and\r\n self.tamagotchi_logic):\r\n\r\n new_size = event.size()\r\n width_change = abs(new_size.width() - old_size.width())\r\n height_change = abs(new_size.height() - old_size.height())\r\n\r\n # Only startle if change is significant (>50px)\r\n if width_change > 50 or height_change > 50:\r\n # Check if first resize\r\n if not hasattr(self, '_has_resized_before'):\r\n source = \"first_resize\"\r\n self._has_resized_before = True\r\n else:\r\n source = \"window_resize\"\r\n\r\n #self.tamagotchi_logic.startle_squid(source=source) #STARTLE WHEN WINDOW RESIZE\r\n\r\n if self.debug_mode:\r\n print(f\"Squid startled by {source}\")\r\n\r\n # Enforce minimum window size (1280x900)\r\n min_width, min_height = 1280, 900\r\n if event.size().width() < min_width or event.size().height() < min_height:\r\n self.resize(\r\n max(event.size().width(), min_width),\r\n max(event.size().height(), min_height)\r\n )\r\n\r\n def closeEvent(self, event):\r\n \"\"\"Handle window close event - save state and clean up resources\"\"\"\r\n # Stop the worker thread first\r\n self.stop_worker()\r\n \r\n if hasattr(self, 'tamagotchi_logic') and self.tamagotchi_logic:\r\n # Save current brain state\r\n try:\r\n brain_state = self.save_brain_state()\r\n with open('last_brain_state.json', 'w') as f:\r\n json.dump(brain_state, f)\r\n except Exception as e:\r\n print(f\"Error saving brain state: {e}\")\r\n\r\n # Clean up timers\r\n if hasattr(self, 'hebbian_timer'):\r\n self.hebbian_timer.stop()\r\n if hasattr(self, 'countdown_timer'):\r\n self.countdown_timer.stop()\r\n if hasattr(self, 'memory_update_timer'):\r\n self.memory_update_timer.stop()\r\n\r\n # Close any child windows\r\n if hasattr(self, '_inspector') and self._inspector: \r\n self._inspector.close()\r\n \r\n if hasattr(self, '_laboratory') and self._laboratory:\r\n self._laboratory.close()\r\n \r\n # Accept the close event \r\n event.accept()\r\n\r\n def save_brain_state(self):\r\n return {\r\n 'weights': self.weights,\r\n 'neuron_positions': self.neuron_positions,\r\n 'neuron_states': self.state,\r\n 'layer_structure': self.layers,\r\n 'neuron_shapes': dict(self.neuron_shapes),\r\n 'state_colors': dict(self.state_colors),\r\n }\r\n\r\n def load_brain_state(self, state):\r\n \"\"\"Load the brain state from a saved state dictionary\"\"\"\r\n self.weights = state['weights']\r\n self.neuron_positions = state['neuron_positions']\r\n self.state = state.get('neuron_states', {})\r\n self.layers = state.get('layer_structure', [])\r\n \r\n # Sync connections list from loaded weights\r\n self.sync_connections_from_weights()\r\n\r\n # ADD THESE THREE LINES\r\n self.neuron_shapes = state.get('neuron_shapes', {}) # Load shapes\r\n self.state_colors = state.get('state_colors', {}) # Load colors\r\n print(f\"📦 Loaded {len(self.neuron_shapes)} neuron shapes\") # Debug print\r\n\r\n # Ensure all neurons in neuron_positions exist in state\r\n for neuron in self.neuron_positions:\r\n if neuron not in self.state:\r\n self.state[neuron] = 50\r\n\r\n # Explicitly update excluded neurons if they exist in positions\r\n for neuron in self.excluded_neurons:\r\n if neuron in self.neuron_positions and neuron not in self.state:\r\n self.state[neuron] = False\r\n\r\n # Ensure visible_neurons is complete\r\n if not self.is_tutorial_mode:\r\n self.visible_neurons = set(self.original_neurons)\r\n for neuron in self.neuron_positions:\r\n if neuron not in self.excluded_neurons and neuron not in self.original_neurons:\r\n self.visible_neurons.add(neuron)\r\n print(f\"📊 Loaded {len(self.neuron_positions)} neurons, {len(self.visible_neurons)} visible\")\r\n \r\n # Mark render dirty and trigger update\r\n self.mark_render_dirty()\r\n self.update()\r\n\r\n\r\n\r\n\r\n def create_initial_state(self):\r\n \"\"\"\r\n Create and return the initial brain state for a new game.\r\n Returns a dictionary with all core neurons set to their default values.\r\n Also resets animation tracking attributes.\r\n \"\"\"\r\n # Reset animation tracking attributes\r\n self.reset_animation_state()\r\n \r\n initial_state = {\r\n \"can_see_food\": 0,\r\n \"hunger\": 50,\r\n \"happiness\": 50,\r\n \"cleanliness\": 50,\r\n \"sleepiness\": 50,\r\n \"satisfaction\": 50,\r\n \"anxiety\": 50,\r\n \"curiosity\": 50,\r\n \"is_sick\": False,\r\n \"is_eating\": False,\r\n \"is_sleeping\": False,\r\n \"pursuing_food\": False,\r\n \"direction\": \"up\",\r\n \"position\": (0, 0),\r\n \"is_startled\": False,\r\n \"is_fleeing\": False,\r\n 'neurogenesis_active': True\r\n }\r\n return initial_state\r\n \r\n def reset_animation_state(self):\r\n \"\"\"\r\n Reset all animation and reveal tracking attributes for a new game.\r\n This ensures the neuron reveal animation can run properly.\r\n \"\"\"\r\n # Enable tutorial mode for new game reveal animation\r\n self.is_tutorial_mode = True\r\n \r\n # Reset visible neurons\r\n self.visible_neurons = set()\r\n \r\n # Reset reveal tracking (recreate if deleted)\r\n self.revealed_neurons = set()\r\n self.revealed_connections = set()\r\n \r\n # Clear reveal animations\r\n self.neuron_reveal_animations = {}\r\n \r\n print(\"🔄 Animation state reset for new game (tutorial mode enabled)\")\r\n\r\n def initialize_connections(self):\r\n \"\"\"Return list of connection tuples derived from self.weights.\r\n This ensures self.connections stays synced with self.weights as source of truth.\"\"\"\r\n return list(self.weights.keys())\r\n \r\n def sync_connections_from_weights(self):\r\n \"\"\"Sync self.connections list from self.weights (single source of truth).\r\n Call this after any modification to self.weights.\"\"\"\r\n self.connections = list(self.weights.keys())\r\n\r\n def initialize_weights(self):\r\n \"\"\"Initialize weights with sparse random connections (40% density).\"\"\"\r\n neurons = list(self.neuron_positions.keys())\r\n # Create sparse random connections (40% density)\r\n connection_probability = 0.4\r\n \r\n for i in range(len(neurons)):\r\n for j in range(i+1, len(neurons)):\r\n if random.random() < connection_probability:\r\n self.weights[(neurons[i], neurons[j])] = random.uniform(-1, 1)\r\n \r\n # Sync connections list from weights\r\n self.sync_connections_from_weights()\r\n\r\n def get_neuron_count(self):\r\n \"\"\"Returns the actual count of neurons in the network positions.\"\"\"\r\n return len(self.neuron_positions)\r\n\r\n def get_edge_count(self):\r\n \"\"\"Returns the actual count of connections (weights) in the network.\"\"\"\r\n return len(self.weights) # MODIFIED: Use self.weights\r\n\r\n def get_weakest_connections(self, n=3):\r\n \"\"\"Return the n weakest connections by absolute weight\"\"\"\r\n if not hasattr(self, 'weights') or not self.weights:\r\n return []\r\n\r\n sorted_weights = sorted(self.weights.items(), key=lambda x: abs(x[1]))\r\n return sorted_weights[:n] # Returns list of ((source, target), weight) tuples\r\n\r\n def get_extreme_neurons(self, n=3):\r\n \"\"\"Return neurons deviating most from baseline (50)\"\"\"\r\n neurons = [(k, v) for k, v in self.state.items()\r\n if isinstance(v, (int, float)) and k in self.neuron_positions]\r\n most_positive = sorted(neurons, key=lambda x: -x[1])[:n]\r\n most_negative = sorted(neurons, key=lambda x: x[1])[:n]\r\n return {'overactive': most_positive, 'underactive': most_negative}\r\n\r\n def get_unbalanced_connections(self, n=3):\r\n \"\"\"Return connections with largest weight disparities\"\"\"\r\n unbalanced = []\r\n for (a, b), w1 in self.weights.items():\r\n w2 = self.weights.get((b, a), 0)\r\n if abs(w1 - w2) > 0.3: # Only consider significant differences\r\n unbalanced.append(((a, b), (w1, w2), abs(w1 - w2)))\r\n return sorted(unbalanced, key=lambda x: -x[2])[:n]\r\n\r\n def calculate_network_health(self):\r\n \"\"\"Calculate network health based on connection weights and neuron activity\"\"\"\r\n total_weight = sum(abs(w) for w in self.weights.values())\r\n avg_weight = total_weight / len(self.weights) if self.weights else 0\r\n health = min(100, max(0, avg_weight * 100))\r\n return health\r\n\r\n def calculate_network_efficiency(self):\r\n \"\"\"Calculate network efficiency based on connection distribution\"\"\"\r\n if not self.connections:\r\n return 0\r\n reciprocal_count = 0\r\n for conn in self.connections:\r\n reverse_conn = (conn[1], conn[0])\r\n if reverse_conn in self.connections:\r\n reciprocal_count += 1\r\n efficiency = (reciprocal_count / len(self.connections)) * 100\r\n return efficiency\r\n\r\n def log_neurogenesis_event(self, neuron_name, event_type, reason=None, details=None):\r\n \"\"\"Log neurogenesis events in a human-readable paragraph format.\"\"\"\r\n \r\n timestamp = datetime.now().strftime(\"%H:%M:%S\")\r\n log_entry = \"\"\r\n\r\n if event_type == \"created\" and details:\r\n neuron_type = details.get(\"trigger_type\")\r\n trigger_value = details.get(\"trigger_value\", 0.0)\r\n\r\n if not neuron_type:\r\n return # Cannot log without a neuron type\r\n\r\n # General creation message\r\n log_entry += f\"{timestamp} - a {neuron_type.upper()} neuron ({neuron_name}) was created because {neuron_type} counter was {trigger_value:.2f}\\n\"\r\n\r\n # Specific details for stress neurons\r\n if neuron_type == \"stress\":\r\n log_entry += \"An inhibitory connection was made to ANXIETY\\n\"\r\n log_entry += \"Maximum anxiety value has been permanently reduced by 10\\n\"\r\n\r\n elif event_type == \"pruned\":\r\n # A more consistent format for pruned events\r\n timestamp_full = datetime.now().strftime(\"%H:%M:%S\")\r\n log_entry = f\"{timestamp_full} - a neuron ({neuron_name}) was PRUNED due to {reason if reason else 'unknown reason'}\\n\"\r\n\r\n if log_entry:\r\n try:\r\n with open('neurogenesis_log.txt', 'a', encoding='utf-8') as f:\r\n f.write(log_entry)\r\n # Always add the separator after an entry\r\n f.write(\"\\n-------------------------------\\n\\n\")\r\n except Exception as e:\r\n print(f\"\\x1b[31mNeurogenesis logging failed: {str(e)}\\x1b[0m\")\r\n\r\n # In brain_widget.py\r\n\r\n def update_state(self, new_state=None):\r\n \"\"\"\r\n Update neuron activations. \r\n If new_state is provided, it is the SOURCE OF TRUTH (Sensor data).\r\n If None, it is a PHYSICS TICK (Internal decay/noise).\r\n \"\"\"\r\n import time\r\n import random\r\n\r\n # LIST OF PROTECTED INPUTS\r\n PURE_INPUTS = {\r\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\", \r\n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\", \r\n \"plant_proximity\"\r\n }\r\n\r\n # --- CASE A: External Update (Source of Truth) ---\r\n if new_state is not None:\r\n for k, v in (new_state.items() if isinstance(new_state, dict) else []):\r\n val_to_set = v\r\n # Enforce binary rules for specific neurons\r\n if k in self.neuron_positions and self.is_binary_neuron(k):\r\n if isinstance(v, bool):\r\n val_to_set = 100.0 if v else 0.0\r\n elif isinstance(v, (int, float)):\r\n val_to_set = 100.0 if float(v) > 50.0 else 0.0\r\n else:\r\n val_to_set = float(v) if isinstance(v, (int, float, bool)) else v\r\n\r\n # 1. Update Display State\r\n self.state[k] = val_to_set\r\n\r\n # 2. Update Internal Simulation State\r\n if k in self.neurons:\r\n self.neurons[k]['activation'] = float(val_to_set)\r\n\r\n # [Update cache so worker knows the new truth immediately]\r\n if hasattr(self, 'brain_worker') and self.brain_worker:\r\n self._update_worker_cache()\r\n\r\n self.mark_render_dirty()\r\n self.update()\r\n return\r\n\r\n # --- CASE B: Internal Physics Tick (Decay/Noise) ---\r\n # We must NOT apply decay to PURE_INPUTS\r\n \r\n updated = {}\r\n\r\n # 1. Calculate Decay & Noise\r\n for neuron, props in self.neurons.items():\r\n # [FIX] SKIP PURE INPUTS. Do not calculate decay for them.\r\n if neuron in PURE_INPUTS:\r\n continue\r\n\r\n value = props.get('activation', 0.0)\r\n decay = props.get('decay', 1.0)\r\n noise = props.get('noise', 0.0)\r\n value *= decay\r\n value += random.uniform(-noise, noise)\r\n updated[neuron] = value\r\n\r\n # 2. Apply Connections - USE self.weights as source of truth\r\n for (src, dst), weight in self.weights.items():\r\n # Get source value (Use current state if it's an input)\r\n if src in PURE_INPUTS and src not in updated:\r\n src_val = self.neurons.get(src, {}).get('activation', 0.0)\r\n elif src in updated:\r\n src_val = updated[src]\r\n else:\r\n continue\r\n\r\n # [FIX] NEVER modify a PURE_INPUT via connections\r\n if dst in PURE_INPUTS:\r\n continue\r\n \r\n if dst not in updated:\r\n continue\r\n\r\n updated[dst] += src_val * weight\r\n\r\n # 3. Save Back\r\n for neuron, val in updated.items():\r\n clamped = max(min(val, 100), -100)\r\n if neuron in self.neurons:\r\n self.neurons[neuron]['activation'] = clamped\r\n else:\r\n self.state[neuron] = clamped\r\n\r\n if updated:\r\n self.mark_render_dirty()\r\n\r\n def _perform_state_update_sync(self):\r\n \"\"\"Synchronous fallback when worker is unavailable\"\"\"\r\n import random\r\n \r\n updated = {}\r\n # [FIX] Define protected neurons here as well\r\n PURE_INPUTS = {\r\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\", \r\n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\", \r\n \"plant_proximity\"\r\n }\r\n \r\n # First pass: decay and noise\r\n for neuron, props in self.neurons.items():\r\n if neuron in self.excluded_neurons:\r\n continue\r\n \r\n # [FIX] Skip decay for inputs\r\n if neuron in PURE_INPUTS:\r\n continue\r\n\r\n value = props.get('activation', 0)\r\n decay = props.get('decay', 1.0)\r\n noise = props.get('noise', 0.0)\r\n value *= decay\r\n value += random.uniform(-noise, noise)\r\n updated[neuron] = value\r\n \r\n # Second pass: connection effects - USE self.weights as source of truth\r\n for (src, dst), weight in self.weights.items():\r\n # Skip if neurons don't exist in updated state\r\n if src not in self.state and src not in updated:\r\n continue\r\n if dst not in updated:\r\n continue\r\n \r\n # [FIX] Prevent inputs from being modified by connections\r\n if dst in PURE_INPUTS:\r\n continue\r\n \r\n # Get source value\r\n if src in updated:\r\n src_val = updated[src]\r\n elif src in self.state:\r\n src_val = self.state[src]\r\n if isinstance(src_val, bool):\r\n src_val = 100.0 if src_val else 0.0\r\n else:\r\n continue\r\n \r\n if isinstance(src_val, (int, float)):\r\n updated[dst] += src_val * weight\r\n\r\n # Use current state for inputs if not in 'updated' list yet\r\n src_val = updated.get(src, self.state.get(src, 0))\r\n \r\n if dst in updated:\r\n updated[dst] += src_val * weight\r\n \r\n # Final pass: clamping\r\n for neuron, val in updated.items():\r\n updated[neuron] = max(min(val, 100), -100)\r\n \r\n self.state.update(updated)\r\n self.update()\r\n\r\n\r\n def _fast_apply_external_state(self, new_state):\r\n \"\"\"Quickly apply externally provided state (plugin updates, etc.)\"\"\"\r\n for k, v in new_state.items():\r\n if k in self.neuron_positions:\r\n if self.is_binary_neuron(k):\r\n self.state[k] = 100.0 if (v if isinstance(v, bool) else float(v) > 50) else 0.0\r\n else:\r\n self.state[k] = float(v) if isinstance(v, (int, float)) else v\r\n \r\n # >>> ADDED: Mark render dirty <<<\r\n self.mark_render_dirty()\r\n\r\n def _perform_state_update_sync(self):\r\n \"\"\"Synchronous fallback when worker is unavailable\"\"\"\r\n import random\r\n \r\n updated = {}\r\n BINARY_NEURONS = {\"can_see_food\"}\r\n \r\n # First pass: decay and noise\r\n for neuron, props in self.neurons.items():\r\n if neuron in self.excluded_neurons:\r\n continue\r\n value = props.get('activation', 0)\r\n decay = props.get('decay', 1.0)\r\n noise = props.get('noise', 0.0)\r\n value *= decay\r\n value += random.uniform(-noise, noise)\r\n updated[neuron] = value\r\n \r\n # Second pass: connection effects - USE self.weights as source of truth\r\n for (src, dst), weight in self.weights.items():\r\n if src in updated and dst in updated:\r\n updated[dst] += updated[src] * weight\r\n \r\n # Final pass: clamping\r\n for neuron, val in updated.items():\r\n if neuron in BINARY_NEURONS:\r\n updated[neuron] = 100.0 if val > 50 else 0.0\r\n else:\r\n updated[neuron] = max(min(val, 100), -100)\r\n \r\n self.state.update(updated)\r\n self.update()\r\n\r\n\r\n def provide_outcome_feedback(self, outcome_value: float):\r\n \"\"\"\r\n Provide feedback to recently activated neurons.\r\n outcome_value: 1.0 = very positive, 0.0 = neutral, -1.0 = very negative\r\n \"\"\"\r\n if not hasattr(self, 'enhanced_neurogenesis'):\r\n return\r\n \r\n current_time = time.time()\r\n \r\n # Update utility scores for recently active neurons\r\n for name, func_neuron in self.enhanced_neurogenesis.functional_neurons.items():\r\n # Was this neuron recently active?\r\n # Check if func_neuron has the last_activated attribute (for FunctionalNeuron objects)\r\n if hasattr(func_neuron, 'last_activated') and current_time - func_neuron.last_activated < 30: # 30 seconds\r\n if hasattr(func_neuron, 'update_utility_score'):\r\n func_neuron.update_utility_score(outcome_value)\r\n\r\n\r\n \r\n \r\n def check_neurogenesis_triggers(self, state):\r\n \"\"\"Enhanced neurogenesis check with proper trigger priority\"\"\"\r\n if not state.get('neurogenesis_active', True):\r\n return False\r\n \r\n # Build experience context\r\n recent_actions = state.get('recent_actions', [])\r\n environment = {\r\n 'food_count': state.get('food_count', 0),\r\n 'poop_count': state.get('poop_count', 0),\r\n 'has_rock': state.get('carrying_rock', False)\r\n }\r\n \r\n # ===== FIX: PROPER TRIGGER PRIORITY WITH EMERGENCY OVERRIDE =====\r\n trigger_type = None\r\n \r\n # 🚨 HIGHEST PRIORITY: Emergency stress (overrides everything)\r\n if state.get('anxiety', 50) >= 95:\r\n trigger_type = 'stress'\r\n print(f\"🚨 EMERGENCY: Critical anxiety level ({state.get('anxiety', 50):.1f})!\")\r\n \r\n # HIGH PRIORITY: Stress (anxiety or sustained stress)\r\n elif state.get('anxiety', 50) > 75 or state.get('sustained_stress', 0) > 1:\r\n trigger_type = 'stress'\r\n \r\n # MEDIUM PRIORITY: Novelty (curiosity or new objects)\r\n elif state.get('curiosity', 50) > 70 or state.get('novelty_exposure', 0) > 2:\r\n trigger_type = 'novelty'\r\n \r\n # LOW PRIORITY: Reward (satisfaction or positive outcomes)\r\n elif state.get('satisfaction', 50) > 70 or state.get('recent_rewards', 0) > 2:\r\n trigger_type = 'reward'\r\n # ================================================================\r\n \r\n if trigger_type:\r\n # Capture full experience context\r\n context = self.enhanced_neurogenesis.capture_experience_context(\r\n trigger_type=trigger_type,\r\n brain_state=self.state,\r\n recent_actions=recent_actions,\r\n environment=environment\r\n )\r\n \r\n # Add to experience buffer\r\n self.experience_buffer.add_experience(context)\r\n \r\n # Check if we should create a neuron\r\n if self.enhanced_neurogenesis.should_create_neuron(context):\r\n neuron_name = self.enhanced_neurogenesis.create_functional_neuron(context)\r\n \r\n if neuron_name and self.pruning_enabled:\r\n # Check if we need to prune\r\n current_count = len(self.neuron_positions) - len(self.excluded_neurons)\r\n max_neurons = self.neurogenesis_config.get('max_neurons', 32)\r\n \r\n if current_count > max_neurons * 0.85:\r\n self.enhanced_neurogenesis.intelligent_pruning()\r\n \r\n return neuron_name is not None\r\n \r\n return False\r\n\r\n def get_neurogenesis_threshold(self, trigger_type):\r\n \"\"\"Safely get threshold for a trigger type with fallback defaults\"\"\"\r\n try:\r\n return self.neurogenesis_config['triggers'][trigger_type]['threshold']\r\n except KeyError:\r\n defaults = {'novelty': 0.7, 'stress': 0.8, 'reward': 0.6}\r\n return defaults.get(trigger_type, 1.0)\r\n\r\n def stimulate_brain(self, stimulation_values):\r\n \"\"\"Handle brain stimulation with validation\"\"\"\r\n if not isinstance(stimulation_values, dict):\r\n return\r\n filtered_update = {}\r\n for key in self.state.keys():\r\n if key in stimulation_values:\r\n filtered_update[key] = stimulation_values[key]\r\n self.update_state(filtered_update)\r\n\r\n def get_adjusted_threshold(self, base_threshold, trigger_type):\r\n \"\"\"Scale threshold based on network size to prevent runaway neurogenesis\"\"\"\r\n original_count = len(self.original_neuron_positions)\r\n current_count = len(self.neuron_positions) - len(self.excluded_neurons)\r\n new_neuron_count = current_count - original_count\r\n baseline = original_count + 3\r\n if new_neuron_count <= 0 or current_count <= baseline:\r\n return base_threshold\r\n scaling_factors = {'novelty': 0.25, 'stress': 0.1, 'reward': 0.08}\r\n scaling_factor = scaling_factors.get(trigger_type, 0.15)\r\n multiplier = 1.0 + (scaling_factor * (new_neuron_count - baseline + 1))\r\n adjusted = base_threshold * multiplier\r\n return adjusted\r\n\r\n def prune_weak_neurons(self):\r\n \"\"\"Remove weakly connected or inactive neurons, skipping connectors.\"\"\"\r\n min_neurons = len(self.original_neuron_positions)\r\n current_count = len(self.neuron_positions) - len(self.excluded_neurons)\r\n if current_count <= min_neurons:\r\n return False\r\n\r\n candidates = []\r\n for neuron in list(self.neuron_positions.keys()):\r\n # Basic exclusions\r\n if neuron in self.original_neuron_positions or neuron in self.excluded_neurons:\r\n continue\r\n \r\n # IMMUNITY: Connector neurons are structural and cannot be pruned\r\n if self.is_connector_neuron(neuron):\r\n continue\r\n\r\n connections = [abs(w) for (a, b), w in self.weights.items() if (a == neuron or b == neuron)]\r\n activity = self.state.get(neuron, 0)\r\n activity_score = 0 if isinstance(activity, bool) else abs(activity - 50)\r\n \r\n if not connections or sum(connections) / len(connections) < 0.2:\r\n candidates.append((neuron, 1))\r\n elif activity_score < 10:\r\n candidates.append((neuron, 2))\r\n \r\n candidates.sort(key=lambda x: x[1])\r\n\r\n if candidates:\r\n neuron_to_remove = candidates[0][0]\r\n if neuron_to_remove in self.neuron_positions:\r\n del self.neuron_positions[neuron_to_remove]\r\n if neuron_to_remove in self.state:\r\n del self.state[neuron_to_remove]\r\n if neuron_to_remove in self.neuron_shapes:\r\n del self.neuron_shapes[neuron_to_remove]\r\n if neuron_to_remove in self.state_colors:\r\n del self.state_colors[neuron_to_remove]\r\n \r\n for conn in list(self.weights.keys()):\r\n if isinstance(conn, tuple) and (conn[0] == neuron_to_remove or conn[1] == neuron_to_remove):\r\n del self.weights[conn]\r\n \r\n if neuron_to_remove in self.neurogenesis_data.get('new_neurons', []):\r\n self.neurogenesis_data['new_neurons'].remove(neuron_to_remove)\r\n \r\n reason = \"weak connections/activity\"\r\n self.log_neurogenesis_event(neuron_to_remove, \"pruned\", reason)\r\n \r\n self.mark_render_dirty()\r\n self.update()\r\n return True\r\n return False\r\n\r\n def apply_repulsion_force(self, iterations=15, strength=0.6, threshold=120.0):\r\n \"\"\"Applies repulsion force and enforces boundary constraints from config.\"\"\"\r\n \r\n neuron_props = self.config.neurogenesis.get('neuron_properties', {})\r\n force_bounds = neuron_props.get('force_bounds', True)\r\n centering_force = neuron_props.get('centering_force', 0.02)\r\n padding = neuron_props.get('canvas_padding', 60)\r\n \r\n # Logical canvas center\r\n center_x, center_y = 512, 384\r\n min_x, max_x = padding, 1024 - padding\r\n min_y, max_y = padding, 768 - padding\r\n\r\n neuron_list = [name for name in self.neuron_positions.keys() if name not in self.excluded_neurons]\r\n\r\n for _ in range(iterations):\r\n displacements = {name: [0.0, 0.0] for name in neuron_list}\r\n\r\n # 1. Repulsion between neurons\r\n for i in range(len(neuron_list)):\r\n for j in range(i + 1, len(neuron_list)):\r\n neuron1 = neuron_list[i]\r\n neuron2 = neuron_list[j]\r\n\r\n pos1 = self.neuron_positions[neuron1]\r\n pos2 = self.neuron_positions[neuron2]\r\n\r\n dx = pos1[0] - pos2[0]\r\n dy = pos1[1] - pos2[1]\r\n\r\n distance_sq = dx*dx + dy*dy\r\n\r\n if 0 < distance_sq < threshold*threshold:\r\n distance = math.sqrt(distance_sq)\r\n force = strength * (threshold - distance) / distance\r\n move_x = (dx / distance) * force\r\n move_y = (dy / distance) * force\r\n displacements[neuron1][0] += move_x\r\n displacements[neuron1][1] += move_y\r\n displacements[neuron2][0] -= move_x\r\n displacements[neuron2][1] -= move_y\r\n\r\n # 2. Apply movements + Centering Force + Boundary Constraints\r\n damping = 0.5\r\n moved = False\r\n \r\n for name in neuron_list:\r\n # Skip core neurons IF you want them fixed, but requirement says randomise start\r\n # so we allow them to move, but maybe less? For now, move all.\r\n \r\n pos = self.neuron_positions[name]\r\n disp = displacements[name]\r\n \r\n # Apply Centering Force (pull towards middle)\r\n if centering_force > 0:\r\n dir_to_center_x = center_x - pos[0]\r\n dir_to_center_y = center_y - pos[1]\r\n disp[0] += dir_to_center_x * centering_force\r\n disp[1] += dir_to_center_y * centering_force\r\n\r\n if abs(disp[0]) > 0.1 or abs(disp[1]) > 0.1:\r\n new_x = pos[0] + disp[0] * damping\r\n new_y = pos[1] + disp[1] * damping\r\n \r\n # Force Bounds\r\n if force_bounds:\r\n new_x = max(min_x, min(max_x, new_x))\r\n new_y = max(min_y, min(max_y, new_y))\r\n \r\n self.neuron_positions[name] = (new_x, new_y)\r\n moved = True\r\n\r\n if not moved:\r\n break\r\n if moved:\r\n self.update()\r\n\r\n\r\n def update_weights(self):\r\n\r\n if self.frozen_weights is not None:\r\n return\r\n\r\n # Iterate over a copy of the actual weight keys ---\r\n for conn in list(self.weights.keys()):\r\n # Check if the connection still exists (it might be pruned concurrently)\r\n if conn in self.weights:\r\n # Clamp the weight to stay within [-1, 1]\r\n self.weights[conn] = max(-1, min(1, self.weights[conn]))\r\n\r\n def freeze_weights(self):\r\n self.frozen_weights = self.weights.copy()\r\n\r\n def unfreeze_weights(self):\r\n self.frozen_weights = None\r\n\r\n def strengthen_connection(self, neuron1, neuron2, amount):\r\n \"\"\"Strengthen a connection, respecting connector limits for new links.\"\"\"\r\n pair = (neuron1, neuron2)\r\n reverse_pair = (neuron2, neuron1)\r\n \r\n exists = pair in self.weights or reverse_pair in self.weights\r\n use_pair = pair if pair in self.weights else reverse_pair\r\n\r\n # --- CONNECTOR LIMIT CHECK ---\r\n if not exists:\r\n if self.is_connector_neuron(neuron1) and self.get_neuron_degree(neuron1) >= 3:\r\n return\r\n if self.is_connector_neuron(neuron2) and self.get_neuron_degree(neuron2) >= 3:\r\n return\r\n # If we pass checks, create the connection\r\n self.weights[pair] = 0.0\r\n use_pair = pair\r\n\r\n self.weights[use_pair] += amount\r\n self.weights[use_pair] = max(-1, min(1, self.weights[use_pair]))\r\n \r\n self.mark_render_dirty()\r\n self.update()\r\n\r\n def capture_training_data(self, state):\r\n training_sample = [state[neuron] for neuron in self.neuron_positions.keys()]\r\n self.training_data.append(training_sample)\r\n print(\"Captured training data:\", training_sample)\r\n\r\n def train_hebbian(self):\r\n print(\"Starting Hebbian training...\")\r\n for sample in self.training_data:\r\n self.associations = self.compute_backend.hebbian(\r\n self.associations, sample, self.learning_rate\r\n )\r\n self.training_data = []\r\n\r\n def get_association_strength(self, neuron1, neuron2):\r\n idx1 = list(self.neuron_positions.keys()).index(neuron1)\r\n idx2 = list(self.neuron_positions.keys()).index(neuron2)\r\n return self.compute_backend.get_value(self.associations, idx1, idx2)\r\n \r\n def draw_layers(self, painter, scale):\r\n \"\"\"Draw background rectangles for custom layers (matches BrainDesigner).\"\"\"\r\n if not self.layers: # ← already stored by load_brain_state\r\n return\r\n\r\n for layer in self.layers:\r\n y_pos = layer.get('y_position', 0)\r\n name = layer.get('name', 'Layer')\r\n l_type = layer.get('layer_type', 'hidden')\r\n\r\n # ---- same metrics as BrainDesigner ----\r\n rect_height = 120\r\n rect_top = y_pos - rect_height / 2\r\n rect_left = -200\r\n rect_width = 2000\r\n\r\n # ---- same colours / alpha ----\r\n if l_type == 'input':\r\n color = QtGui.QColor(200, 255, 200, 80)\r\n border_color = QtGui.QColor(150, 220, 150, 120)\r\n elif l_type == 'output':\r\n color = QtGui.QColor(255, 200, 200, 80)\r\n border_color = QtGui.QColor(220, 150, 150, 120)\r\n else: # hidden\r\n color = QtGui.QColor(230, 230, 255, 80)\r\n border_color = QtGui.QColor(200, 200, 240, 120)\r\n\r\n # ---- filled background ----\r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRect(QtCore.QRectF(rect_left, rect_top,\r\n rect_width, rect_height))\r\n\r\n # ---- top & bottom border lines ----\r\n painter.setPen(QtGui.QPen(border_color, 2))\r\n painter.drawLine(QtCore.QLineF(rect_left, rect_top,\r\n rect_left + rect_width, rect_top))\r\n painter.drawLine(QtCore.QLineF(rect_left, rect_top + rect_height,\r\n rect_left + rect_width, rect_top + rect_height))\r\n\r\n # ---- layer label ----\r\n font = painter.font()\r\n font.setPointSize(int(10 * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n painter.setPen(QtGui.QColor(100, 100, 120))\r\n painter.drawText(QtCore.QPointF(10, rect_top + 20),\r\n f\"{name} ({l_type})\")\r\n\r\n def draw_connections(self, painter, scale):\r\n \"\"\"\r\n Draw connections with extended 2-second weight-change animations.\r\n Links are forced INVISIBLE while core neurons are still being revealed.\r\n Includes special visualization for Stress->Anxiety inhibitory links.\r\n \"\"\"\r\n if not self.show_links:\r\n return\r\n\r\n # ===== PERFORMANCE FIX: Skip if widget is hidden =====\r\n if not self.isVisible():\r\n return\r\n\r\n # ===== PERFORMANCE TRACKING =====\r\n if _PERF_TRACKING_AVAILABLE:\r\n _conn_start = time.perf_counter()\r\n\r\n # absolutely no connections until every core neuron is completely revealed (tutorial mode guard). \r\n if self.is_tutorial_mode and len(self.visible_neurons) < len(self.original_neurons):\r\n return\r\n \r\n # ===== NEURAL STYLE: Use dedicated neural renderer =====\r\n if self.anim_neural_pulse_enabled:\r\n self._draw_neural_connections(painter, scale)\r\n return\r\n\r\n current_time = time.time()\r\n connections_drawn = 0\r\n connections_skipped = 0\r\n\r\n for key, weight in self.weights.items():\r\n if not isinstance(key, tuple) or len(key) != 2:\r\n continue\r\n source, target = key\r\n\r\n # skip tutorial-only connections when not in tutorial\r\n tutorial_mode = getattr(self.parent(), 'tutorial_active', False)\r\n is_tutorial_conn = (source.startswith('tutorial_neuron_') or\r\n target.startswith('tutorial_neuron_'))\r\n if is_tutorial_conn and not tutorial_mode:\r\n continue\r\n\r\n # skip if either neuron is still revealing (tutorial safety)\r\n if self.is_tutorial_mode and (\r\n not self.is_neuron_revealed(source) or\r\n not self.is_neuron_revealed(target)):\r\n connections_skipped += 1\r\n continue\r\n\r\n if (source not in self.neuron_positions or\r\n target not in self.neuron_positions or\r\n source in self.excluded_neurons or\r\n target in self.excluded_neurons):\r\n continue\r\n\r\n # skip connections involving non-visible core neurons (tutorial)\r\n if self.is_tutorial_mode:\r\n if source in self.original_neurons and source not in self.visible_neurons:\r\n connections_skipped += 1\r\n continue\r\n if target in self.original_neurons and target not in self.visible_neurons:\r\n connections_skipped += 1\r\n continue\r\n\r\n start = self.neuron_positions[source]\r\n end = self.neuron_positions[target]\r\n start_point = QtCore.QPointF(float(start[0]), float(start[1]))\r\n end_point = QtCore.QPointF(float(end[0]), float(end[1]))\r\n\r\n # === SPECIAL STYLING: Stress -> Anxiety (Dotted Red with Moving Arrows) ===\r\n # Detect connection between any stress neuron and anxiety\r\n is_stress_to_anxiety = (\r\n (source.lower().startswith('stress') and target.lower() == 'anxiety') or\r\n (target.lower().startswith('stress') and source.lower() == 'anxiety'))\r\n \r\n if is_stress_to_anxiety:\r\n # 1. Draw Dotted Red Line\r\n # Use a bright red color to indicate inhibitory/stress signal\r\n pen = QtGui.QPen(QtGui.QColor(255, 60, 60)) \r\n pen.setWidth(max(2, int(3 * scale))) # Thicker than normal for visibility\r\n pen.setStyle(QtCore.Qt.DotLine)\r\n painter.setPen(pen)\r\n painter.drawLine(start_point, end_point)\r\n \r\n # 2. Draw Moving Arrows (Flowing towards Anxiety)\r\n # Determine which end is Anxiety\r\n if target.lower() == 'anxiety':\r\n actual_start = start_point\r\n actual_end = end_point\r\n else:\r\n actual_start = end_point\r\n actual_end = start_point\r\n \r\n # Vector math for the line\r\n dx = actual_end.x() - actual_start.x()\r\n dy = actual_end.y() - actual_start.y()\r\n length = math.sqrt(dx*dx + dy*dy)\r\n \r\n if length > 0:\r\n # Unit vector\r\n ux = dx / length\r\n uy = dy / length\r\n \r\n # Arrow animation parameters\r\n arrow_spacing = 40 * scale # Distance between arrows\r\n speed = 60 * scale # Pixels per second\r\n \r\n # Offset based on time to create movement\r\n offset = (current_time * speed) % arrow_spacing\r\n \r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(255, 0, 0)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n \r\n current_dist = offset\r\n while current_dist < length:\r\n # Calculate position of arrow center on the line\r\n ax = actual_start.x() + ux * current_dist\r\n ay = actual_start.y() + uy * current_dist\r\n \r\n # Draw triangle (Arrowhead)\r\n arrow_size = 6 * scale\r\n \r\n # Perpendicular vector for arrowhead width\r\n px = -uy * arrow_size\r\n py = ux * arrow_size\r\n \r\n # Tip of arrow (pointing forward)\r\n tip_x = ax + ux * arrow_size\r\n tip_y = ay + uy * arrow_size\r\n \r\n # Base corners of arrow\r\n base_x = ax - ux * arrow_size\r\n base_y = ay - uy * arrow_size\r\n \r\n points = [\r\n QtCore.QPointF(tip_x, tip_y),\r\n QtCore.QPointF(base_x + px, base_y + py),\r\n QtCore.QPointF(base_x - px, base_y - py)\r\n ]\r\n painter.drawPolygon(QtGui.QPolygonF(points))\r\n \r\n current_dist += arrow_spacing\r\n\r\n # Skip standard drawing logic for this connection\r\n connections_drawn += 1\r\n continue\r\n\r\n # === STANDARD CONNECTION DRAWING ===\r\n anim_weight = weight\r\n base_width = self.anim_line_base_width * scale\r\n line_width = base_width\r\n pen_style = QtCore.Qt.SolidLine\r\n animating = False\r\n pulse_progress = 0.0\r\n\r\n # check for active weight-change animations (2-second window)\r\n for anim in self.weight_animations:\r\n if anim['pair'] == key:\r\n elapsed = current_time - anim['start_time']\r\n if elapsed < anim['duration']:\r\n progress = elapsed / anim['duration']\r\n anim_weight = anim['start_weight'] + progress * (\r\n anim['end_weight'] - anim['start_weight'])\r\n\r\n # growing / shrinking line width\r\n if progress < 0.5:\r\n line_width = base_width + (6.0 * scale * progress * 2)\r\n else:\r\n line_width = base_width + (6.0 * scale * (1 - progress) * 2)\r\n\r\n pulse_progress = progress * anim['pulse_speed']\r\n animating = True\r\n break\r\n\r\n # colour & alpha\r\n if animating:\r\n r, g, b = anim['color']\r\n alpha = int(255 * (1 - pulse_progress ** 2))\r\n color = QtGui.QColor(r, g, b, alpha)\r\n else:\r\n base_alpha = int(self._link_opacities.get(key, 0.0) * 255)\r\n \r\n # ===== VIBRANT STYLE: Apply ambient pulse =====\r\n if self.anim_ambient_pulse_enabled and base_alpha > 0:\r\n pulse_state = self._get_or_create_ambient_pulse(key)\r\n phase = pulse_state['phase']\r\n \r\n # Sinusoidal oscillation (0 to 1 range)\r\n pulse_factor = (math.sin(phase) + 1.0) / 2.0\r\n \r\n # Interpolate width\r\n w_min, w_max = self.anim_ambient_pulse_width_range\r\n width_mult = w_min + pulse_factor * (w_max - w_min)\r\n line_width = base_width * width_mult\r\n \r\n # Interpolate alpha\r\n a_min, a_max = self.anim_ambient_pulse_alpha_range\r\n pulse_alpha = int(a_min + pulse_factor * (a_max - a_min))\r\n # Combine with base opacity\r\n final_alpha = int((base_alpha / 255.0) * pulse_alpha)\r\n \r\n if weight > 0:\r\n color = QtGui.QColor(self.anim_line_col_pos[0], \r\n self.anim_line_col_pos[1], \r\n self.anim_line_col_pos[2], final_alpha)\r\n else:\r\n color = QtGui.QColor(self.anim_line_col_neg[0], \r\n self.anim_line_col_neg[1], \r\n self.anim_line_col_neg[2], final_alpha)\r\n else:\r\n # Standard coloring (classic style or opacity 0)\r\n color = (QtGui.QColor(0, int(255 * abs(weight)), 0, base_alpha) if weight > 0 else\r\n QtGui.QColor(int(255 * abs(weight)), 0, 0, base_alpha))\r\n\r\n # line style\r\n if is_tutorial_conn and tutorial_mode:\r\n color = QtGui.QColor(255, 255, 0, 180)\r\n line_width = 3\r\n pen_style = QtCore.Qt.DashLine\r\n else:\r\n pen_style = (QtCore.Qt.DashLine if weight < 0 else\r\n QtCore.Qt.SolidLine)\r\n if abs(anim_weight) < 0.1:\r\n pen_style = QtCore.Qt.DotLine\r\n\r\n painter.setPen(QtGui.QPen(color, line_width, pen_style))\r\n painter.drawLine(start_point, end_point)\r\n\r\n # pulse circle travelling along the wire (uses animation style params)\r\n if self.anim_pulse_enabled and animating and pulse_progress < 1.0:\r\n pulse_pos = pulse_progress\r\n pulse_x = start_point.x() + pulse_pos * (end_point.x() - start_point.x())\r\n pulse_y = start_point.y() + pulse_pos * (end_point.y() - start_point.y())\r\n pulse_size = self.anim_pulse_diameter * scale * (1 - pulse_progress ** 2)\r\n\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(*self.anim_pulse_colour, self.anim_pulse_alpha)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawEllipse(QtCore.QPointF(pulse_x, pulse_y),\r\n pulse_size, pulse_size)\r\n\r\n # glow around the line (uses animation style params)\r\n if self.anim_glow_enabled and animating and progress < self.anim_glow_fade_threshold:\r\n glow_progress = progress / self.anim_glow_fade_threshold\r\n glow_width = line_width + 4 * scale * (1 - glow_progress)\r\n glow_color = QtGui.QColor(*self.anim_glow_colour, self.anim_glow_alpha)\r\n painter.setPen(QtGui.QPen(glow_color, glow_width, pen_style))\r\n painter.drawLine(start_point, end_point)\r\n \r\n # ===== SUBTLE STYLE: Draw communication glow packets =====\r\n if self.anim_comm_glow_enabled:\r\n self._draw_comm_glows_for_connection(\r\n painter, scale, key, start_point, end_point\r\n )\r\n\r\n # weight text (optional)\r\n if self.show_weights and abs(weight) > 0.1:\r\n # Calculate angle for rotation\r\n dx = end_point.x() - start_point.x()\r\n dy = end_point.y() - start_point.y()\r\n angle_deg = math.degrees(math.atan2(dy, dx))\r\n \r\n # Ensure text is readable (not upside down)\r\n if angle_deg > 90:\r\n angle_deg -= 180\r\n elif angle_deg < -90:\r\n angle_deg += 180\r\n\r\n midpoint = QtCore.QPointF((start_point.x() + end_point.x()) / 2,\r\n (start_point.y() + end_point.y()) / 2)\r\n \r\n text_str = f\"{weight:.2f}\"\r\n \r\n # Font config\r\n font_size = max(7, int(8 * scale))\r\n padding = 4 * scale\r\n \r\n font = painter.font()\r\n font.setPointSize(font_size)\r\n font.setBold(True)\r\n painter.setFont(font)\r\n \r\n fm = painter.fontMetrics()\r\n text_w = fm.horizontalAdvance(text_str)\r\n text_h = fm.height()\r\n\r\n painter.save()\r\n painter.translate(midpoint)\r\n painter.rotate(angle_deg)\r\n \r\n # Draw background pill\r\n rect = QtCore.QRectF(-text_w/2 - padding, -text_h/2, \r\n text_w + padding*2, text_h)\r\n \r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(255, 255, 255, 220)))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(100, 100, 100, 150), 1))\r\n painter.drawRoundedRect(rect, 4, 4)\r\n \r\n # Draw text\r\n text_color = QtGui.QColor(0, 100, 0) if weight >= 0 else QtGui.QColor(150, 0, 0)\r\n painter.setPen(text_color)\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, text_str)\r\n \r\n painter.restore()\r\n\r\n connections_drawn += 1\r\n\r\n # debug guard: warn only when something looks wrong\r\n if connections_drawn == 0 and len(self.weights) > 0:\r\n print(f\"🔴 NO CONNECTIONS DRAWN! tutorial_mode={self.is_tutorial_mode}, \"\r\n f\"visible_neurons={len(self.visible_neurons)}, original_neurons={len(self.original_neurons)}, \"\r\n f\"total_weights={len(self.weights)}, skipped={connections_skipped}\")\r\n \r\n # ===== END PERFORMANCE TRACKING =====\r\n if _PERF_TRACKING_AVAILABLE:\r\n _conn_elapsed = (time.perf_counter() - _conn_start) * 1000\r\n perf_tracker.record(\"draw_connections\", _conn_elapsed)\r\n\r\n def _get_logical_coords(self, widget_pos):\r\n \"\"\"\r\n Maps widget pixels back to logical neuron coordinates.\r\n MUST MATCH brain_render_worker.py scaling logic exactly.\r\n \"\"\"\r\n # Constants from render worker\r\n indicator_space = 0 \r\n base_width = 1024\r\n base_height = 768 - indicator_space\r\n \r\n # Calculate Scale\r\n scale_x = self.width() / base_width\r\n scale_y = (self.height() - indicator_space) / max(1, base_height)\r\n scale = max(0.01, min(scale_x, scale_y))\r\n \r\n # Calculate Offset (centering)\r\n offset_x = 0\r\n if scale_x > scale_y:\r\n content_width = base_width * scale\r\n offset_x = (self.width() - content_width) / 2\r\n \r\n # Inverse Transform: (Screen - Offset) / Scale = Logical\r\n lx = (widget_pos.x() - offset_x) / scale\r\n ly = (widget_pos.y() - indicator_space) / scale\r\n \r\n return QtCore.QPointF(lx, ly)\r\n\r\n def get_connection_at_pos(self, widget_pos):\r\n logical_pos = self._get_logical_coords(widget_pos)\r\n threshold = 15.0 # logical pixels tolerance\r\n closest_dist = float('inf')\r\n closest_conn = None\r\n\r\n # Helper to convert tuple coords to QPointF\r\n to_pt = lambda c: QtCore.QPointF(c[0], c[1])\r\n\r\n for (u, v) in self.weights.keys():\r\n # Skip invisible/excluded\r\n if u not in self.neuron_positions or v not in self.neuron_positions: continue\r\n if u in self.excluded_neurons or v in self.excluded_neurons: continue\r\n if not self.show_links: continue\r\n\r\n # If strictly 2-element tuple\r\n p1 = to_pt(self.neuron_positions[u])\r\n p2 = to_pt(self.neuron_positions[v])\r\n \r\n d2 = self._dist_to_segment_squared(logical_pos, p1, p2)\r\n \r\n if d2 < threshold**2 and d2 < closest_dist:\r\n closest_dist = d2\r\n closest_conn = (u, v)\r\n\r\n return closest_conn\r\n\r\n def _draw_connection_highlight(self, painter):\r\n if not self.hovered_connection:\r\n return\r\n\r\n u, v = self.hovered_connection\r\n if u not in self.neuron_positions or v not in self.neuron_positions:\r\n return\r\n\r\n indicator_space = 0\r\n base_width = 1024\r\n base_height = 768 - indicator_space\r\n \r\n scale_x = self.width() / base_width\r\n scale_y = (self.height() - indicator_space) / max(1, base_height)\r\n scale = max(0.01, min(scale_x, scale_y))\r\n \r\n offset_x = 0\r\n if scale_x > scale_y:\r\n content_width = base_width * scale\r\n offset_x = (self.width() - content_width) / 2\r\n\r\n pos1 = self.neuron_positions[u]\r\n pos2 = self.neuron_positions[v]\r\n\r\n # Apply Transform: Logical * Scale + Offset = Screen\r\n x1 = pos1[0] * scale + offset_x\r\n y1 = pos1[1] * scale + indicator_space\r\n x2 = pos2[0] * scale + offset_x\r\n y2 = pos2[1] * scale + indicator_space\r\n\r\n p1 = QtCore.QPointF(x1, y1)\r\n p2 = QtCore.QPointF(x2, y2)\r\n\r\n # Draw Glow/Highlight\r\n painter.save()\r\n # Yellow, thick, slightly transparent\r\n pen = QtGui.QPen(QtGui.QColor(255, 255, 0, 200), 6 * scale)\r\n pen.setCapStyle(QtCore.Qt.RoundCap)\r\n painter.setPen(pen)\r\n painter.drawLine(p1, p2)\r\n \r\n # Label (Weight Value)\r\n weight = self.weights.get(self.hovered_connection, 0.0)\r\n mid = (p1 + p2) / 2\r\n \r\n font = painter.font()\r\n font.setPointSize(max(10, int(12 * scale)))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n \r\n label = f\"{weight:.2f}\"\r\n fm = painter.fontMetrics()\r\n w = fm.horizontalAdvance(label) + 10\r\n h = fm.height() + 4\r\n r = QtCore.QRectF(mid.x() - w/2, mid.y() - h/2, w, h)\r\n \r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.setBrush(QtGui.QColor(0, 0, 0, 180))\r\n painter.drawRoundedRect(r, 4, 4)\r\n \r\n painter.setPen(QtGui.QColor(255, 255, 0))\r\n painter.drawText(r, QtCore.Qt.AlignCenter, label)\r\n \r\n painter.restore()\r\n\r\n def _dist_to_segment_squared(self, p, v, w):\r\n l2 = (v.x() - w.x())**2 + (v.y() - w.y())**2\r\n if l2 == 0: return (p.x() - v.x())**2 + (p.y() - v.y())**2\r\n t = ((p.x() - v.x()) * (w.x() - v.x()) + (p.y() - v.y()) * (w.y() - v.y())) / l2\r\n t = max(0, min(1, t))\r\n dist_x = p.x() - (v.x() + t * (w.x() - v.x()))\r\n dist_y = p.y() - (v.y() + t * (w.y() - v.y()))\r\n return dist_x**2 + dist_y**2\r\n\r\n def get_neuron_at_pos(self, widget_pos):\r\n \"\"\"Finds a neuron at the given QPoint widget coordinates.\"\"\"\r\n logical_pos = self._get_logical_coords(widget_pos)\r\n neuron_radius = 50 # Increased to 50 for better click detection on all neurons\r\n for name, pos in self.neuron_positions.items():\r\n dist_sq = (logical_pos.x() - pos[0])**2 + (logical_pos.y() - pos[1])**2\r\n if dist_sq <= neuron_radius**2:\r\n return name\r\n return None\r\n\r\n\r\n # ------------------------------------------------------------------\r\n # Binary neuron detection\r\n # ------------------------------------------------------------------\r\n def is_binary_neuron(self, name: str) -> bool:\r\n \"\"\"Neurons that are strictly on/off (not continuous stats).\"\"\"\r\n return name in {\r\n 'can_see_food', 'is_eating', 'is_sleeping', 'is_sick',\r\n 'pursuing_food', 'is_fleeing', 'is_startled',\r\n 'external_stimulus', 'plant_proximity'\r\n }\r\n\r\n # ------------------------------------------------------------------\r\n\r\n def paintEvent(self, event):\r\n \"\"\"\r\n Optimized paintEvent that uses cached offscreen render.\r\n \r\n The heavy rendering is done in BrainRenderWorker. This method\r\n just blits the cached image and draws any overlay elements\r\n that need to be responsive (like hover effects).\r\n \"\"\"\r\n # Performance tracking\r\n if _PERF_TRACKING_AVAILABLE:\r\n _paint_start = time.perf_counter()\r\n perf_tracker.increment(\"paint_calls\")\r\n \r\n painter = QtGui.QPainter(self)\r\n painter.setRenderHint(QtGui.QPainter.Antialiasing)\r\n \r\n # Draw cached render if available\r\n if self._cached_render and not self._cached_render.isNull():\r\n # Scale cached image to widget size if needed\r\n if (self._cached_render.width() != self.width() or \r\n self._cached_render.height() != self.height()):\r\n # Request new render at correct size\r\n self._render_dirty = True\r\n # Draw scaled version for now\r\n scaled = self._cached_render.scaled(\r\n self.width(), self.height(),\r\n QtCore.Qt.KeepAspectRatio,\r\n QtCore.Qt.SmoothTransformation\r\n )\r\n painter.drawImage(0, 0, scaled)\r\n else:\r\n painter.drawImage(0, 0, self._cached_render)\r\n else:\r\n # No cached render yet - draw background and request render\r\n bg_color = QtGui.QColor(*self.anim_background_colour)\r\n painter.fillRect(self.rect(), bg_color)\r\n self._render_dirty = True\r\n \r\n # Draw overlay elements that need immediate response\r\n self._draw_overlays(painter)\r\n \r\n painter.end()\r\n \r\n # Performance tracking\r\n if _PERF_TRACKING_AVAILABLE:\r\n _paint_elapsed = (time.perf_counter() - _paint_start) * 1000\r\n perf_tracker.record(\"paint_event\", _paint_elapsed)\r\n\r\n def _draw_overlays(self, painter):\r\n \"\"\"\r\n Draw overlay elements that need immediate response.\r\n These are drawn on top of the cached render.\r\n \"\"\"\r\n # Tutorial glow effect\r\n if getattr(self, 'tutorial_glow_active', False):\r\n self._draw_tutorial_glow(painter)\r\n \r\n # Connection Highlight\r\n if self.hovered_connection:\r\n self._draw_connection_highlight(painter)\r\n\r\n # Neurogenesis highlights\r\n if hasattr(self, 'neurogenesis_highlight'):\r\n nh = self.neurogenesis_highlight\r\n if nh.get('neuron') and time.time() - nh.get('start_time', 0) < nh.get('duration', 0):\r\n self._draw_neurogenesis_highlight(painter)\r\n \r\n # Drag preview if dragging a neuron\r\n if getattr(self, 'dragging', False) and getattr(self, 'dragged_neuron', None):\r\n self._draw_drag_preview(painter)\r\n\r\n def _draw_tutorial_glow(self, painter):\r\n \"\"\"Draw tutorial glow border effect\"\"\"\r\n opacity = getattr(self, '_tutorial_glow_opacity', 0.0)\r\n if opacity > 0:\r\n glow_color = QtGui.QColor(255, 215, 0, int(150 * opacity))\r\n pen = QtGui.QPen(glow_color, 4)\r\n painter.setPen(pen)\r\n painter.setBrush(QtCore.Qt.NoBrush)\r\n painter.drawRect(self.rect().adjusted(2, 2, -2, -2))\r\n\r\n def _draw_neurogenesis_highlight(self, painter):\r\n \"\"\"Draw highlight around newly created neurons\"\"\"\r\n # Calculate scale (same as in render worker)\r\n indicator_space = 0\r\n base_width = 1024\r\n base_height = 768 - indicator_space\r\n scale_x = self.width() / base_width\r\n scale_y = (self.height() - indicator_space) / max(1, base_height)\r\n scale = max(0.01, min(scale_x, scale_y))\r\n \r\n offset_x = 0\r\n if scale_x > scale_y:\r\n content_width = base_width * scale\r\n offset_x = (self.width() - content_width) / 2\r\n \r\n nh = self.neurogenesis_highlight\r\n neuron_name = nh.get('neuron')\r\n if neuron_name and neuron_name in self.neuron_positions:\r\n pos = self.neuron_positions[neuron_name]\r\n x = pos[0] * scale + offset_x\r\n y = pos[1] * scale + indicator_space\r\n \r\n # Pulsing effect\r\n elapsed = time.time() - nh.get('start_time', 0)\r\n pulse = 0.5 + 0.5 * math.sin(elapsed * 4)\r\n \r\n radius = 40 * scale * (1 + pulse * 0.2)\r\n alpha = int(200 * (1 - elapsed / nh.get('duration', 1)))\r\n \r\n painter.setPen(QtGui.QPen(QtGui.QColor(255, 255, 0, alpha), 3))\r\n painter.setBrush(QtCore.Qt.NoBrush)\r\n painter.drawEllipse(QtCore.QPointF(x, y), radius, radius)\r\n\r\n def _draw_drag_preview(self, painter):\r\n \"\"\"Draw preview when dragging a neuron (runs at full framerate)\"\"\"\r\n if not self.dragged_neuron or self.dragged_neuron not in self.neuron_positions:\r\n return\r\n\r\n # 1. Calculate Scale (Must match _draw_neurogenesis_highlight and render worker)\r\n indicator_space = 0\r\n base_width = 1024\r\n base_height = 768 - indicator_space\r\n scale_x = self.width() / base_width\r\n scale_y = (self.height() - indicator_space) / max(1, base_height)\r\n scale = max(0.01, min(scale_x, scale_y))\r\n \r\n # 2. Prepare single-neuron state for static drawing\r\n name = self.dragged_neuron\r\n pos = self.neuron_positions[name]\r\n val = self.state.get(name, 50)\r\n \r\n temp_positions = {name: pos}\r\n temp_states = {name: val}\r\n \r\n # 3. Draw the neuron immediately (bypassing cached 10fps render)\r\n # Note: We don't clear the background, so we draw ON TOP of the cached frame.\r\n # This might cause a slight 'trail' behind the moving neuron if the background \r\n # refresh is slow, but it guarantees the neuron stays stuck to the mouse cursor.\r\n \r\n # Check if it has a custom shape\r\n shape = self.neuron_shapes.get(name, 'circle')\r\n \r\n x = pos[0] * scale\r\n y = pos[1] * scale\r\n radius = 20 * scale\r\n \r\n # Temporarily set painter to high quality\r\n painter.save()\r\n painter.setRenderHint(QtGui.QPainter.Antialiasing)\r\n \r\n # Use existing shape drawing logic\r\n if shape == 'diamond':\r\n self.draw_diamond_neuron(painter, x, y, radius, name, scale)\r\n elif shape == 'square':\r\n self.draw_square_neuron(painter, x, y, radius, name, scale)\r\n elif shape == 'triangle':\r\n self.draw_triangular_neuron(painter, x, y, radius, name, scale)\r\n elif shape == 'hexagon':\r\n self.draw_hexagon_neuron(painter, x, y, radius, name, scale)\r\n else:\r\n # Standard/Continuous or Binary\r\n # Explicitly call the static method from the Mixin class\r\n NetworkRenderingMixin.draw_neurons_static(\r\n painter, temp_positions, temp_states,\r\n visible_neurons={name}, \r\n scale=scale, \r\n base_font_size=self.neuron_label_font_size\r\n )\r\n \r\n painter.restore()\r\n\r\n def draw_neurons(self, painter, scale=1.0):\r\n \"\"\"Main neuron drawing routine.\"\"\"\r\n # ------------------------------------------------------------------\r\n # Explicit list of true binary (on/off) neurons\r\n # ------------------------------------------------------------------\r\n BINARY_NEURONS = {\r\n \"can_see_food\", \"is_eating\", \"is_sleeping\",\r\n \"is_sick\", \"is_fleeing\", \"pursuing_food\", \"is_startled\",\r\n \"external_stimulus\", \"plant_proximity\"\r\n }\r\n\r\n # Font size for labels - use config value directly\r\n label_font = QtGui.QFont(\"Arial\", self.neuron_label_font_size)\r\n label_font.setBold(True)\r\n painter.setFont(label_font)\r\n font_metrics = painter.fontMetrics()\r\n\r\n for name, pos in self.neuron_positions.items():\r\n if name not in self.visible_neurons and not self.is_tutorial_mode:\r\n continue\r\n if name in self.excluded_neurons:\r\n continue\r\n\r\n x_logical, y_logical = pos\r\n x = x_logical * scale\r\n y = y_logical * scale\r\n radius = 20 * scale\r\n\r\n # Check shape early\r\n shape = self.neuron_shapes.get(name, 'circle')\r\n\r\n # --- BINARY NEURONS (always squares) ---\r\n if name in BINARY_NEURONS or name == \"can_see_food\":\r\n raw_value = self.state.get(name, 0)\r\n \r\n # Value calculation logic\r\n value = 100.0 if float(raw_value) > 50 else 0.0\r\n is_active = value > 50\r\n color = QtGui.QColor(0, 255, 0) if is_active else QtGui.QColor(255, 0, 0)\r\n\r\n # Draw Square\r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0), max(1, int(2 * scale))))\r\n \r\n size = radius * 1.8 \r\n rect = QtCore.QRectF(x - size/2, y - size/2, size, size)\r\n painter.drawRect(rect)\r\n\r\n # [NEW] Draw Checkmark or Cross inside\r\n symbol = \"✓\" if is_active else \"✗\"\r\n \r\n painter.save()\r\n symbol_font = QtGui.QFont(\"Arial\", int(size * 0.7))\r\n symbol_font.setBold(True)\r\n painter.setFont(symbol_font)\r\n painter.setPen(QtGui.QColor(0, 0, 0)) # Black text\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, symbol)\r\n painter.restore()\r\n\r\n if name == \"can_see_food\":\r\n # Custom \"Small Black Label\" Logic for can_see_food\r\n \r\n # Get Localised Name\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n display_name = loc.get(name)\r\n if display_name == name: display_name = name.replace(\"_\", \" \").title()\r\n\r\n # Smaller Font (0.75x)\r\n small_font = painter.font()\r\n small_font.setPointSize(max(4, int(self.neuron_label_font_size * 0.75 * scale)))\r\n painter.setFont(small_font)\r\n fm = painter.fontMetrics()\r\n\r\n text_width = fm.horizontalAdvance(display_name)\r\n padding = 4 * scale\r\n rect_width = text_width + padding * 2\r\n rect_height = fm.height() + 2\r\n\r\n text_rect = QtCore.QRectF(\r\n x - rect_width / 2,\r\n y + size/2 + 4 * scale,\r\n rect_width,\r\n rect_height\r\n )\r\n\r\n # Black Background\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0))) \r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRoundedRect(text_rect, 2, 2)\r\n\r\n # White Text\r\n painter.setPen(QtGui.QColor(255, 255, 255))\r\n painter.drawText(text_rect, QtCore.Qt.AlignCenter, display_name)\r\n\r\n # Restore Font\r\n painter.setFont(label_font)\r\n else:\r\n # Standard Label for other binary neurons\r\n self._draw_standard_label(painter, name, x, y, scale, self.neuron_label_font_size)\r\n \r\n continue\r\n\r\n # --- SHAPE-BASED NEURONS ---\r\n elif shape == 'hexagon':\r\n # --- HEXAGON LOGIC ---\r\n color = QtGui.QColor(*self.state_colors.get(name, (160, 32, 240)))\r\n \r\n # Draw hexagon\r\n painter.save()\r\n painter.translate(x, y)\r\n \r\n sides = 6\r\n polygon = QtGui.QPolygonF()\r\n angle_step = 360.0 / sides\r\n for i in range(sides):\r\n angle = math.radians(i * angle_step - 90)\r\n polygon.append(QtCore.QPointF(radius * math.cos(angle), \r\n radius * math.sin(angle)))\r\n \r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0)))\r\n painter.drawPolygon(polygon)\r\n \r\n # Draw 'C' inside\r\n font = QtGui.QFont(\"Arial\", int(14 * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n painter.setPen(QtGui.QColor(255, 255, 255))\r\n \r\n rect_size = radius * 2\r\n rect = QtCore.QRectF(-radius, -radius, rect_size, rect_size)\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, \"c\")\r\n painter.restore()\r\n \r\n # SKIP External Label for connectors\r\n continue\r\n \r\n elif shape == 'diamond':\r\n color = QtGui.QColor(*self.state_colors.get(name, (152, 251, 152)))\r\n self._draw_polygon_neuron(painter, x, y, 4, radius, color, name, scale, rotation=0)\r\n continue\r\n \r\n elif shape == 'square':\r\n color = QtGui.QColor(*self.state_colors.get(name, (152, 251, 152)))\r\n self._draw_polygon_neuron(painter, x, y, 4, radius, color, name, scale, rotation=45)\r\n continue\r\n \r\n elif shape == 'triangle':\r\n color = QtGui.QColor(*self.state_colors.get(name, (255, 255, 150)))\r\n self._draw_polygon_neuron(painter, x, y, 3, radius, color, name, scale, rotation=0)\r\n continue\r\n \r\n else: # circle (default)\r\n # Color logic\r\n raw_value = self.state.get(name, 0)\r\n value = float(raw_value) if isinstance(raw_value, (int, float, bool)) else 50.0\r\n value = max(0, min(100, value))\r\n \r\n if name in self.state_colors:\r\n color = QtGui.QColor(*self.state_colors[name])\r\n else:\r\n color = QtGui.QColor(220, 220, 220) # Grey\r\n\r\n # Draw Circle\r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0), max(1, int(2 * scale))))\r\n painter.drawEllipse(QtCore.QPointF(x, y), radius, radius)\r\n\r\n # Draw Label\r\n self._draw_standard_label(painter, name, x, y, scale, self.neuron_label_font_size)\r\n\r\n def _draw_standard_label(self, painter, name, x, y, scale, font_size=None):\r\n \"\"\"Draw a standard neuron label with improved localisation fallback.\"\"\"\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n\r\n if font_size is None:\r\n font_size = self.neuron_label_font_size\r\n\r\n # [NEW] Scale font for neurogenesis neurons\r\n # If the neuron is NOT in the original list, it is a neurogenesis neuron.\r\n is_neurogenesis = name not in self.original_neurons\r\n \r\n # Apply scaling if it's a neurogenesis neuron (0.75x)\r\n effective_font_size = font_size * 0.75 if is_neurogenesis else font_size\r\n\r\n label_font = QtGui.QFont(\"Arial\", int(effective_font_size * scale))\r\n label_font.setBold(True)\r\n painter.setFont(label_font)\r\n font_metrics = painter.fontMetrics()\r\n\r\n # Primary: exact key\r\n display_name = loc.get(name)\r\n\r\n # Fallback 1: try space-separated version\r\n if display_name == name: # Means no translation found\r\n space_key = name.replace(\"_\", \" \")\r\n display_name = loc.get(space_key, default=None)\r\n if display_name is None:\r\n display_name = space_key # Use spaces for readability\r\n\r\n # Fallback 2: neurogenesis pattern (e.g., novelty_1 → Novelty 1)\r\n if display_name == name or display_name == name.replace(\"_\", \" \"):\r\n match = re.match(r\"^([a_z]+)_(\\d+)$\", name)\r\n if match:\r\n base = match.group(1)\r\n idx = match.group(2)\r\n base_loc = loc.get(base)\r\n if base_loc != base: # Found translation for base\r\n display_name = f\"{base_loc} {idx}\"\r\n else:\r\n display_name = f\"{base.capitalize()} {idx}\"\r\n\r\n # Final fallback: clean title case\r\n if display_name == name:\r\n display_name = name.replace(\"_\", \" \").title()\r\n\r\n text_width = font_metrics.horizontalAdvance(display_name)\r\n padding = 10 * scale\r\n rect_width = text_width + padding * 2\r\n rect_height = font_metrics.height() + 4\r\n\r\n text_rect = QtCore.QRectF(\r\n x - rect_width / 2,\r\n y + (20 * scale) + 5 * scale,\r\n rect_width,\r\n rect_height,\r\n )\r\n\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(26, 26, 26, 200)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRoundedRect(text_rect, 4, 4)\r\n\r\n painter.setPen(QtGui.QColor(224, 224, 224))\r\n painter.drawText(text_rect, QtCore.Qt.AlignCenter, display_name)\r\n\r\n def _draw_neuron_label(self, painter, x, y, name, radius, scale, alpha=255):\r\n \"\"\"Draw neuron label for polygon shapes.\"\"\"\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n \r\n # [NEW] Scale font for neurogenesis neurons\r\n base_size = self.neuron_label_font_size\r\n is_neurogenesis = name not in self.original_neurons\r\n effective_size = base_size * 0.75 if is_neurogenesis else base_size\r\n\r\n font = QtGui.QFont(\"Arial\", int(effective_size * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n fm = painter.fontMetrics()\r\n\r\n # Step 1: Try exact key\r\n label = loc.get(name)\r\n\r\n # Step 2: Try space-separated key\r\n if label == name:\r\n space_key = name.replace(\"_\", \" \")\r\n label = loc.get(space_key)\r\n if label == space_key:\r\n label = None # Mark as not found\r\n\r\n # Step 3: Neurogenesis pattern\r\n if not label:\r\n import re\r\n match = re.match(r\"^([a-z_]+)_(\\d+)$\", name)\r\n\r\n def _draw_neuron_label(self, painter, x, y, name, radius, scale, alpha=255):\r\n \"\"\"Draw neuron label for polygon shapes.\"\"\"\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n \r\n # [NEW] Scale font for neurogenesis neurons\r\n base_size = self.neuron_label_font_size\r\n is_neurogenesis = name not in self.original_neurons\r\n effective_size = base_size * 0.75 if is_neurogenesis else base_size\r\n\r\n font = QtGui.QFont(\"Arial\", int(effective_size * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n fm = painter.fontMetrics()\r\n\r\n # Step 1: Try exact key\r\n label = loc.get(name)\r\n\r\n # Step 2: Try space-separated key\r\n if label == name:\r\n space_key = name.replace(\"_\", \" \")\r\n label = loc.get(space_key)\r\n if label == space_key:\r\n label = None # Mark as not found\r\n\r\n # Step 3: Neurogenesis pattern\r\n if not label:\r\n import re\r\n match = re.match(r\"^([a-z_]+)_(\\d+)$\", name)\r\n if match:\r\n base_key = match.group(1)\r\n num = match.group(2)\r\n base_label = loc.get(base_key)\r\n if base_label != base_key:\r\n label = f\"{base_label} {num}\"\r\n else:\r\n label = f\"{base_key.replace('_', ' ').title()} {num}\"\r\n\r\n # Final fallback\r\n if not label:\r\n label = name.replace(\"_\", \" \").title()\r\n\r\n text_width = fm.horizontalAdvance(label)\r\n padding = 10 * scale\r\n \r\n # Position label below the neuron (y + radius + padding)\r\n rect_y = y + radius + (5 * scale)\r\n \r\n rect = QtCore.QRectF(\r\n x - text_width / 2 - padding,\r\n rect_y,\r\n text_width + padding * 2,\r\n fm.height() + 6\r\n )\r\n\r\n # Apply alpha transparency\r\n bg_alpha = min(180, alpha)\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0, bg_alpha)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRoundedRect(rect, 6, 6)\r\n\r\n text_color = QtGui.QColor(255, 255, 255)\r\n text_color.setAlpha(alpha)\r\n painter.setPen(text_color)\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, label)\r\n\r\n def _draw_standard_label(self, painter, name, x, y, scale, font_size=None):\r\n \"\"\"Draw a standard neuron label with improved localisation fallback.\"\"\"\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n\r\n if font_size is None:\r\n font_size = self.neuron_label_font_size\r\n\r\n label_font = QtGui.QFont(\"Arial\", int(font_size * scale))\r\n label_font.setBold(True)\r\n painter.setFont(label_font)\r\n font_metrics = painter.fontMetrics()\r\n\r\n # Primary: exact key\r\n display_name = loc.get(name)\r\n\r\n # Fallback 1: try space-separated version\r\n if display_name == name: # Means no translation found\r\n space_key = name.replace(\"_\", \" \")\r\n display_name = loc.get(space_key, default=None)\r\n if display_name is None:\r\n display_name = space_key # Use spaces for readability\r\n\r\n # Fallback 2: neurogenesis pattern (e.g., novelty_1 → Novelty 1)\r\n if display_name == name or display_name == name.replace(\"_\", \" \"):\r\n match = re.match(r\"^([a_z]+)_(\\d+)$\", name)\r\n if match:\r\n base = match.group(1)\r\n idx = match.group(2)\r\n base_loc = loc.get(base)\r\n if base_loc != base: # Found translation for base\r\n display_name = f\"{base_loc} {idx}\"\r\n else:\r\n display_name = f\"{base.capitalize()} {idx}\"\r\n\r\n # Final fallback: clean title case\r\n if display_name == name:\r\n display_name = name.replace(\"_\", \" \").title()\r\n\r\n text_width = font_metrics.horizontalAdvance(display_name)\r\n padding = 10 * scale\r\n rect_width = text_width + padding * 2\r\n rect_height = font_metrics.height() + 4\r\n\r\n text_rect = QtCore.QRectF(\r\n x - rect_width / 2,\r\n y + (20 * scale) + 5 * scale,\r\n rect_width,\r\n rect_height,\r\n )\r\n\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(26, 26, 26, 200)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRoundedRect(text_rect, 4, 4)\r\n\r\n painter.setPen(QtGui.QColor(224, 224, 224))\r\n painter.drawText(text_rect, QtCore.Qt.AlignCenter, display_name)\r\n\r\n\r\n def draw_binary_neuron(self, painter, x, y, value, label, scale=1.0):\r\n color = (0, 0, 0) if value else (255, 255, 255)\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(*color))); painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0)))\r\n x_scaled, y_scaled, size = int(x * scale), int(y * scale), int(30 * scale)\r\n painter.drawRect(x_scaled - size//2, y_scaled - size//2, size, size)\r\n font = painter.font(); font.setPointSize(max(4, int(5 * scale))); painter.setFont(font) # Reduced from 6, added max\r\n label_width, label_height = int(150 * scale), int(20 * scale)\r\n painter.drawText(x_scaled - label_width//2, y_scaled + int(30 * scale), label_width, label_height, QtCore.Qt.AlignCenter, label)\r\n\r\n def draw_circular_neuron(self, painter, name, pos, value, scale=1.0, visible_neurons=None, excluded_neurons=None):\r\n \"\"\"Fixed version with correct excluded_neurons handling.\"\"\"\r\n if visible_neurons is None:\r\n visible_neurons = self.visible_neurons\r\n if excluded_neurons is None:\r\n excluded_neurons = self.excluded_neurons\r\n\r\n if name in excluded_neurons or name not in visible_neurons:\r\n return\r\n\r\n # Reuse static method for consistency\r\n temp_states = {name: value}\r\n temp_positions = {name: pos}\r\n \r\n NetworkRenderingMixin.draw_neurons_static(\r\n painter, temp_positions, temp_states,\r\n visible_neurons={name}, excluded_neurons=excluded_neurons,\r\n scale=scale, base_font_size=self.neuron_label_font_size\r\n )\r\n\r\n def draw_triangular_neuron(self, painter, x, y, radius, label, scale=1.0, alpha=255):\r\n \"\"\"Draw a triangular neuron with given radius\"\"\"\r\n color = QtGui.QColor(*self.state_colors.get(label, (255, 255, 150)))\r\n self._draw_polygon_neuron(painter, x, y, 3, radius, color, label, scale, alpha=alpha)\r\n\r\n def draw_hexagon_neuron(self, painter, x, y, radius, label, scale=1.0, alpha=255):\r\n \"\"\"Draw a purple hexagon neuron with a 'C' inside and NO external label\"\"\"\r\n # 1. Setup Painter\r\n painter.save()\r\n painter.translate(x, y)\r\n \r\n # Color setup (Purple)\r\n color_tuple = self.state_colors.get(label, (160, 32, 240))\r\n color = QtGui.QColor(*color_tuple)\r\n color.setAlpha(min(255, max(0, alpha)))\r\n \r\n pen_color = QtGui.QColor(0, 0, 0)\r\n pen_color.setAlpha(min(255, max(0, alpha)))\r\n\r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtGui.QPen(pen_color))\r\n\r\n # 2. Draw Hexagon Polygon\r\n sides = 6\r\n polygon = QtGui.QPolygonF()\r\n angle_step = 360.0 / sides\r\n for i in range(sides):\r\n angle = math.radians(i * angle_step - 90)\r\n polygon.append(QtCore.QPointF(radius * math.cos(angle), \r\n radius * math.sin(angle)))\r\n painter.drawPolygon(polygon)\r\n\r\n # 3. Draw the 'C' inside\r\n font_size = int(14 * scale)\r\n font = QtGui.QFont(\"Arial\", font_size)\r\n font.setBold(True)\r\n painter.setFont(font)\r\n \r\n # White text\r\n painter.setPen(QtGui.QColor(255, 255, 255, min(255, max(0, alpha))))\r\n \r\n rect_size = radius * 2\r\n rect = QtCore.QRectF(-radius, -radius, rect_size, rect_size)\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, \"c\")\r\n\r\n painter.restore()\r\n\r\n\r\n def show_diagnostic_report(self):\r\n if hasattr(self, 'brain_widget'): self.brain_widget.show_diagnostic_report()\r\n else: print(\"Error: Brain widget not initialized\")\r\n\r\n def _draw_polygon_neuron(self, painter, x, y, sides, radius, color, label, scale,\r\n rotation=0, alpha=255):\r\n painter.save()\r\n painter.translate(x, y)\r\n painter.rotate(rotation)\r\n\r\n alpha = max(0, min(255, alpha)) # ← clamp\r\n colored = QtGui.QColor(color)\r\n colored.setAlpha(alpha)\r\n\r\n pen_color = QtGui.QColor(0, 0, 0)\r\n pen_color.setAlpha(alpha)\r\n\r\n painter.setBrush(QtGui.QBrush(colored))\r\n painter.setPen(QtGui.QPen(pen_color))\r\n\r\n polygon = QtGui.QPolygonF()\r\n angle_step = 360.0 / sides\r\n for i in range(sides):\r\n angle = math.radians(i * angle_step - 90)\r\n polygon.append(QtCore.QPointF(radius * math.cos(angle),\r\n radius * math.sin(angle)))\r\n painter.drawPolygon(polygon)\r\n painter.restore()\r\n self._draw_neuron_label(painter, x, y, label, radius, scale, alpha)\r\n\r\n def _draw_neuron_label(self, painter, x, y, name, radius, scale, alpha=255):\r\n \"\"\"Draw neuron label with robust localisation fallback.\"\"\"\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n\r\n font = QtGui.QFont(\"Arial\", int(self.neuron_label_font_size * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n fm = painter.fontMetrics()\r\n\r\n # Step 1: Try exact key\r\n label = loc.get(name)\r\n\r\n # Step 2: Try space-separated key\r\n if label == name:\r\n space_key = name.replace(\"_\", \" \")\r\n label = loc.get(space_key)\r\n if label == space_key:\r\n label = None # Mark as not found\r\n\r\n # Step 3: Neurogenesis pattern\r\n if not label:\r\n import re\r\n match = re.match(r\"^([a-z_]+)_(\\d+)$\", name)\r\n if match:\r\n base_key = match.group(1)\r\n num = match.group(2)\r\n base_label = loc.get(base_key)\r\n if base_label != base_key:\r\n label = f\"{base_label} {num}\"\r\n else:\r\n label = f\"{base_key.replace('_', ' ').title()} {num}\"\r\n\r\n # Final fallback\r\n if not label:\r\n label = name.replace(\"_\", \" \").title()\r\n\r\n text_width = fm.horizontalAdvance(label)\r\n padding = 10 * scale\r\n \r\n # Position label below the neuron (y + radius + padding)\r\n rect_y = y + radius + (5 * scale)\r\n \r\n rect = QtCore.QRectF(\r\n x - text_width / 2 - padding,\r\n rect_y,\r\n text_width + padding * 2,\r\n fm.height() + 6\r\n )\r\n\r\n # Apply alpha transparency\r\n bg_alpha = min(180, alpha)\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0, bg_alpha)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRoundedRect(rect, 6, 6)\r\n\r\n text_color = QtGui.QColor(255, 255, 255)\r\n text_color.setAlpha(alpha)\r\n painter.setPen(text_color)\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, label)\r\n\r\n def draw_neurogenesis_highlights(self, painter, scale):\r\n if (self.neurogenesis_highlight['neuron'] and time.time() - self.neurogenesis_highlight['start_time'] < self.neurogenesis_highlight['duration']):\r\n pos = self.neuron_positions.get(self.neurogenesis_highlight['neuron'])\r\n if pos:\r\n painter.setPen(QtGui.QPen(QtGui.QColor(255, 255, 0), int(3 * scale))); painter.setBrush(QtCore.Qt.NoBrush); radius = int(40 * scale)\r\n x, y, width, height = int(pos[0] - radius), int(pos[1] - radius), int(radius * 2), int(radius * 2)\r\n painter.drawEllipse(x, y, width, height)\r\n\r\n def draw_square_neuron(self, painter, x, y, radius, label, scale=1.0, alpha=255):\r\n \"\"\"Draw a square neuron with given radius\"\"\"\r\n color = QtGui.QColor(*self.state_colors.get(label, (152, 251, 152)))\r\n self._draw_polygon_neuron(painter, x, y, 4, radius, color, label, scale, rotation=45, alpha=alpha)\r\n\r\n def draw_diamond_neuron(self, painter, x, y, radius, label, scale=1.0, alpha=255):\r\n \"\"\"Draw a diamond-shaped neuron with given radius\"\"\"\r\n color = QtGui.QColor(*self.state_colors.get(label, (152, 251, 152)))\r\n self._draw_polygon_neuron(painter, x, y, 4, radius, color, label, scale, rotation=0, alpha=alpha)\r\n\r\n def toggle_links(self, state):\r\n \"\"\"\r\n Public slot connected to the checkbox.\r\n Triggers a staggered, organic fade animation for connections.\r\n \"\"\"\r\n from PyQt5 import QtCore\r\n import time\r\n import random\r\n \r\n want_visible = (state == QtCore.Qt.Checked)\r\n \r\n # CRITICAL: We must enable the render loop immediately so the fade animation can play\r\n if want_visible:\r\n self.show_links = True\r\n \r\n now = time.time()\r\n \r\n # Calculate staggering based on number of connections to ensure smooth waves\r\n count = len(self.weights)\r\n \r\n for i, key in enumerate(self.weights.keys()):\r\n self._link_targets[key] = 1.0 if want_visible else 0.0\r\n \r\n # Organic staggering: 0.0 to 1.2 seconds delay based on randomness\r\n # This creates the \\\"not all at once\\\" effect\r\n delay = random.uniform(0.0, 1.2)\r\n \r\n self._link_start_times[key] = now + delay\r\n self._link_fade_speeds[key] = random.uniform(1.5, 4.0) # Variable fade speeds\r\n \r\n # Initialize opacity if tracking is missing\r\n if key not in self._link_opacities:\r\n self._link_opacities[key] = 0.0 if want_visible else 1.0\r\n \r\n # Ensure the fade timer is running to process the animation frames\r\n if not self._link_fade_timer.isActive():\r\n self._link_fade_timer.start()\r\n \r\n self.mark_render_dirty()\r\n\r\n\r\n def toggle_weights(self, state):\r\n self.show_weights = (state == QtCore.Qt.Checked)\r\n self.mark_render_dirty()\r\n self.update()\r\n\r\n def toggle_capture_training_data(self, state):\r\n self.capture_training_data_enabled = state\r\n\r\n def mousePressEvent(self, event):\r\n if event.button() != QtCore.Qt.LeftButton:\r\n super().mousePressEvent(event)\r\n return\r\n\r\n logical_pos = self._get_logical_coords(event.pos())\r\n neuron = self.get_neuron_at_pos(event.pos())\r\n \r\n if not neuron:\r\n self.dragged_neuron = None\r\n self.dragging = False\r\n super().mousePressEvent(event)\r\n return\r\n\r\n # Allow dragging any neuron\r\n self.dragged_neuron = neuron\r\n self.dragging = True\r\n self.drag_start_pos = event.pos()\r\n \r\n # Debug info\r\n is_neuro = self.is_neurogenesis_neuron(neuron)\r\n neuron_type = \"Neurogenesis\" if is_neuro else \"Core\"\r\n \r\n # Debug: Check if neuron is in functional_neurons\r\n if hasattr(self, 'enhanced_neurogenesis') and neuron in self.enhanced_neurogenesis.functional_neurons:\r\n print(f\" Functional neuron details: {self.enhanced_neurogenesis.functional_neurons[neuron]}\")\r\n \r\n self.update()\r\n super().mousePressEvent(event)\r\n\r\n def handle_neuron_clicked(self, neuron_name):\r\n print(f\"\")\r\n\r\n def show_diagnostic_report(self):\r\n dialog = DiagnosticReportDialog(self, self.parent())\r\n dialog.exec_()\r\n\r\n def mouseMoveEvent(self, event):\r\n \"\"\"Handle mouse movement for tooltips, hover tracking, and dragging\"\"\"\r\n if hasattr(self, 'tooltip_manager'):\r\n self.tooltip_manager.show_tooltip_for_position(event)\r\n\r\n # 1. Track hover state for neurons\r\n neuron = self.get_neuron_at_pos(event.pos())\r\n \r\n # Determine if neuron hover state changed\r\n if neuron != self.hovered_neuron:\r\n self.hovered_neuron = neuron\r\n self.hover_animation_time = time.time()\r\n self.hover_value_opacity = 0.0\r\n self.hover_value_display_active = neuron is not None\r\n self.update() \r\n\r\n # 2. [NEW] Track hover state for connections (only if not hovering a neuron)\r\n if not neuron:\r\n conn = self.get_connection_at_pos(event.pos())\r\n if conn != self.hovered_connection:\r\n self.hovered_connection = conn\r\n self.update() # Trigger repaint for overlay\r\n else:\r\n # If hovering neuron, clear connection highlight\r\n if self.hovered_connection is not None:\r\n self.hovered_connection = None\r\n self.update()\r\n\r\n # 3. Dragging logic\r\n if getattr(self, 'dragging', False) and getattr(self, 'dragged_neuron', None):\r\n if self.is_neurogenesis_neuron(self.dragged_neuron):\r\n logical_pos = self._get_logical_coords(event.pos())\r\n self.neuron_positions[self.dragged_neuron] = (logical_pos.x(), logical_pos.y())\r\n self.update()\r\n\r\n super().mouseMoveEvent(event)\r\n\r\n def leaveEvent(self, event):\r\n \"\"\"Clear hover state when mouse leaves widget.\"\"\"\r\n if self.hovered_neuron is not None:\r\n self.hovered_neuron = None\r\n self.hover_value_display_active = False\r\n self.hover_value_opacity = 0.0\r\n self.update()\r\n super().leaveEvent(event)\r\n\r\n def mouseDoubleClickEvent(self, event):\r\n \"\"\"\r\n Handle double-click on a neuron to open the Neuron Laboratory instead of the Inspector.\r\n \"\"\"\r\n if event.button() == QtCore.Qt.LeftButton:\r\n neuron_name = self.get_neuron_at_pos(event.pos())\r\n \r\n if neuron_name:\r\n print(f\"Double-clicked on neuron: {neuron_name}\")\r\n \r\n # Close the old Inspector if it's currently open (compatibility cleanup)\r\n if hasattr(self, '_inspector') and self._inspector and self._inspector.isVisible():\r\n self._inspector.close()\r\n self._inspector = None # Clear the old reference\r\n\r\n # Open or show the Neuron Laboratory\r\n if self._laboratory is None:\r\n self._laboratory = NeuronLaboratory(self, parent=self.window() or self.parent()) \r\n \r\n self._laboratory.show()\r\n self._laboratory.raise_() # Bring the window to the front\r\n\r\n # CALL A NEW METHOD: Pass the neuron name for selection\r\n if hasattr(self._laboratory, 'select_neuron_by_name'):\r\n self._laboratory.select_neuron_by_name(neuron_name)\r\n \r\n self.update() # Redraw the brain visualization\r\n event.accept()\r\n return\r\n \r\n super().mouseDoubleClickEvent(event)\r\n\r\n def mouseReleaseEvent(self, event):\r\n if event.button() == QtCore.Qt.LeftButton:\r\n is_click = False\r\n if self.dragged_neuron and self.drag_start_pos:\r\n distance = (event.pos() - self.drag_start_pos).manhattanLength()\r\n if distance < QtWidgets.QApplication.startDragDistance():\r\n is_click = True\r\n if is_click:\r\n self.neuronClicked.emit(self.dragged_neuron)\r\n self.dragging = False\r\n self.dragged_neuron = None\r\n self.drag_start_pos = None\r\n self.update()\r\n # Only apply repulsion to neurogenesis neurons\r\n #if hasattr(self, 'enhanced_neurogenesis'):\r\n # self.apply_repulsion_force()\r\n super().mouseReleaseEvent(event)\r\n\r\n def draw_strength_multiplier(self, painter, scale):\r\n \"\"\"\r\n Draw strength multipliers on neurons that have been strengthened.\r\n Displays as \"2.5x\" above strengthened neurons with a badge.\r\n \"\"\"\r\n if not hasattr(self, 'enhanced_neurogenesis'):\r\n return\r\n \r\n current_time = time.time()\r\n \r\n # Save painter state to avoid interfering with other drawings\r\n painter.save()\r\n \r\n for name, neuron in self.enhanced_neurogenesis.functional_neurons.items():\r\n # Verify attribute exists and neuron is strengthened\r\n if not hasattr(neuron, 'strength_multiplier'):\r\n continue\r\n \r\n if neuron.strength_multiplier <= 1.0 or name not in self.neuron_positions:\r\n continue\r\n \r\n pos = self.neuron_positions[name]\r\n x, y = pos\r\n \r\n # Position ABOVE the neuron (in logical coordinates)\r\n label_y = y - 45 # Don't scale Y offset - already in logical space\r\n \r\n # Format multiplier text\r\n multiplier_text = f\"{neuron.strength_multiplier:.1f}x\" # FIX: typo here\r\n \r\n # Create font with proper scaling\r\n font = QtGui.QFont()\r\n font.setPointSize(int(9 * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n \r\n # Draw background circle/badge\r\n font_metrics = painter.fontMetrics()\r\n text_width = font_metrics.horizontalAdvance(multiplier_text)\r\n badge_radius = max(12 * scale, (text_width / 2) + 5 * scale)\r\n \r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(255, 215, 0, 220)))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(139, 105, 20), max(1, int(2 * scale))))\r\n painter.drawEllipse(QtCore.QPointF(x, label_y), badge_radius, badge_radius)\r\n \r\n # Draw text\r\n painter.setPen(QtGui.QColor(0, 0, 0))\r\n painter.drawText(\r\n int(x - text_width / 2),\r\n int(label_y - font_metrics.height() / 2),\r\n int(text_width),\r\n int(font_metrics.height()),\r\n QtCore.Qt.AlignCenter,\r\n multiplier_text\r\n )\r\n \r\n # Optional: Add star indicator\r\n star_radius = 8 * scale\r\n star_x = x + 20 * scale\r\n star_y = y - 20 * scale\r\n \r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(255, 215, 0, 200)))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(255, 165, 0), max(1, int(2 * scale))))\r\n painter.drawEllipse(QtCore.QPointF(star_x, star_y), star_radius, star_radius)\r\n \r\n painter.restore()\r\n\r\n\r\n def _is_click_on_neuron(self, point, neuron_pos, scale):\r\n neuron_x, neuron_y = neuron_pos\r\n scaled_x = neuron_x * scale; scaled_y = neuron_y * scale\r\n return (abs(scaled_x - point.x()) <= 25 * scale and abs(scaled_y - point.y()) <= 25 * scale)\r\n\r\n def is_point_inside_neuron(self, point, neuron_pos, scale):\r\n neuron_x, neuron_y = neuron_pos\r\n scaled_x = neuron_x * scale; scaled_y = neuron_y * scale\r\n return ((scaled_x - 25 * scale) <= point.x() <= (scaled_x + 25 * scale) and (scaled_y - 25 * scale) <= point.y() <= (scaled_y + 25 * scale))\r\n\r\n def reset_positions(self):\r\n self.neuron_positions = self.original_neuron_positions.copy()\r\n \r\n # Check config for randomization preference\r\n neuron_props = self.config.neurogenesis.get('neuron_properties', {})\r\n if neuron_props.get('randomize_start_positions', False):\r\n self._randomize_all_positions()\r\n \r\n self.update()\r\n\r\n def _randomize_all_positions(self):\r\n \"\"\"Randomize positions of all neurons within safe bounds.\"\"\"\r\n import random\r\n padding = self.config.neurogenesis.get('neuron_properties', {}).get('canvas_padding', 60)\r\n \r\n # Canvas dimensions (assumed roughly 1024x768 logical)\r\n min_x, max_x = padding, 1024 - padding\r\n min_y, max_y = padding, 768 - padding\r\n \r\n for name in self.neuron_positions:\r\n rx = random.randint(min_x, max_x)\r\n ry = random.randint(min_y, max_y)\r\n self.neuron_positions[name] = (rx, ry)\r\n \r\n print(\"🎲 Randomized neuron positions\")\r\n \r\n def start_tutorial_glow(self, duration_ms=5000):\r\n \"\"\"Start a glowing, pulsing border effect for tutorial purposes\"\"\"\r\n self.tutorial_glow_active = True\r\n self._tutorial_glow_opacity = 0.0\r\n \r\n # Create animation for pulsing effect\r\n self.tutorial_glow_animation = QtCore.QPropertyAnimation(self, b\"tutorial_glow_opacity\")\r\n self.tutorial_glow_animation.setDuration(500) # 0.5 second pulse\r\n self.tutorial_glow_animation.setStartValue(0.0)\r\n self.tutorial_glow_animation.setEndValue(1.0)\r\n self.tutorial_glow_animation.setLoopCount(-1) # Infinite loop\r\n self.tutorial_glow_animation.setEasingCurve(QtCore.QEasingCurve.InOutSine)\r\n \r\n # Start the animation\r\n self.tutorial_glow_animation.start()\r\n \r\n # Set timer to stop after duration\r\n self.tutorial_glow_timer = QtCore.QTimer()\r\n self.tutorial_glow_timer.setSingleShot(True)\r\n self.tutorial_glow_timer.timeout.connect(self.stop_tutorial_glow)\r\n self.tutorial_glow_timer.start(duration_ms)\r\n \r\n def stop_tutorial_glow(self):\r\n \"\"\"Stop the tutorial glow effect\"\"\"\r\n self.tutorial_glow_active = False\r\n if self.tutorial_glow_animation:\r\n self.tutorial_glow_animation.stop()\r\n self.tutorial_glow_animation = None\r\n if self.tutorial_glow_timer:\r\n self.tutorial_glow_timer.stop()\r\n self.tutorial_glow_timer = None\r\n self.update()\r\n \r\n def get_tutorial_glow_opacity(self):\r\n \"\"\"Get current glow opacity (for Qt property animation)\"\"\"\r\n return self._tutorial_glow_opacity\r\n \r\n def set_tutorial_glow_opacity(self, value):\r\n \"\"\"Set glow opacity and trigger repaint (for Qt property animation)\"\"\"\r\n self._tutorial_glow_opacity = value\r\n self.update()\r\n \r\n # Qt property for animation\r\n tutorial_glow_opacity = QtCore.pyqtProperty(float, get_tutorial_glow_opacity, set_tutorial_glow_opacity)\r\n\r\nimport time\r\n\r\nclass PerformanceProfiler:\r\n \"\"\"Lightweight profiler for identifying slow code paths.\"\"\"\r\n \r\n def __init__(self):\r\n self.timings = {}\r\n self.call_counts = {}\r\n \r\n def start(self, name):\r\n if name not in self.timings:\r\n self.timings[name] = []\r\n self.call_counts[name] = 0\r\n self._current_start = time.perf_counter()\r\n self._current_name = name\r\n \r\n def stop(self):\r\n elapsed = (time.perf_counter() - self._current_start) * 1000\r\n self.timings[self._current_name].append(elapsed)\r\n self.call_counts[self._current_name] += 1\r\n # Keep only last 100 samples\r\n if len(self.timings[self._current_name]) > 100:\r\n self.timings[self._current_name].pop(0)\r\n \r\n def report(self):\r\n \"\"\"Print performance report.\"\"\"\r\n print(\"\\n\" + \"=\"*60)\r\n print(\"PERFORMANCE REPORT\")\r\n print(\"=\"*60)\r\n for name, times in sorted(self.timings.items()):\r\n if times:\r\n avg = sum(times) / len(times)\r\n max_t = max(times)\r\n calls = self.call_counts[name]\r\n print(f\"{name:30} avg={avg:6.2f}ms max={max_t:6.2f}ms calls={calls}\")\r\n print(\"=\"*60 + \"\\n\")\r\n\r\n# =============================================================================\r\n# NETWORK RENDERING MIXIN (Add to brain_widget.py)\r\n# =============================================================================\r\n\r\nclass NetworkRenderingMixin:\r\n \"\"\"\r\n Mixin providing static network rendering methods extracted from BrainWidget.\r\n Used by both BrainWidget and save viewer's NetworkCanvas for consistent visuals.\r\n \"\"\"\r\n \r\n @staticmethod\r\n def draw_connections(self, painter, scale):\r\n \"\"\"Draw connections with extended 2-second weight-change animations.\r\n Links are forced INVISIBLE while core neurons are still being revealed.\"\"\"\r\n if not self.show_links:\r\n return\r\n\r\n # ===== PERFORMANCE FIX: Skip if widget is hidden =====\r\n if not self.isVisible():\r\n return\r\n\r\n # ===== PERFORMANCE TRACKING =====\r\n if _PERF_TRACKING_AVAILABLE:\r\n _conn_start = time.perf_counter()\r\n\r\n # absolutely no connections until every core neuron is completely revealed (tutorial mode guard). \r\n if self.is_tutorial_mode and len(self.visible_neurons) < len(self.original_neurons):\r\n return\r\n \r\n # ===== NEURAL STYLE: Use dedicated neural renderer =====\r\n if self.anim_neural_pulse_enabled:\r\n self._draw_neural_connections(painter, scale)\r\n return\r\n\r\n current_time = time.time()\r\n connections_drawn = 0\r\n connections_skipped = 0\r\n\r\n for key, weight in self.weights.items():\r\n if not isinstance(key, tuple) or len(key) != 2:\r\n continue\r\n source, target = key\r\n\r\n # skip tutorial-only connections when not in tutorial\r\n tutorial_mode = getattr(self.parent(), 'tutorial_active', False)\r\n is_tutorial_conn = (source.startswith('tutorial_neuron_') or\r\n target.startswith('tutorial_neuron_'))\r\n if is_tutorial_conn and not tutorial_mode:\r\n continue\r\n\r\n # skip if either neuron is still revealing (tutorial safety)\r\n if self.is_tutorial_mode and (\r\n not self.is_neuron_revealed(source) or\r\n not self.is_neuron_revealed(target)):\r\n connections_skipped += 1\r\n continue\r\n\r\n if (source not in self.neuron_positions or\r\n target not in self.neuron_positions or\r\n source in self.excluded_neurons or\r\n target in self.excluded_neurons):\r\n continue\r\n\r\n # skip connections involving non-visible core neurons (tutorial)\r\n if self.is_tutorial_mode:\r\n if source in self.original_neurons and source not in self.visible_neurons:\r\n connections_skipped += 1\r\n continue\r\n if target in self.original_neurons and target not in self.visible_neurons:\r\n connections_skipped += 1\r\n continue\r\n\r\n start = self.neuron_positions[source]\r\n end = self.neuron_positions[target]\r\n start_point = QtCore.QPointF(float(start[0]), float(start[1]))\r\n end_point = QtCore.QPointF(float(end[0]), float(end[1]))\r\n\r\n # special styling: Stress ↔ Anxiety (uses animation style params)\r\n is_stress_to_anxiety = (\r\n (source.lower().startswith('stress') and target.lower() == 'anxiety') or\r\n (target.lower().startswith('stress') and source.lower() == 'anxiety'))\r\n if is_stress_to_anxiety:\r\n pen = QtGui.QPen(QtGui.QColor(*self.anim_stress_colour))\r\n pen.setWidth(int(self.anim_stress_width))\r\n if self.anim_stress_dashed:\r\n pen.setStyle(QtCore.Qt.DashLine)\r\n painter.setPen(pen)\r\n painter.drawLine(start_point, end_point)\r\n continue # skip default drawing for this pair\r\n\r\n # default appearance (uses animation style params)\r\n anim_weight = weight\r\n base_width = self.anim_line_base_width * scale\r\n line_width = base_width\r\n pen_style = QtCore.Qt.SolidLine\r\n animating = False\r\n pulse_progress = 0.0\r\n\r\n # check for active weight-change animations (2-second window)\r\n for anim in self.weight_animations:\r\n if anim['pair'] == key:\r\n elapsed = current_time - anim['start_time']\r\n if elapsed < anim['duration']:\r\n progress = elapsed / anim['duration']\r\n anim_weight = anim['start_weight'] + progress * (\r\n anim['end_weight'] - anim['start_weight'])\r\n\r\n # growing / shrinking line width\r\n if progress < 0.5:\r\n line_width = base_width + (6.0 * scale * progress * 2)\r\n else:\r\n line_width = base_width + (6.0 * scale * (1 - progress) * 2)\r\n\r\n pulse_progress = progress * anim['pulse_speed']\r\n animating = True\r\n break\r\n\r\n # colour & alpha\r\n if animating:\r\n r, g, b = anim['color']\r\n alpha = int(255 * (1 - pulse_progress ** 2))\r\n color = QtGui.QColor(r, g, b, alpha)\r\n else:\r\n base_alpha = int(self._link_opacities.get(key, 0.0) * 255)\r\n \r\n # ===== VIBRANT STYLE: Apply ambient pulse =====\r\n if self.anim_ambient_pulse_enabled and base_alpha > 0:\r\n pulse_state = self._get_or_create_ambient_pulse(key)\r\n phase = pulse_state['phase']\r\n \r\n # Sinusoidal oscillation (0 to 1 range)\r\n pulse_factor = (math.sin(phase) + 1.0) / 2.0\r\n \r\n # Interpolate width\r\n w_min, w_max = self.anim_ambient_pulse_width_range\r\n width_mult = w_min + pulse_factor * (w_max - w_min)\r\n line_width = base_width * width_mult\r\n \r\n # Interpolate alpha\r\n a_min, a_max = self.anim_ambient_pulse_alpha_range\r\n pulse_alpha = int(a_min + pulse_factor * (a_max - a_min))\r\n # Combine with base opacity\r\n final_alpha = int((base_alpha / 255.0) * pulse_alpha)\r\n \r\n if weight > 0:\r\n color = QtGui.QColor(self.anim_line_col_pos[0], \r\n self.anim_line_col_pos[1], \r\n self.anim_line_col_pos[2], final_alpha)\r\n else:\r\n color = QtGui.QColor(self.anim_line_col_neg[0], \r\n self.anim_line_col_neg[1], \r\n self.anim_line_col_neg[2], final_alpha)\r\n else:\r\n # Standard coloring (classic style or opacity 0)\r\n color = (QtGui.QColor(0, int(255 * abs(weight)), 0, base_alpha) if weight > 0 else\r\n QtGui.QColor(int(255 * abs(weight)), 0, 0, base_alpha))\r\n\r\n # line style\r\n if is_tutorial_conn and tutorial_mode:\r\n color = QtGui.QColor(255, 255, 0, 180)\r\n line_width = 3\r\n pen_style = QtCore.Qt.DashLine\r\n else:\r\n pen_style = (QtCore.Qt.DashLine if weight < 0 else\r\n QtCore.Qt.SolidLine)\r\n if abs(anim_weight) < 0.1:\r\n pen_style = QtCore.Qt.DotLine\r\n\r\n painter.setPen(QtGui.QPen(color, line_width, pen_style))\r\n painter.drawLine(start_point, end_point)\r\n\r\n # pulse circle travelling along the wire (uses animation style params)\r\n if self.anim_pulse_enabled and animating and pulse_progress < 1.0:\r\n pulse_pos = pulse_progress\r\n pulse_x = start_point.x() + pulse_pos * (end_point.x() - start_point.x())\r\n pulse_y = start_point.y() + pulse_pos * (end_point.y() - start_point.y())\r\n pulse_size = self.anim_pulse_diameter * scale * (1 - pulse_progress ** 2)\r\n\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(*self.anim_pulse_colour, self.anim_pulse_alpha)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawEllipse(QtCore.QPointF(pulse_x, pulse_y),\r\n pulse_size, pulse_size)\r\n\r\n # glow around the line (uses animation style params)\r\n if self.anim_glow_enabled and animating and progress < self.anim_glow_fade_threshold:\r\n glow_progress = progress / self.anim_glow_fade_threshold\r\n glow_width = line_width + 4 * scale * (1 - glow_progress)\r\n glow_color = QtGui.QColor(*self.anim_glow_colour, self.anim_glow_alpha)\r\n painter.setPen(QtGui.QPen(glow_color, glow_width, pen_style))\r\n painter.drawLine(start_point, end_point)\r\n \r\n # ===== SUBTLE STYLE: Draw communication glow packets =====\r\n if self.anim_comm_glow_enabled:\r\n self._draw_comm_glows_for_connection(\r\n painter, scale, key, start_point, end_point\r\n )\r\n\r\n # weight text (optional)\r\n if self.show_weights and abs(weight) > 0.1:\r\n # Calculate angle for rotation\r\n dx = end_point.x() - start_point.x()\r\n dy = end_point.y() - start_point.y()\r\n angle_deg = math.degrees(math.atan2(dy, dx))\r\n \r\n # Ensure text is readable (not upside down)\r\n if angle_deg > 90:\r\n angle_deg -= 180\r\n elif angle_deg < -90:\r\n angle_deg += 180\r\n\r\n midpoint = QtCore.QPointF((start_point.x() + end_point.x()) / 2,\r\n (start_point.y() + end_point.y()) / 2)\r\n \r\n text_str = f\"{weight:.2f}\"\r\n \r\n # Font config\r\n font_size = max(7, int(8 * scale))\r\n padding = 4 * scale\r\n \r\n font = painter.font()\r\n font.setPointSize(font_size)\r\n font.setBold(True)\r\n painter.setFont(font)\r\n \r\n fm = painter.fontMetrics()\r\n text_w = fm.horizontalAdvance(text_str)\r\n text_h = fm.height()\r\n\r\n painter.save()\r\n painter.translate(midpoint)\r\n painter.rotate(angle_deg)\r\n \r\n # Draw background pill\r\n rect = QtCore.QRectF(-text_w/2 - padding, -text_h/2, \r\n text_w + padding*2, text_h)\r\n \r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(255, 255, 255, 220)))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(100, 100, 100, 150), 1))\r\n painter.drawRoundedRect(rect, 4, 4)\r\n \r\n # Draw text\r\n text_color = QtGui.QColor(0, 100, 0) if weight >= 0 else QtGui.QColor(150, 0, 0)\r\n painter.setPen(text_color)\r\n painter.drawText(rect, QtCore.Qt.AlignCenter, text_str)\r\n \r\n painter.restore()\r\n\r\n connections_drawn += 1\r\n\r\n # debug guard: warn only when something looks wrong\r\n if connections_drawn == 0 and len(self.weights) > 0:\r\n print(f\"🔴 NO CONNECTIONS DRAWN! tutorial_mode={self.is_tutorial_mode}, \"\r\n f\"visible_neurons={len(self.visible_neurons)}, original_neurons={len(self.original_neurons)}, \"\r\n f\"total_weights={len(self.weights)}, skipped={connections_skipped}\")\r\n \r\n # ===== END PERFORMANCE TRACKING =====\r\n if _PERF_TRACKING_AVAILABLE:\r\n _conn_elapsed = (time.perf_counter() - _conn_start) * 1000\r\n perf_tracker.record(\"draw_connections\", _conn_elapsed)\r\n \r\n @staticmethod\r\n def draw_neurons_static(\r\n painter, neuron_positions, neuron_states,\r\n visible_neurons=None, excluded_neurons=None,\r\n scale=1.0, base_font_size=6):\r\n \"\"\"\r\n Static neuron drawing with full localisation fallback support.\r\n \"\"\"\r\n import re\r\n from .localisation import Localisation\r\n loc = Localisation.instance()\r\n\r\n BINARY_NEURONS = {\r\n \"can_see_food\", \"is_eating\", \"is_sleeping\",\r\n \"is_sick\", \"is_fleeing\", \"pursuing_food\", \"is_startled\"\r\n }\r\n\r\n if visible_neurons is None:\r\n visible_neurons = set(neuron_positions.keys())\r\n if excluded_neurons is None:\r\n excluded_neurons = set()\r\n\r\n label_font = QtGui.QFont(\"Arial\", int(base_font_size * scale))\r\n label_font.setBold(True)\r\n painter.setFont(label_font)\r\n font_metrics = painter.fontMetrics()\r\n\r\n for name, pos in neuron_positions.items():\r\n if name in excluded_neurons or name not in visible_neurons:\r\n continue\r\n\r\n raw_value = neuron_states.get(name, 0)\r\n\r\n # Determine color and value (binary vs continuous)\r\n if name in BINARY_NEURONS:\r\n value = 100.0 if float(raw_value) > 50 else 0.0\r\n is_active = value > 50\r\n color = QtGui.QColor(0, 255, 0) if is_active else QtGui.QColor(255, 0, 0)\r\n else:\r\n value = float(raw_value) if isinstance(raw_value, (int, float, bool)) else 50.0\r\n value = max(0, min(100, value))\r\n normalized = value / 100.0\r\n if normalized > 0.7:\r\n color = QtGui.QColor(76, 175, 80)\r\n elif normalized > 0.4:\r\n color = QtGui.QColor(255, 193, 7)\r\n else:\r\n color = QtGui.QColor(244, 67, 54)\r\n\r\n x = pos[0] * scale\r\n y = pos[1] * scale\r\n radius = 20 * scale\r\n\r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0), max(1, int(2 * scale))))\r\n painter.drawEllipse(QtCore.QPointF(x, y), radius, radius)\r\n\r\n # === Localisation with multi-level fallback ===\r\n display_name = loc.get(name)\r\n\r\n # Fallback 1: space-separated key\r\n if display_name == name:\r\n space_key = name.replace(\"_\", \" \")\r\n display_name = loc.get(space_key)\r\n if display_name == space_key:\r\n display_name = None\r\n\r\n # Fallback 2: neurogenesis numbered neuron\r\n if not display_name:\r\n match = re.match(r\"^([a-z_]+)_(\\d+)$\", name)\r\n if match:\r\n base = match.group(1)\r\n idx = match.group(2)\r\n base_loc = loc.get(base)\r\n if base_loc != base:\r\n display_name = f\"{base_loc} {idx}\"\r\n else:\r\n display_name = f\"{base.replace('_', ' ').title()} {idx}\"\r\n\r\n # Final fallback\r\n if not display_name:\r\n display_name = name.replace(\"_\", \" \").title()\r\n\r\n text_width = font_metrics.horizontalAdvance(display_name)\r\n padding = 10 * scale\r\n rect_width = text_width + padding * 2\r\n rect_height = font_metrics.height() + 4\r\n\r\n text_rect = QtCore.QRectF(\r\n x - rect_width / 2,\r\n y + radius + 5 * scale,\r\n rect_width,\r\n rect_height,\r\n )\r\n\r\n painter.setBrush(QtGui.QBrush(QtGui.QColor(26, 26, 26, 200)))\r\n painter.setPen(QtCore.Qt.NoPen)\r\n painter.drawRoundedRect(text_rect, 4, 4)\r\n\r\n painter.setPen(QtGui.QColor(224, 224, 224))\r\n painter.drawText(text_rect, QtCore.Qt.AlignCenter, display_name)\r\n\r\n \r\n @staticmethod\r\n def draw_layers_static(painter, layers, scale=1.0):\r\n \"\"\"Draw layer background rectangles if layer structure exists\"\"\"\r\n if not layers:\r\n return\r\n \r\n for layer in layers:\r\n y_pos = layer.get('y_position', 0)\r\n name = layer.get('name', 'Layer')\r\n layer_type = layer.get('layer_type', 'hidden')\r\n \r\n # Logical dimensions (match brain_widget's coordinate system)\r\n rect_height = 120\r\n rect_top = (y_pos - rect_height / 2)\r\n rect_left = -200 # Extend beyond visible area\r\n rect_width = 2000\r\n \r\n # Determine layer color based on type\r\n if layer_type == 'input':\r\n color = QtGui.QColor(220, 255, 220, 30)\r\n border_color = QtGui.QColor(180, 220, 180, 60)\r\n elif layer_type == 'output':\r\n color = QtGui.QColor(255, 220, 220, 30)\r\n border_color = QtGui.QColor(220, 180, 180, 60)\r\n else: # hidden\r\n color = QtGui.QColor(230, 230, 255, 40)\r\n border_color = QtGui.QColor(200, 200, 240, 60)\r\n \r\n # Draw rectangle\r\n rect = QtCore.QRectF(rect_left, rect_top, rect_width, rect_height)\r\n painter.setBrush(QtGui.QBrush(color))\r\n painter.setPen(QtGui.QPen(border_color, 1, QtCore.Qt.DashLine))\r\n painter.drawRect(rect)\r\n \r\n # Draw label\r\n font = QtGui.QFont(\"Arial\", int(10 * scale))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n painter.setPen(QtGui.QColor(150, 150, 170))\r\n painter.drawText(QtCore.QPointF(20, rect_top + 20), name)\r\n\r\n\r\n"
},
{
"path": "src/brain_worker.py",
"content": "import sys\nimport time\nimport random\nimport traceback\nimport math\nfrom queue import Queue, Empty\nfrom heapq import nlargest\n\nfrom PyQt5.QtCore import QThread, pyqtSignal, QMutex, QMutexLocker, QWaitCondition\n\nclass BrainWorker(QThread):\n \"\"\"\n Background worker for handling expensive brain logic operations:\n - Neurogenesis checks\n - Hebbian learning calculations\n - State decay and update processing\n \"\"\"\n \n # Signals for results (emitted to main thread)\n neurogenesis_result = pyqtSignal(dict)\n hebbian_result = pyqtSignal(dict)\n state_update_result = pyqtSignal(dict)\n error_occurred = pyqtSignal(str)\n \n def __init__(self, brain_widget=None):\n super().__init__()\n self.brain_widget = brain_widget # Optional weak ref if needed, usually avoided for thread safety\n self._running = True\n self._paused = False\n \n # Thread-safe queues for tasks\n self.task_queue = Queue()\n \n # Cache for thread-safe access to brain state\n self._cache_mutex = QMutex()\n self.cache = {\n 'state': {},\n 'weights': {},\n 'positions': {},\n 'config': None,\n 'excluded_neurons': set(),\n 'connector_neurons': set(),\n 'learning_rate': 0.1,\n 'new_neurons': set(),\n 'custom_neurons': set()\n }\n\n # History tracking to prevent Hebbian loops\n self._last_hebbian_pairs = []\n \n self.wait_condition = QWaitCondition()\n self.queue_mutex = QMutex()\n\n def update_cache(self, state, weights, positions, config, excluded_neurons=None, \n connector_neurons=None, learning_rate=0.1, new_neurons=None,\n custom_neurons=None):\n \"\"\"\n Update the local cache of brain state.\n Called from main thread before triggering heavy tasks.\n \"\"\"\n with QMutexLocker(self._cache_mutex):\n # Deep copy or safe copy important structures\n self.cache['state'] = state.copy()\n self.cache['weights'] = weights.copy()\n self.cache['positions'] = positions.copy()\n self.cache['config'] = config\n self.cache['excluded_neurons'] = excluded_neurons if excluded_neurons else set()\n self.cache['connector_neurons'] = connector_neurons if connector_neurons else set()\n self.cache['learning_rate'] = learning_rate\n self.cache['new_neurons'] = new_neurons if new_neurons else set()\n self.cache['custom_neurons'] = custom_neurons if custom_neurons else set()\n\n def queue_neurogenesis_check(self, state_context):\n self._add_task('neurogenesis', {'state': state_context})\n\n def queue_hebbian_learning(self):\n # print(\"🧵 BrainWorker: Hebbian learning queued\") # Uncomment for verbose queuing logs\n self._add_task('hebbian', {})\n\n def queue_state_update(self, update_data):\n self._add_task('state_update', update_data)\n\n def _add_task(self, task_type, data):\n with QMutexLocker(self.queue_mutex):\n self.task_queue.put((task_type, data))\n self.wait_condition.wakeOne()\n\n def stop(self):\n self._running = False\n with QMutexLocker(self.queue_mutex):\n self.wait_condition.wakeAll()\n\n # --- Pause and Resume Methods ---\n def pause(self):\n \"\"\"Pause the worker thread.\"\"\"\n with QMutexLocker(self.queue_mutex):\n self._paused = True\n \n def resume(self):\n \"\"\"Resume the worker thread.\"\"\"\n with QMutexLocker(self.queue_mutex):\n self._paused = False\n self.wait_condition.wakeAll()\n # --------------------------------\n\n def run(self):\n print(\"🧵 BrainWorker thread started\")\n \n while self._running:\n task = None\n \n # Wait for task\n with QMutexLocker(self.queue_mutex):\n # Check pause state first\n while self._paused and self._running:\n self.wait_condition.wait(self.queue_mutex)\n\n if not self._running:\n break\n\n if self.task_queue.empty():\n self.wait_condition.wait(self.queue_mutex, 200) # Timeout allows checking _running\n # Re-check pause after wait\n if self._paused: \n continue\n if self.task_queue.empty():\n continue\n \n try:\n task = self.task_queue.get_nowait()\n except Empty:\n continue\n\n if not task:\n continue\n\n task_type, data = task\n \n try:\n if task_type == 'neurogenesis':\n self._perform_neurogenesis_check(data)\n elif task_type == 'hebbian':\n self._perform_hebbian_learning()\n elif task_type == 'state_update':\n self._process_state_update(data)\n except Exception as e:\n error_msg = f\"Error in {task_type}: {str(e)}\\n{traceback.format_exc()}\"\n print(error_msg)\n self.error_occurred.emit(error_msg)\n \n print(\"🧵 BrainWorker thread stopped\")\n\n def _perform_neurogenesis_check(self, data):\n \"\"\"Check if neurogenesis conditions are met based on cached config.\"\"\"\n state = data.get('state', {})\n \n with QMutexLocker(self._cache_mutex):\n config = self.cache['config']\n \n if not config:\n return\n\n neuro_config = getattr(config, 'neurogenesis', {})\n \n triggers = {\n 'novelty': state.get('novelty_exposure', 0) > neuro_config.get('novelty_threshold', 3.0),\n 'stress': state.get('sustained_stress', 0) > neuro_config.get('stress_threshold', 1.2) or state.get('anxiety', 0) > 75,\n 'reward': state.get('recent_rewards', 0) > neuro_config.get('reward_threshold', 3.5)\n }\n \n # Priority logic\n trigger_type = None\n trigger_val = 0\n \n if triggers['stress']:\n trigger_type = 'stress'\n trigger_val = state.get('sustained_stress', 0)\n elif triggers['novelty']:\n trigger_type = 'novelty'\n trigger_val = state.get('novelty_exposure', 0)\n elif triggers['reward']:\n trigger_type = 'reward'\n trigger_val = state.get('recent_rewards', 0)\n \n if trigger_type:\n # Emit result back to main thread to finalize creation\n self.neurogenesis_result.emit({\n 'should_create': True,\n 'neuron_type': trigger_type,\n 'trigger_value': trigger_val,\n 'state_context': state,\n 'is_emergency': (trigger_type == 'stress' and state.get('anxiety', 0) > 90)\n })\n else:\n self.neurogenesis_result.emit({'should_create': False})\n\n def _perform_hebbian_learning(self):\n \"\"\"Perform Hebbian learning calculations using cached state.\"\"\"\n # Retrieve snapshot of cache\n with QMutexLocker(self._cache_mutex):\n state = self.cache['state']\n weights = self.cache['weights']\n neuron_list = list(self.cache['positions'].keys())\n excluded = self.cache['excluded_neurons']\n connector_neurons = self.cache['connector_neurons']\n config = self.cache['config']\n base_learning_rate = self.cache['learning_rate']\n new_neurons = self.cache['new_neurons']\n\n # DEBUG: Check if we have the basics\n if not config:\n print(\"⚠️ BrainWorker: Hebbian skipped - No 'config' in cache yet.\")\n return\n \n if not neuron_list:\n print(\"⚠️ BrainWorker: Hebbian skipped - No neurons in cache 'positions'.\")\n return\n\n # PURE_INPUTS (Sensors) - Do not include in Hebbian learning\n PURE_INPUTS = {\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\", \n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\", \n \"plant_proximity\"\n }\n\n # Filter available neurons\n # Exclude system neurons, connector neurons AND pure inputs\n learning_candidates = [\n n for n in neuron_list \n if n not in excluded and n not in connector_neurons and n not in PURE_INPUTS\n ]\n \n # DEBUG: Check if we have enough candidates\n if len(learning_candidates) < 2:\n print(f\"⚠️ BrainWorker: Hebbian skipped - Not enough candidates ({len(learning_candidates)}).\")\n # print(f\" Excluded: {len(excluded)}, Connectors: {len(connector_neurons)}, Total: {len(neuron_list)}\")\n self.hebbian_result.emit({'updated_pairs': []})\n return\n\n # Calculate scores\n scored_pairs = []\n for i, n1 in enumerate(learning_candidates):\n for n2 in learning_candidates[i + 1:]:\n # Base Score: Sum of activations\n v1 = self._get_neuron_value(state.get(n1, 50))\n v2 = self._get_neuron_value(state.get(n2, 50))\n score = v1 + v2\n\n # 1. Add Random Noise to break deterministic loops\n score += random.uniform(0, 40)\n\n # 2. Cooldown Penalty: Check if pair was used in last cycle\n # Sort tuple to ensure (A,B) is treated same as (B,A)\n pair_key = tuple(sorted((n1, n2)))\n if pair_key in self._last_hebbian_pairs:\n score -= 500 # Massive penalty ensures rotation\n\n scored_pairs.append((score, n1, n2, v1, v2))\n\n if not scored_pairs:\n print(\"⚠️ BrainWorker: Hebbian skipped - No valid pairs formed.\")\n return\n\n # Select top pairs\n top_k = 2 # Default\n if hasattr(config, 'neurogenesis'):\n top_k = config.neurogenesis.get('max_hebbian_pairs', 2)\n \n top_pairs = nlargest(top_k, scored_pairs)\n \n # Update history for next run\n self._last_hebbian_pairs = [tuple(sorted((n1, n2))) for _, n1, n2, _, _ in top_pairs]\n \n weight_updates = {}\n updated_pairs_list = []\n \n hebbian_config = getattr(config, 'hebbian', {})\n decay_rate = hebbian_config.get('weight_decay', 0.01)\n \n for _, n1, n2, v1, v2 in top_pairs:\n pair = (n1, n2)\n reverse_pair = (n2, n1)\n \n # Find existing weight key\n use_pair = None\n if pair in weights:\n use_pair = pair\n elif reverse_pair in weights:\n use_pair = reverse_pair\n \n if not use_pair:\n # CREATE NEW CONNECTION if it doesn't exist\n # This allows Hebbian learning to form new pathways between neurons\n # that are frequently co-active, not just strengthen existing ones\n use_pair = pair\n old_w = 0.0 # New connections start at zero\n # Mark this as a new connection that needs to be created\n weight_updates[use_pair] = {\n 'old_weight': old_w,\n 'new_weight': 0.0, # Will be updated below\n 'is_new_connection': True # Signal to brain_widget to create this\n }\n else:\n old_w = weights[use_pair]\n \n # Boost learning rate for new neurons\n lr = base_learning_rate\n if n1 in new_neurons or n2 in new_neurons:\n lr *= 2.0\n \n # Hebbian rule: delta = lr * act1 * act2\n delta = lr * (v1 / 100.0) * (v2 / 100.0)\n \n new_w = old_w + delta - (old_w * decay_rate)\n new_w = max(-1.0, min(1.0, new_w))\n \n # Check if this was a new connection we're creating\n is_new = use_pair in weight_updates and weight_updates[use_pair].get('is_new_connection', False)\n \n weight_updates[use_pair] = {\n 'old_weight': old_w,\n 'new_weight': new_w,\n 'is_new_connection': is_new\n }\n updated_pairs_list.append(use_pair)\n\n if updated_pairs_list:\n print(f\"🧠 Hebbian: updated {len(updated_pairs_list)} pair(s)\")\n\n self.hebbian_result.emit({\n 'updated_pairs': updated_pairs_list,\n 'weight_updates': weight_updates\n })\n\n def _process_state_update(self, data):\n \"\"\"\n Process state decay and noise logic.\n \"\"\"\n if data.get('health_check'):\n self.state_update_result.emit({'health_check': True})\n return\n\n with QMutexLocker(self._cache_mutex):\n current_state = self.cache['state']\n weights = self.cache['weights']\n excluded = self.cache['excluded_neurons']\n\n updated_state = {}\n \n # PURE_INPUTS (Sensors) - Do not decay these\n PURE_INPUTS = {\n \"can_see_food\", \"is_eating\", \"is_sleeping\", \"is_sick\", \n \"pursuing_food\", \"is_fleeing\", \"is_startled\", \"external_stimulus\", \n \"plant_proximity\"\n }\n\n # 1. Decay and Noise\n for neuron, val in current_state.items():\n if neuron in excluded or neuron in PURE_INPUTS:\n continue\n \n # Simple decay towards baseline\n if isinstance(val, (int, float)):\n # Decay factor\n decay = 0.95 \n noise = random.uniform(-0.5, 0.5)\n \n new_val = val * decay + noise\n updated_state[neuron] = new_val\n\n # 2. Connection effects (Simplified delta calculation)\n connection_deltas = {}\n \n for (src, dst), w in weights.items():\n if src in current_state and dst in current_state:\n if dst in PURE_INPUTS: continue\n \n src_val = current_state[src]\n if isinstance(src_val, (int, float)):\n effect = src_val * w * 0.1 # Small timestep factor\n connection_deltas[dst] = connection_deltas.get(dst, 0) + effect\n \n # Apply deltas\n for neuron, delta in connection_deltas.items():\n if neuron in updated_state:\n updated_state[neuron] += delta\n elif neuron in current_state and neuron not in PURE_INPUTS:\n updated_state[neuron] = current_state[neuron] + delta\n\n # Clamp\n final_state = {}\n for k, v in updated_state.items():\n final_state[k] = max(-100, min(100, v))\n\n self.state_update_result.emit({'processed_state': final_state})\n\n def _get_neuron_value(self, val):\n if isinstance(val, (int, float)):\n return float(val)\n if isinstance(val, bool):\n return 100.0 if val else 0.0\n return 0.0"
},
{
"path": "src/certificate.py",
"content": "\"\"\"\r\nOld feature, currently unused - for future reimplementation\r\n\r\nGenerate a certificate with top statistics\r\n\"\"\"\r\n\r\n\r\nimport datetime\r\nfrom PyQt5 import QtCore, QtGui, QtWidgets\r\n\r\nclass SquidCertificateWindow(QtWidgets.QDialog):\r\n def __init__(self, parent=None, tamagotchi_logic=None):\r\n super().__init__(parent)\r\n self.tamagotchi_logic = tamagotchi_logic\r\n self.setWindowTitle(\"Squid Certificate\")\r\n self.setMinimumSize(800, 1000) # Increased minimum size\r\n \r\n layout = QtWidgets.QVBoxLayout(self)\r\n \r\n self.certificate_view = QtWidgets.QTextBrowser()\r\n self.certificate_view.setOpenExternalLinks(False)\r\n layout.addWidget(self.certificate_view)\r\n \r\n # Add print button with larger text\r\n print_button = QtWidgets.QPushButton(\"Print Certificate\")\r\n print_button.setStyleSheet(\"font-size: 18px; padding: 10px;\")\r\n print_button.clicked.connect(self.print_certificate)\r\n layout.addWidget(print_button, alignment=QtCore.Qt.AlignRight)\r\n \r\n self.update_certificate()\r\n \r\n def update_certificate(self):\r\n if not self.tamagotchi_logic or not self.tamagotchi_logic.squid:\r\n return\r\n \r\n squid = self.tamagotchi_logic.squid\r\n current_date = datetime.datetime.now().strftime(\"%B %d, %Y\")\r\n personality = str(squid.personality).split('.')[-1].lower().capitalize()\r\n squid_name = getattr(squid, 'name', 'Squid')\r\n \r\n certificate_html = f\"\"\"\r\n \r\n \r\n \r\n \r\n \r\n
\r\n
\r\n
Certificate of Squidship
\r\n
Presented by the International Dosidicus Society
\r\n
\r\n \r\n
\r\n
This certifies that
\r\n
{squid_name}
\r\n
is an officially recognized Dosidicus electronicae of the
\r\n
{personality} Personality Type
\r\n
\r\n \r\n
\r\n
Statistics
\r\n
\r\n
\r\n
Happiness: {squid.happiness}/100
\r\n
Hunger: {squid.hunger}/100
\r\n
\r\n
\r\n
Cleanliness: {squid.cleanliness}/100
\r\n
Sleepiness: {squid.sleepiness}/100
\r\n
\r\n
\r\n
Anxiety: {squid.anxiety}/100
\r\n
Curiosity: {squid.curiosity}/100
\r\n
\r\n
\r\n
\r\n \r\n
\r\n
Achievements:
\r\n
\r\n
Successfully hatched a squid
\r\n
Fed the squid over 10 times
\r\n
Reached a happiness level above 80
\r\n
Survived a difficult situation
\r\n
\r\n
\r\n \r\n
\r\n
Issued on this day, {current_date}
\r\n
OFFICIAL
\r\n
\r\n
\r\n \r\n \r\n \"\"\"\r\n \r\n self.certificate_view.setHtml(certificate_html)\r\n \r\n def print_certificate(self):\r\n from PyQt5 import QtPrintSupport\r\n printer = QtPrintSupport.QPrinter(QtPrintSupport.QPrinter.HighResolution)\r\n dialog = QtPrintSupport.QPrintDialog(printer, self)\r\n if dialog.exec_() == QtWidgets.QDialog.Accepted:\r\n self.certificate_view.print_(printer)\r\n"
},
{
"path": "src/compute_backend.py",
"content": "\"\"\"\r\nOptional NPU / AI Accelerator support via ONNX Runtime\r\n===========================================================================\r\n\r\nA thin abstraction over the core matrix operations used by the\r\nbrain engine (forward pass MatMul, Hebbian outer-product update, zeros\r\ninitialisation) so that an ONNX Runtime execution provider can be dropped\r\nin without touching the rest of the codebase.\r\n\r\nBackend selection\r\n-----------------\r\nSet [Compute] backend = onnx in config.ini to enable ONNX.\r\nLeave as backend = numpy (or omit the section entirely) for the default\r\nNumPy path. ONNX silently falls back to NumPy if onnxruntime is not\r\ninstalled.\r\n\r\nPublic API\r\n----------\r\n get_backend(backend_name=None) → ComputeBackend instance (singleton)\r\n\r\nComputeBackend methods used by brain_widget / brain_worker:\r\n .zeros(shape) → ndarray-compatible 2-D matrix\r\n .forward(weights_matrix, inputs) → 1-D result of weights @ inputs\r\n .hebbian(associations, sample, lr) → updated associations matrix\r\n .get_value(matrix, i, j) → float scalar\r\n\r\nAuthor note: dynamic neurogenesis is supported because the ONNX MatMul\r\ngraph is rebuilt whenever the network shape changes.\r\n\"\"\"\r\n\r\nfrom __future__ import annotations\r\n\r\n# ---------------------------------------------------------------------------\r\n# Base class\r\n# ---------------------------------------------------------------------------\r\n\r\nclass ComputeBackend:\r\n \"\"\"Abstract base class for compute backends.\"\"\"\r\n\r\n def zeros(self, shape: tuple):\r\n \"\"\"Return a zero-filled matrix of *shape* compatible with this backend.\"\"\"\r\n raise NotImplementedError\r\n\r\n def forward(self, weights_matrix, inputs):\r\n \"\"\"Dense matrix-vector product: result = weights_matrix @ inputs.\"\"\"\r\n raise NotImplementedError\r\n\r\n def hebbian(self, associations, sample: list, learning_rate: float):\r\n \"\"\"\r\n Hebbian outer-product update applied to *associations* in place.\r\n\r\n For each pair (i, j) where i < j:\r\n associations[i][j] += learning_rate * sample[i] * sample[j]\r\n associations[j][i] = associations[i][j] (keep symmetric)\r\n\r\n Returns the updated associations matrix.\r\n \"\"\"\r\n raise NotImplementedError\r\n\r\n def get_value(self, matrix, i: int, j: int) -> float:\r\n \"\"\"Return matrix[i][j] as a plain Python float.\"\"\"\r\n raise NotImplementedError\r\n\r\n @property\r\n def name(self) -> str:\r\n raise NotImplementedError\r\n\r\n\r\n# ---------------------------------------------------------------------------\r\n# NumPy backend (default, always available)\r\n# ---------------------------------------------------------------------------\r\n\r\nclass NumpyBackend(ComputeBackend):\r\n \"\"\"\r\n Default compute backend. Uses NumPy for all operations – identical\r\n behaviour to the pre-integration codebase.\r\n \"\"\"\r\n\r\n def __init__(self):\r\n import numpy as _np # already a project dependency\r\n self._np = _np\r\n print(\"🧠 Compute backend: NumPy\")\r\n\r\n # --- ComputeBackend interface -------------------------------------------\r\n\r\n def zeros(self, shape: tuple):\r\n return self._np.zeros(shape)\r\n\r\n def forward(self, weights_matrix, inputs):\r\n return weights_matrix @ inputs\r\n\r\n def hebbian(self, associations, sample: list, learning_rate: float):\r\n np = self._np\r\n arr = np.array(sample, dtype=np.float64)\r\n delta = np.outer(arr, arr) * learning_rate\r\n n = len(sample)\r\n for i in range(n):\r\n for j in range(i + 1, n):\r\n associations[i][j] += delta[i][j]\r\n associations[j][i] = associations[i][j]\r\n return associations\r\n\r\n def get_value(self, matrix, i: int, j: int) -> float:\r\n return float(matrix[i][j])\r\n\r\n @property\r\n def name(self) -> str:\r\n return \"numpy\"\r\n\r\n\r\n# ---------------------------------------------------------------------------\r\n# ONNX Runtime backend (optional)\r\n# ---------------------------------------------------------------------------\r\n\r\nclass ONNXBackend(ComputeBackend):\r\n \"\"\"\r\n Optional ONNX Runtime backend.\r\n\r\n * Lazy-imports onnx and onnxruntime so Dosidicus starts fine even\r\n when neither package is installed.\r\n * Automatically selects the best available execution provider:\r\n DirectML → AMD / Intel / NVIDIA via Windows ML (NPU-capable)\r\n OpenVINO → Intel NPU\r\n QNN → Qualcomm Snapdragon X\r\n CPU → universal fallback\r\n * Rebuilds the ONNX MatMul graph whenever the network shape changes,\r\n which means dynamic neurogenesis is fully supported.\r\n * Falls back to NumPy arithmetic internally for the Hebbian update\r\n (the association matrix is small; ONNX overhead would dominate).\r\n \"\"\"\r\n\r\n # Execution-provider preference order\r\n _PROVIDER_PRIORITY = [\r\n 'QNNExecutionProvider', # Qualcomm Snapdragon X Elite NPU\r\n 'DmlExecutionProvider', # DirectML (AMD XDNA, Intel Arc, NVIDIA)\r\n 'OpenVINOExecutionProvider', # Intel NPU / iGPU\r\n 'CPUExecutionProvider', # Always available\r\n ]\r\n\r\n def __init__(self):\r\n self._available = False\r\n self._session = None\r\n self._last_shape = None\r\n self._provider = 'CPUExecutionProvider'\r\n self._np = None\r\n\r\n try:\r\n import numpy as np\r\n import onnx # noqa: F401 (confirms package present)\r\n import onnxruntime as ort\r\n\r\n self._np = np\r\n self._ort = ort\r\n\r\n available_providers = ort.get_available_providers()\r\n for pref in self._PROVIDER_PRIORITY:\r\n if pref in available_providers:\r\n self._provider = pref\r\n break\r\n\r\n self._available = True\r\n print(f\"🧠 Compute backend: ONNX Runtime [{self._provider}]\")\r\n print(f\" Available providers: {available_providers}\")\r\n\r\n except ImportError as exc:\r\n print(f\"⚠️ ONNX Runtime not available ({exc}).\")\r\n print(\" Falling back to NumPy backend. \"\r\n \"Install 'onnxruntime' (or 'onnxruntime-directml') to enable NPU support.\")\r\n\r\n # --- Internal helpers ---------------------------------------------------\r\n\r\n def _build_session(self, rows: int, cols: int):\r\n \"\"\"\r\n Build (or rebuild) an ONNX MatMul session for a (rows, cols) weight\r\n matrix applied to a cols-element input vector → rows-element output.\r\n\r\n Called automatically from forward() when the shape changes.\r\n \"\"\"\r\n from onnx import helper, TensorProto\r\n\r\n W = helper.make_tensor_value_info('weights', TensorProto.FLOAT, [rows, cols])\r\n V = helper.make_tensor_value_info('inputs', TensorProto.FLOAT, [cols])\r\n Y = helper.make_tensor_value_info('output', TensorProto.FLOAT, [rows])\r\n\r\n node = helper.make_node('MatMul', inputs=['weights', 'inputs'], outputs=['output'])\r\n graph = helper.make_graph([node], 'dosidicus_forward', [W, V], [Y])\r\n model = helper.make_model(\r\n graph,\r\n opset_imports=[helper.make_opsetid('', 17)]\r\n )\r\n\r\n model_bytes = model.SerializeToString()\r\n\r\n sess_opts = self._ort.SessionOptions()\r\n sess_opts.log_severity_level = 3 # suppress verbose ONNX logs\r\n\r\n self._session = self._ort.InferenceSession(\r\n model_bytes,\r\n sess_options=sess_opts,\r\n providers=[self._provider, 'CPUExecutionProvider']\r\n )\r\n self._last_shape = (rows, cols)\r\n\r\n # --- ComputeBackend interface -------------------------------------------\r\n\r\n def zeros(self, shape: tuple):\r\n return self._np.zeros(shape)\r\n\r\n def forward(self, weights_matrix, inputs):\r\n if not self._available:\r\n # Transparent NumPy fallback\r\n return weights_matrix @ inputs\r\n\r\n np = self._np\r\n w = np.array(weights_matrix, dtype=np.float32)\r\n v = np.array(inputs, dtype=np.float32)\r\n\r\n rows, cols = w.shape\r\n if (rows, cols) != self._last_shape:\r\n # Network topology changed (neurogenesis) → rebuild graph\r\n self._build_session(rows, cols)\r\n\r\n result = self._session.run(['output'], {'weights': w, 'inputs': v})\r\n return result[0]\r\n\r\n def hebbian(self, associations, sample: list, learning_rate: float):\r\n \"\"\"\r\n For the Hebbian update we stay in NumPy.\r\n The association matrix is small (N × N where N ≈ 10–100 neurons);\r\n the ONNX round-trip cost far exceeds the compute benefit at this size.\r\n \"\"\"\r\n np = self._np\r\n arr = np.array(sample, dtype=np.float64)\r\n delta = np.outer(arr, arr) * learning_rate\r\n n = len(sample)\r\n for i in range(n):\r\n for j in range(i + 1, n):\r\n associations[i][j] += delta[i][j]\r\n associations[j][i] = associations[i][j]\r\n return associations\r\n\r\n def get_value(self, matrix, i: int, j: int) -> float:\r\n return float(matrix[i][j])\r\n\r\n @property\r\n def name(self) -> str:\r\n if self._available:\r\n return f\"onnx [{self._provider}]\"\r\n return \"numpy (onnx unavailable)\"\r\n\r\n\r\n# ---------------------------------------------------------------------------\r\n# Factory / singleton\r\n# ---------------------------------------------------------------------------\r\n\r\n_backend_instance: ComputeBackend | None = None\r\n\r\n\r\ndef get_backend(backend_name: str | None = None) -> ComputeBackend:\r\n \"\"\"\r\n Return the (singleton) compute backend.\r\n\r\n backend_name : 'numpy' | 'onnx'\r\n If None, reads [Compute] backend from config.ini.\r\n Defaults to 'numpy' if the section / key is absent.\r\n\r\n The ONNX backend silently falls back to NumPy if onnxruntime is not\r\n installed, so callers never need to guard against ImportError.\r\n \"\"\"\r\n global _backend_instance\r\n if _backend_instance is not None:\r\n return _backend_instance\r\n\r\n if backend_name is None:\r\n backend_name = _read_backend_from_config()\r\n\r\n backend_name = backend_name.strip().lower()\r\n\r\n if backend_name == 'onnx':\r\n candidate = ONNXBackend()\r\n # If ONNX packages are missing, silently use NumPy\r\n _backend_instance = candidate if candidate._available else NumpyBackend()\r\n else:\r\n _backend_instance = NumpyBackend()\r\n\r\n return _backend_instance\r\n\r\n\r\ndef reset_backend():\r\n \"\"\"Force re-initialisation on next get_backend() call (useful for tests).\"\"\"\r\n global _backend_instance\r\n _backend_instance = None\r\n\r\n\r\n# ---------------------------------------------------------------------------\r\n# Config reader (standalone – avoids circular import with config_manager)\r\n# ---------------------------------------------------------------------------\r\n\r\ndef _read_backend_from_config() -> str:\r\n \"\"\"Read [Compute] backend from config.ini, returns 'numpy' on any error.\"\"\"\r\n try:\r\n import configparser\r\n import os\r\n import sys\r\n\r\n config = configparser.ConfigParser()\r\n\r\n if getattr(sys, 'frozen', False):\r\n base_path = os.path.dirname(sys.executable)\r\n else:\r\n # __file__ is src/compute_backend.py → go up one level\r\n src_dir = os.path.dirname(os.path.abspath(__file__))\r\n base_path = os.path.dirname(src_dir)\r\n\r\n config_path = os.path.join(base_path, 'config.ini')\r\n config.read(config_path)\r\n return config.get('Compute', 'backend', fallback='numpy')\r\n\r\n except Exception:\r\n return 'numpy'\r\n"
},
{
"path": "src/config_manager.py",
"content": "import configparser\r\nimport os\r\nimport random\r\nimport sys\r\nfrom PyQt5 import QtCore\r\nfrom ast import literal_eval\r\n\r\nclass ConfigManager:\r\n \"\"\"\r\n Configuration manager for Dosidicus-2.\r\n \r\n Handles loading/saving of config.ini and provides typed accessors\r\n for all configuration values including animation styles.\r\n \"\"\"\r\n \r\n # Available animation styles - UPDATED to include all styles\r\n ANIMATION_STYLES = ['vibrant', 'subtle', 'neural', 'none', 'electric', 'zen', 'neon']\r\n \r\n def __init__(self, config_filename=\"config.ini\"):\r\n # Check if we are running as a frozen executable (Auto-Py-To-Exe)\r\n if getattr(sys, 'frozen', False):\r\n # If frozen, the config file should be next to the .exe\r\n base_path = os.path.dirname(sys.executable)\r\n else:\r\n # If running from source (Dev), we are in /src/config_manager.py\r\n # So we need to go up one level to find config.ini\r\n current_dir = os.path.dirname(os.path.abspath(__file__))\r\n base_path = os.path.dirname(current_dir) # Go up to parent folder\r\n\r\n self.config_path = os.path.join(base_path, config_filename)\r\n \r\n self.config = configparser.ConfigParser()\r\n self.load_config()\r\n\r\n def load_config(self):\r\n if not os.path.exists(self.config_path):\r\n self.create_default_config()\r\n self.config.read(self.config_path)\r\n\r\n def create_default_config(self):\r\n \r\n self.config['General'] = {\r\n 'language': 'en'\r\n }\r\n\r\n # Debug section\r\n self.config['Debug'] = {\r\n 'multiplayer_debug': 'False'\r\n }\r\n\r\n # Rock Interactions\r\n self.config['RockInteractions'] = {\r\n 'pickup_probability': '0.7',\r\n 'throw_probability': '0.4',\r\n 'min_carry_duration': '4.0',\r\n 'max_carry_duration': '10.0',\r\n 'cooldown_after_throw': '10.0',\r\n 'happiness_boost': '9',\r\n 'satisfaction_boost': '11',\r\n 'anxiety_reduction': '9',\r\n 'memory_decay_rate': '0.98',\r\n 'max_rock_memories': '10'\r\n }\r\n\r\n # Poop Interactions - NEW SECTION\r\n self.config['PoopInteractions'] = {\r\n 'pickup_probability': '0.2',\r\n 'throw_probability': '0.3',\r\n 'min_carry_duration': '2.0',\r\n 'max_carry_duration': '9.0',\r\n 'cooldown_after_throw': '10.0',\r\n }\r\n\r\n # Decorations Message System - NEW SECTION\r\n self.config['Decorations'] = {\r\n 'message_enabled': 'True',\r\n 'message_max_shows': '3',\r\n 'message_min_interval': '120.0', # 2 minutes in seconds\r\n 'message_max_interval': '300.0' # 5 minutes in seconds\r\n }\r\n\r\n # Neurogenesis\r\n self.config['Neurogenesis'] = {\r\n 'enabled': 'True',\r\n 'showmanship': 'True',\r\n 'pruning_enabled': 'True', # NEW KEY\r\n 'cooldown': '60.0',\r\n 'per_type_cooldown': '30.0',\r\n 'max_novelty_neurons': '5', # NEW KEY\r\n 'pattern_threshold': '3', # NEW KEY\r\n 'experience_buffer_size': '30', # NEW KEY\r\n 'min_utility_for_keep': '0.2', # NEW KEY\r\n 'max_neurons': '100',\r\n 'initial_neuron_count': '7',\r\n 'max_hebbian_pairs': '2'\r\n }\r\n\r\n # Specialist Neuron Cap (Important!)\r\n self.config['Neurogenesis.SpecialisationCaps'] = {\r\n 'novelty_object_investigation': '8',\r\n }\r\n\r\n # Neurogenesis Triggers\r\n self.config['Neurogenesis.Novelty'] = {\r\n 'enabled': 'True',\r\n 'threshold': '3.0',\r\n 'decay_rate': '0.85',\r\n 'max_counter': '10.0',\r\n 'min_curiosity': '0.3',\r\n 'adventurous_modifier': '1.2',\r\n 'timid_modifier': '0.8'\r\n }\r\n\r\n self.config['Neurogenesis.Stress'] = {\r\n 'enabled': 'True',\r\n 'threshold': '2.0',\r\n 'decay_rate': '0.85',\r\n 'max_counter': '10.0',\r\n 'min_anxiety': '0.4',\r\n 'timid_modifier': '1.5',\r\n 'energetic_modifier': '0.7'\r\n }\r\n\r\n self.config['Neurogenesis.Reward'] = {\r\n 'enabled': 'True',\r\n 'threshold': '2.5',\r\n 'decay_rate': '0.85',\r\n 'max_counter': '8.0',\r\n 'min_satisfaction': '0.5',\r\n 'boost_multiplier': '1.1'\r\n }\r\n\r\n # Neuron Properties\r\n self.config['Neurogenesis.NeuronProperties'] = {\r\n 'base_activation': '0.5',\r\n 'position_variance': '75',\r\n 'default_connections': 'True',\r\n 'connection_strength': '0.35',\r\n 'reciprocal_strength': '0.15',\r\n 'randomize_start_positions': 'True', # NEW KEY\r\n 'canvas_padding': '60', # NEW KEY\r\n 'centering_force': '0.02', # NEW KEY\r\n 'force_bounds': 'True' # NEW KEY\r\n }\r\n\r\n # Appearance\r\n self.config['Neurogenesis.Appearance'] = {\r\n 'novelty_color': '255,255,150',\r\n 'stress_color': '255,150,150',\r\n 'reward_color': '150,255,150',\r\n 'novelty_shape': 'triangle',\r\n 'stress_shape': 'square',\r\n 'reward_shape': 'circle'\r\n }\r\n\r\n # Visual Effects\r\n self.config['Neurogenesis.VisualEffects'] = {\r\n 'highlight_duration': '5.0',\r\n 'highlight_radius': '40',\r\n 'pulse_effect': 'True',\r\n 'pulse_speed': '0.5',\r\n 'animation_style': 'pattern_1' # NEW KEY\r\n }\r\n\r\n # Hebbian Learning - NEW SECTION\r\n self.config['Hebbian'] = {\r\n 'learning_interval': '30',\r\n 'base_learning_rate': '0.1',\r\n 'weight_decay': '0.01',\r\n 'min_weight': '-1.0',\r\n 'max_weight': '1.0',\r\n 'max_hebbian_pairs': '2'\r\n }\r\n\r\n # Link Blink - NEW SECTION\r\n self.config['LinkBlink'] = {\r\n 'interval_min': '8.0',\r\n 'interval_max': '20.0',\r\n 'blink_duration': '2.0'\r\n }\r\n\r\n # ---------- ANIMATION STYLES ----------\r\n # All animation style configurations - UPDATED\r\n self.config['Animation'] = {\r\n 'style': 'vibrant'\r\n }\r\n\r\n self.config['Animation.Electric'] = {\r\n 'use_thick_lines': 'True',\r\n 'line_base_width': '2.5',\r\n 'line_colour_positive': '0,255,255',\r\n 'line_colour_negative': '255,0,255',\r\n 'line_alpha': '255'\r\n }\r\n\r\n self.config['Animation.Zen'] = {\r\n 'use_thick_lines': 'False',\r\n 'line_base_width': '1.0',\r\n 'line_colour_positive': '60,60,60',\r\n 'line_colour_negative': '120,120,120',\r\n 'line_alpha': '120'\r\n }\r\n\r\n self.config['Animation.Neon'] = {\r\n 'use_thick_lines': 'True',\r\n 'line_base_width': '1.8',\r\n 'line_colour_positive': '0,255,120',\r\n 'line_colour_negative': '255,50,205',\r\n 'line_alpha': '240'\r\n }\r\n\r\n # Display Settings\r\n self.config['Display'] = {\r\n 'neuron_label_font_size': '8',\r\n 'neuron_radius': '14', # Updated to match current default\r\n 'connection_line_width': '1.5',\r\n 'button_font_size': '16',\r\n 'button_width': '140',\r\n 'button_height': '50',\r\n 'button_spacing': '20'\r\n }\r\n\r\n # Designer Settings\r\n self.config['Designer'] = {\r\n 'designer_min_neuron_distance': '100',\r\n 'designer_max_neuron_distance': '600'\r\n }\r\n\r\n with open(self.config_path, 'w') as f:\r\n self.config.write(f)\r\n\r\n def get_hebbian_pairs_per_cycle(self):\r\n \"\"\"Return the number of neuron pairs that should be updated each Hebbian cycle.\"\"\"\r\n # Check Hebbian section first, fallback to Neurogenesis\r\n if self.config.has_section('Hebbian'):\r\n return self.config.getint('Hebbian', 'max_hebbian_pairs', fallback=2)\r\n return self.config.getint('Neurogenesis', 'max_hebbian_pairs', fallback=2)\r\n\r\n def get_showmanship_enabled(self):\r\n \"\"\"Return whether showmanship (dramatic neuron creation) is enabled.\r\n \r\n When enabled, the ShowmanNeurogenesis wrapper will create neurons\r\n during dramatic moments even if normal thresholds aren't met.\r\n When disabled, only the base EnhancedNeurogenesis logic applies.\r\n \"\"\"\r\n return self.config.getboolean('Neurogenesis', 'showmanship', fallback=True)\r\n\r\n\r\n def get_facts_enabled(self):\r\n return self.config.getboolean('Facts', 'enabled', fallback=True)\r\n\r\n def get_fact_interval_ms(self):\r\n mins = self.config.getint('Facts', 'interval_minutes', fallback=5)\r\n return mins * 60 * 1000\r\n\r\n def get_fact_display_ms(self):\r\n secs = self.config.getint('Facts', 'display_seconds', fallback=18)\r\n return secs * 1000\r\n\r\n def get_rock_config(self):\r\n return {\r\n 'pickup_prob': float(self.config['RockInteractions']['pickup_probability']),\r\n 'throw_prob': float(self.config['RockInteractions']['throw_probability']),\r\n 'min_carry_duration': float(self.config['RockInteractions']['min_carry_duration']),\r\n 'max_carry_duration': float(self.config['RockInteractions']['max_carry_duration']),\r\n 'cooldown_after_throw': float(self.config['RockInteractions']['cooldown_after_throw']),\r\n 'happiness_boost': int(self.config['RockInteractions']['happiness_boost']),\r\n 'satisfaction_boost': int(self.config['RockInteractions']['satisfaction_boost']),\r\n 'anxiety_reduction': int(self.config['RockInteractions']['anxiety_reduction']),\r\n 'memory_decay_rate': float(self.config['RockInteractions']['memory_decay_rate']),\r\n 'max_rock_memories': int(self.config['RockInteractions']['max_rock_memories'])\r\n }\r\n \r\n def get_poop_config(self):\r\n \"\"\"NEW METHOD: Get poop interaction configuration\"\"\"\r\n # Fallback dictionary in case section is missing\r\n defaults = {\r\n 'pickup_prob': 0.2,\r\n 'throw_prob': 0.3,\r\n 'min_carry_duration': 2.0,\r\n 'max_carry_duration': 9.0,\r\n 'cooldown_after_throw': 10.0,\r\n }\r\n\r\n if self.config.has_section('PoopInteractions'):\r\n section = self.config['PoopInteractions']\r\n return {\r\n 'pickup_prob': float(section.get('pickup_probability', defaults['pickup_prob'])),\r\n 'throw_prob': float(section.get('throw_probability', defaults['throw_prob'])),\r\n 'min_carry_duration': float(section.get('min_carry_duration', defaults['min_carry_duration'])),\r\n 'max_carry_duration': float(section.get('max_carry_duration', defaults['max_carry_duration'])),\r\n 'cooldown_after_throw': float(section.get('cooldown_after_throw', defaults['cooldown_after_throw']))\r\n }\r\n return defaults\r\n \r\n def get_decorations_config(self):\r\n \"\"\"NEW METHOD: Get decorations message system configuration\"\"\"\r\n return {\r\n 'message_enabled': self.config.getboolean('Decorations', 'message_enabled', fallback=True),\r\n 'message_max_shows': self.config.getint('Decorations', 'message_max_shows', fallback=3),\r\n 'message_min_interval': self.config.getfloat('Decorations', 'message_min_interval', fallback=120.0),\r\n 'message_max_interval': self.config.getfloat('Decorations', 'message_max_interval', fallback=300.0)\r\n }\r\n \r\n def get_specialisation_caps(self):\r\n \"\"\"Return dict {specialisation_name: int_max}\"\"\"\r\n caps = {}\r\n if self.config.has_section('Neurogenesis.SpecialisationCaps'):\r\n for spec, val in self.config.items('Neurogenesis.SpecialisationCaps'):\r\n caps[spec] = int(val)\r\n return caps\r\n\r\n def get_neurogenesis_config(self):\r\n \"\"\"Returns the complete neurogenesis configuration as a dictionary\"\"\"\r\n return {\r\n 'general': {\r\n 'enabled': self.config.getboolean('Neurogenesis', 'enabled', fallback=True),\r\n 'showmanship': self.config.getboolean('Neurogenesis', 'showmanship', fallback=True),\r\n 'pruning_enabled': self.config.getboolean('Neurogenesis', 'pruning_enabled', fallback=True), # NEW KEY\r\n 'cooldown': self.config.getfloat('Neurogenesis', 'cooldown', fallback=60.0),\r\n 'per_type_cooldown': self.config.getfloat('Neurogenesis', 'per_type_cooldown', fallback=30.0),\r\n 'max_novelty_neurons': self.config.getint('Neurogenesis', 'max_novelty_neurons', fallback=5), # NEW KEY\r\n 'pattern_threshold': self.config.getint('Neurogenesis', 'pattern_threshold', fallback=3), # NEW KEY\r\n 'experience_buffer_size': self.config.getint('Neurogenesis', 'experience_buffer_size', fallback=30), # NEW KEY\r\n 'min_utility_for_keep': self.config.getfloat('Neurogenesis', 'min_utility_for_keep', fallback=0.2), # NEW KEY\r\n 'max_neurons': self.config.getint('Neurogenesis', 'max_neurons', fallback=100),\r\n 'initial_neuron_count': self.config.getint('Neurogenesis', 'initial_neuron_count', fallback=7),\r\n 'max_hebbian_pairs': self.config.getint('Neurogenesis', 'max_hebbian_pairs', fallback=2)\r\n },\r\n 'triggers': {\r\n 'novelty': {\r\n 'enabled': self.config.getboolean('Neurogenesis.Novelty', 'enabled', fallback=True),\r\n 'threshold': self.config.getfloat('Neurogenesis.Novelty', 'threshold', fallback=3.0),\r\n 'decay_rate': self.config.getfloat('Neurogenesis.Novelty', 'decay_rate', fallback=0.85),\r\n 'max_counter': self.config.getfloat('Neurogenesis.Novelty', 'max_counter', fallback=10.0),\r\n 'min_curiosity': self.config.getfloat('Neurogenesis.Novelty', 'min_curiosity', fallback=0.3),\r\n 'personality_modifiers': {\r\n 'adventurous': self.config.getfloat('Neurogenesis.Novelty', 'adventurous_modifier', fallback=1.2),\r\n 'timid': self.config.getfloat('Neurogenesis.Novelty', 'timid_modifier', fallback=0.8)\r\n }\r\n },\r\n 'stress': {\r\n 'enabled': self.config.getboolean('Neurogenesis.Stress', 'enabled', fallback=True),\r\n 'threshold': self.config.getfloat('Neurogenesis.Stress', 'threshold', fallback=2.0),\r\n 'decay_rate': self.config.getfloat('Neurogenesis.Stress', 'decay_rate', fallback=0.85),\r\n 'max_counter': self.config.getfloat('Neurogenesis.Stress', 'max_counter', fallback=10.0),\r\n 'min_anxiety': self.config.getfloat('Neurogenesis.Stress', 'min_anxiety', fallback=0.4),\r\n 'personality_modifiers': {\r\n 'timid': self.config.getfloat('Neurogenesis.Stress', 'timid_modifier', fallback=1.5),\r\n 'energetic': self.config.getfloat('Neurogenesis.Stress', 'energetic_modifier', fallback=0.7)\r\n }\r\n },\r\n 'reward': {\r\n 'enabled': self.config.getboolean('Neurogenesis.Reward', 'enabled', fallback=True),\r\n 'threshold': self.config.getfloat('Neurogenesis.Reward', 'threshold', fallback=2.5),\r\n 'decay_rate': self.config.getfloat('Neurogenesis.Reward', 'decay_rate', fallback=0.85),\r\n 'max_counter': self.config.getfloat('Neurogenesis.Reward', 'max_counter', fallback=8.0),\r\n 'min_satisfaction': self.config.getfloat('Neurogenesis.Reward', 'min_satisfaction', fallback=0.5),\r\n 'boost_multiplier': self.config.getfloat('Neurogenesis.Reward', 'boost_multiplier', fallback=1.1)\r\n }\r\n },\r\n 'neuron_properties': {\r\n 'base_activation': self.config.getfloat('Neurogenesis.NeuronProperties', 'base_activation', fallback=0.5),\r\n 'position_variance': self.config.getint('Neurogenesis.NeuronProperties', 'position_variance', fallback=75),\r\n 'default_connections': self.config.getboolean('Neurogenesis.NeuronProperties', 'default_connections', fallback=True),\r\n 'connection_strength': self.config.getfloat('Neurogenesis.NeuronProperties', 'connection_strength', fallback=0.35),\r\n 'reciprocal_strength': self.config.getfloat('Neurogenesis.NeuronProperties', 'reciprocal_strength', fallback=0.15),\r\n 'randomize_start_positions': self.config.getboolean('Neurogenesis.NeuronProperties', 'randomize_start_positions', fallback=True), # NEW KEY\r\n 'canvas_padding': self.config.getint('Neurogenesis.NeuronProperties', 'canvas_padding', fallback=60), # NEW KEY\r\n 'centering_force': self.config.getfloat('Neurogenesis.NeuronProperties', 'centering_force', fallback=0.02), # NEW KEY\r\n 'force_bounds': self.config.getboolean('Neurogenesis.NeuronProperties', 'force_bounds', fallback=True) # NEW KEY\r\n },\r\n 'designer': {\r\n 'min_neuron_distance': self.config.getint('Designer', 'designer_min_neuron_distance', fallback=100),\r\n 'max_neuron_distance': self.config.getint('Designer', 'designer_max_neuron_distance', fallback=600)\r\n },\r\n 'appearance': {\r\n 'colors': {\r\n 'novelty': [int(x) for x in self.config.get('Neurogenesis.Appearance', 'novelty_color', fallback='255,255,150').split(',')],\r\n 'stress': [int(x) for x in self.config.get('Neurogenesis.Appearance', 'stress_color', fallback='255,150,150').split(',')],\r\n 'reward': [int(x) for x in self.config.get('Neurogenesis.Appearance', 'reward_color', fallback='150,255,150').split(',')]\r\n },\r\n 'shapes': {\r\n 'novelty': self.config.get('Neurogenesis.Appearance', 'novelty_shape', fallback='triangle'),\r\n 'stress': self.config.get('Neurogenesis.Appearance', 'stress_shape', fallback='square'),\r\n 'reward': self.config.get('Neurogenesis.Appearance', 'reward_shape', fallback='circle')\r\n }\r\n },\r\n 'visual_effects': {\r\n 'highlight_duration': self.config.getfloat('Neurogenesis.VisualEffects', 'highlight_duration', fallback=5.0),\r\n 'highlight_radius': self.config.getint('Neurogenesis.VisualEffects', 'highlight_radius', fallback=40),\r\n 'pulse_effect': self.config.getboolean('Neurogenesis.VisualEffects', 'pulse_effect', fallback=True),\r\n 'pulse_speed': self.config.getfloat('Neurogenesis.VisualEffects', 'pulse_speed', fallback=0.5),\r\n 'animation_style': self.config.get('Neurogenesis.VisualEffects', 'animation_style', fallback='pattern_1') # NEW KEY\r\n }\r\n }\r\n\r\n def get_hebbian_config(self):\r\n \"\"\"NEW METHOD: Get Hebbian learning configuration\"\"\"\r\n return {\r\n 'learning_interval': self.config.getint('Hebbian', 'learning_interval', fallback=30),\r\n 'base_learning_rate': self.config.getfloat('Hebbian', 'base_learning_rate', fallback=0.1),\r\n 'weight_decay': self.config.getfloat('Hebbian', 'weight_decay', fallback=0.01),\r\n 'min_weight': self.config.getfloat('Hebbian', 'min_weight', fallback=-1.0),\r\n 'max_weight': self.config.getfloat('Hebbian', 'max_weight', fallback=1.0),\r\n 'max_hebbian_pairs': self.config.getint('Hebbian', 'max_hebbian_pairs', fallback=2)\r\n }\r\n\r\n def get_linkblink_config(self):\r\n \"\"\"NEW METHOD: Get link blink animation configuration\"\"\"\r\n return {\r\n 'interval_min': self.config.getfloat('LinkBlink', 'interval_min', fallback=8.0),\r\n 'interval_max': self.config.getfloat('LinkBlink', 'interval_max', fallback=20.0),\r\n 'blink_duration': self.config.getfloat('LinkBlink', 'blink_duration', fallback=2.0)\r\n }\r\n\r\n def get_random_carry_duration(self):\r\n \"\"\"Returns random duration between min and max carry duration\"\"\"\r\n config = self.get_rock_config()\r\n return random.uniform(config['min_carry_duration'], config['max_carry_duration'])\r\n\r\n def _parse_config_value(self, value):\r\n \"\"\"Parse configuration values that might contain comments\"\"\"\r\n # Remove everything after comment markers\r\n for comment_marker in [';', '#', '//']:\r\n if comment_marker in value:\r\n value = value.split(comment_marker)[0]\r\n \r\n value = value.strip()\r\n \r\n # Try to convert to appropriate type\r\n if value.lower() == 'true':\r\n return True\r\n elif value.lower() == 'false':\r\n return False\r\n elif value.isdigit():\r\n return int(value)\r\n try:\r\n return float(value)\r\n except ValueError:\r\n return value\r\n\r\n # =========================================================================\r\n # ANIMATION STYLE CONFIGURATION\r\n # =========================================================================\r\n \r\n def get_animation_style(self) -> str:\r\n \"\"\"\r\n Get the current animation style name.\r\n \r\n Returns one of: 'vibrant', 'subtle', 'neural', 'none', 'electric', 'zen', 'neon'\r\n \"\"\"\r\n if not self.config.has_section('Animation'):\r\n return 'vibrant' # Default style\r\n return self.config.get('Animation', 'style', fallback='vibrant').lower()\r\n \r\n def set_animation_style(self, style_name: str) -> bool:\r\n \"\"\"\r\n Set the animation style and save to config.\r\n \r\n Args:\r\n style_name: One of 'vibrant', 'subtle', 'neural', 'electric', 'zen', 'neon'\r\n \r\n Returns:\r\n True if style was set, False if invalid style name\r\n \"\"\"\r\n style_lower = style_name.lower()\r\n if style_lower not in self.ANIMATION_STYLES:\r\n print(f\"⚠️ Invalid animation style: {style_name}. \"\r\n f\"Available: {self.ANIMATION_STYLES}\")\r\n return False\r\n \r\n if not self.config.has_section('Animation'):\r\n self.config.add_section('Animation')\r\n \r\n self.config.set('Animation', 'style', style_lower)\r\n self._save_config()\r\n return True\r\n \r\n def get_animation_config(self, style_name: str = None) -> dict:\r\n \"\"\"\r\n Get animation configuration for a specific style.\r\n \r\n This provides config values that can override the dataclass defaults\r\n in animation_styles.py, allowing user customization via config.ini.\r\n \r\n Args:\r\n style_name: Style to get config for (defaults to current style)\r\n \r\n Returns:\r\n Dictionary of animation parameters\r\n \"\"\"\r\n if style_name is None:\r\n style_name = self.get_animation_style()\r\n \r\n section_name = f'Animation.{style_name.capitalize()}'\r\n \r\n # Default values for each style\r\n defaults = {\r\n 'vibrant': {\r\n 'use_thick_lines': 'True',\r\n 'pulse_colour': '255,220,50',\r\n 'pulse_alpha': '240',\r\n 'pulse_duration': '1.8',\r\n 'pulse_speed': '1.0',\r\n 'line_base_width': '1.5',\r\n 'line_colour_positive': '50,220,50',\r\n 'line_colour_negative': '255,60,60',\r\n 'line_alpha': '220',\r\n },\r\n 'subtle': {\r\n 'use_thick_lines': 'False',\r\n 'pulse_colour': '200,200,150',\r\n 'pulse_alpha': '160',\r\n 'pulse_duration': '2.5',\r\n 'pulse_speed': '0.8',\r\n 'line_base_width': '0.8',\r\n 'line_colour_positive': '80,160,80',\r\n 'line_colour_negative': '180,80,80',\r\n 'line_alpha': '140',\r\n },\r\n 'neural': {\r\n 'use_thick_lines': 'False',\r\n 'pulse_colour': '180,230,255',\r\n 'pulse_alpha': '200',\r\n 'pulse_duration': '0.9',\r\n 'pulse_speed': '1.1',\r\n 'line_base_width': '1.0',\r\n 'line_colour_positive': '100,200,255',\r\n 'line_colour_negative': '255,120,100',\r\n 'line_alpha': '180',\r\n 'neural_base_colour_positive': '100,200,255',\r\n 'neural_base_colour_negative': '255,120,100',\r\n 'neural_base_alpha': '180',\r\n },\r\n 'electric': {\r\n 'use_thick_lines': 'True',\r\n 'pulse_colour': '255,255,255',\r\n 'pulse_alpha': '255',\r\n 'pulse_duration': '0.15',\r\n 'pulse_speed': '4.0',\r\n 'line_base_width': '2.5',\r\n 'line_colour_positive': '0,255,255',\r\n 'line_colour_negative': '255,0,255',\r\n 'line_alpha': '255',\r\n },\r\n 'zen': {\r\n 'use_thick_lines': 'False',\r\n 'pulse_colour': '200,200,200',\r\n 'pulse_alpha': '120',\r\n 'pulse_duration': '3.0',\r\n 'pulse_speed': '0.5',\r\n 'line_base_width': '1.0',\r\n 'line_colour_positive': '60,60,60',\r\n 'line_colour_negative': '120,120,120',\r\n 'line_alpha': '120',\r\n },\r\n 'neon': {\r\n 'use_thick_lines': 'True',\r\n 'pulse_colour': '255,255,255',\r\n 'pulse_alpha': '255',\r\n 'pulse_duration': '0.3',\r\n 'pulse_speed': '3.5',\r\n 'line_base_width': '1.8',\r\n 'line_colour_positive': '0,255,120',\r\n 'line_colour_negative': '255,50,205',\r\n 'line_alpha': '240',\r\n }\r\n }\r\n \r\n style_defaults = defaults.get(style_name.lower(), defaults['vibrant'])\r\n \r\n # Override with config file values if section exists\r\n if self.config.has_section(section_name):\r\n for key in style_defaults:\r\n if self.config.has_option(section_name, key):\r\n style_defaults[key] = self.config.get(section_name, key)\r\n \r\n return style_defaults\r\n \r\n def get_available_animation_styles(self) -> list:\r\n \"\"\"Return list of available animation style names.\"\"\"\r\n return list(self.ANIMATION_STYLES)\r\n \r\n def get_display_config(self):\r\n \"\"\"Get display configuration settings\"\"\"\r\n return {\r\n 'neuron_label_font_size': self.config.getint('Display', 'neuron_label_font_size', fallback=8),\r\n 'neuron_radius': self.config.getint('Display', 'neuron_radius', fallback=14),\r\n 'connection_line_width': self.config.getfloat('Display', 'connection_line_width', fallback=1.5),\r\n 'button_font_size': self.config.getint('Display', 'button_font_size', fallback=16),\r\n 'button_width': self.config.getint('Display', 'button_width', fallback=140),\r\n 'button_height': self.config.getint('Display', 'button_height', fallback=50),\r\n 'button_spacing': self.config.getint('Display', 'button_spacing', fallback=20)\r\n }\r\n \r\n def is_designer_position_valid(self, x, y, existing_positions, center_x=0, center_y=0):\r\n \"\"\"\r\n Checks if a position is valid based on designer config constraints.\r\n \r\n Args:\r\n x, y: The proposed coordinates.\r\n existing_positions: List of tuples [(x,y), ...] or objects with .x, .y attributes.\r\n center_x, center_y: The origin point to measure max distance from (default 0,0).\r\n \r\n Returns:\r\n True if valid, False if it violates designer constraints.\r\n \"\"\"\r\n import math\r\n \r\n # Load constraints from the new Designer section\r\n min_dist = self.config.getint('Designer', 'designer_min_neuron_distance', fallback=100)\r\n max_dist = self.config.getint('Designer', 'designer_max_neuron_distance', fallback=600)\r\n\r\n # 1. Check Max Distance (Radius from center)\r\n dist_from_center = math.sqrt((x - center_x)**2 + (y - center_y)**2)\r\n if dist_from_center > max_dist:\r\n return False\r\n\r\n # 2. Check Min Distance (Proximity to other neurons)\r\n for pos in existing_positions:\r\n # Handle both tuples and objects with .x .y attributes\r\n if hasattr(pos, 'x') and hasattr(pos, 'y'):\r\n ex, ey = pos.x, pos.y\r\n else:\r\n ex, ey = pos[0], pos[1]\r\n \r\n dist_to_neighbor = math.sqrt((x - ex)**2 + (y - ey)**2)\r\n if dist_to_neighbor < min_dist:\r\n return False\r\n\r\n return True\r\n\r\n\r\n def _save_config(self):\r\n \"\"\"Save the current configuration to file.\"\"\"\r\n try:\r\n with open(self.config_path, 'w') as f:\r\n self.config.write(f)\r\n except Exception as e:\r\n print(f\"⚠️ Failed to save config: {e}\")\r\n\r\n def get_language(self):\r\n if not self.config.has_section('General'):\r\n return 'en'\r\n return self.config.get('General', 'language', fallback='en').lower()"
},
{
"path": "src/custom_brain_loader.py",
"content": "import os\r\nimport json\r\nimport shutil\r\nimport time\r\nfrom pathlib import Path\r\nfrom typing import Optional, Dict\r\nfrom PyQt5 import QtWidgets, QtCore, QtGui\r\nfrom .brain_neuron_outputs import NeuronOutputBinding, OutputTriggerMode\r\n\r\n\r\n# Global tracker for the currently loaded custom brain\r\n_current_custom_brain: Optional[Dict] = None\r\n_current_custom_brain_name: Optional[str] = None\r\n_current_custom_brain_file: Optional[str] = None\r\n\r\n\r\ndef add_load_brain_button(network_tab, checkbox_layout):\r\n \"\"\"\r\n Add a Load Brain button to the NetworkTab.\r\n \r\n Args:\r\n network_tab: The NetworkTab instance (self)\r\n checkbox_layout: The checkbox layout to add the button to\r\n \"\"\"\r\n # Add some spacing\r\n checkbox_layout.addSpacing(20)\r\n \r\n # Create the button\r\n load_btn = QtWidgets.QPushButton(\"Load Brain...\")\r\n load_btn.setToolTip(\"Load a custom brain architecture\")\r\n load_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #5c6bc0;\r\n color: white;\r\n border: none;\r\n border-radius: 3px;\r\n padding: 4px 12px;\r\n font-weight: bold;\r\n font-size: 9pt;\r\n }\r\n QPushButton:hover {\r\n background-color: #7986cb;\r\n }\r\n QPushButton:pressed {\r\n background-color: #3f51b5;\r\n }\r\n \"\"\")\r\n \r\n # Create loader and connect\r\n loader = BrainLoader(network_tab)\r\n network_tab._brain_loader = loader\r\n load_btn.clicked.connect(loader.show_dialog)\r\n \r\n checkbox_layout.addWidget(load_btn)\r\n \r\n # --- RESET BUTTON (with “Are you sure?” guard) ---\r\n reset_btn = QtWidgets.QPushButton(\"↺\")\r\n reset_btn.setToolTip(\"Reset to default brain\")\r\n reset_btn.setFixedSize(50, 50)\r\n reset_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #78909c;\r\n color: white;\r\n border: none;\r\n border-radius: 3px;\r\n font-weight: bold;\r\n }\r\n QPushButton:hover { background-color: #90a4ae; }\r\n \"\"\")\r\n\r\n def _confirm_reset():\r\n ans = QtWidgets.QMessageBox.question(\r\n network_tab, # parent widget\r\n \"Confirm Reset\",\r\n \"Reset all neuron positions to their default locations?\\n\\n\"\r\n \"Network structure (connections and weights) will be preserved.\",\r\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,\r\n QtWidgets.QMessageBox.No\r\n )\r\n if ans == QtWidgets.QMessageBox.Yes:\r\n try:\r\n loader.reset_positions_to_default()\r\n except Exception as e:\r\n QtWidgets.QMessageBox.critical(\r\n network_tab, \"Error\", f\"Failed to reset positions:\\n{e}\"\r\n )\r\n \r\n reset_btn.clicked.connect(_confirm_reset)\r\n checkbox_layout.addWidget(reset_btn)\r\n\r\n\r\n# =============================================================================\r\n# SAVE/LOAD INTEGRATION API\r\n# =============================================================================\r\n\r\ndef get_custom_brain_save_data() -> Optional[Dict]:\r\n \"\"\"\r\n Get custom brain data for saving with game state.\r\n Returns None if using default brain.\r\n \r\n Call this from tamagotchi_logic.save_game() to include in save_data.\r\n \"\"\"\r\n global _current_custom_brain, _current_custom_brain_name\r\n \r\n if _current_custom_brain is None:\r\n return None\r\n \r\n return {\r\n 'is_custom_brain': True,\r\n 'brain_name': _current_custom_brain_name,\r\n 'brain_definition': _current_custom_brain,\r\n 'source_file': _current_custom_brain_file,\r\n }\r\n\r\n\r\ndef has_custom_brain() -> bool:\r\n \"\"\"Check if a custom brain is currently loaded.\"\"\"\r\n return _current_custom_brain is not None\r\n\r\n\r\ndef get_custom_brain_name() -> Optional[str]:\r\n \"\"\"Get the name of the currently loaded custom brain.\"\"\"\r\n return _current_custom_brain_name\r\n\r\n\r\ndef validate_custom_brain_save(save_data: Dict) -> tuple[bool, str]:\r\n \"\"\"\r\n Validate that a save file's custom brain can be restored.\r\n \r\n Returns:\r\n (is_valid, message) - is_valid=True if loadable, message explains any issues\r\n \"\"\"\r\n custom_brain_data = save_data.get('custom_brain')\r\n \r\n if not custom_brain_data:\r\n return True, \"Default brain (no custom brain)\"\r\n \r\n if not custom_brain_data.get('is_custom_brain'):\r\n return True, \"Default brain\"\r\n \r\n brain_def = custom_brain_data.get('brain_definition')\r\n if not brain_def:\r\n return False, \"Save contains custom brain flag but no brain definition!\"\r\n \r\n # Check if brain definition looks valid\r\n if 'positions' not in brain_def and 'neurons' not in brain_def:\r\n return False, \"Custom brain definition is corrupted (no neurons)\"\r\n \r\n brain_name = custom_brain_data.get('brain_name', 'Unknown')\r\n return True, f\"Custom brain: {brain_name}\"\r\n\r\n\r\ndef restore_custom_brain_from_save(save_data: Dict, brain_widget) -> tuple[bool, str]:\r\n \"\"\"\r\n Restore a custom brain from save data.\r\n \r\n Args:\r\n save_data: The loaded save data dict\r\n brain_widget: The BrainWidget to apply the brain to\r\n \r\n Returns:\r\n (success, message)\r\n \"\"\"\r\n global _current_custom_brain, _current_custom_brain_name, _current_custom_brain_file\r\n \r\n custom_brain_data = save_data.get('custom_brain')\r\n \r\n if not custom_brain_data or not custom_brain_data.get('is_custom_brain'):\r\n # No custom brain - reset to default\r\n _current_custom_brain = None\r\n _current_custom_brain_name = None\r\n _current_custom_brain_file = None\r\n return True, \"Using default brain\"\r\n \r\n brain_def = custom_brain_data.get('brain_definition')\r\n brain_name = custom_brain_data.get('brain_name', 'Unknown')\r\n \r\n if not brain_def:\r\n return False, \"Custom brain definition missing from save!\"\r\n \r\n try:\r\n # Create a temporary loader to apply the brain\r\n loader = BrainLoader.__new__(BrainLoader)\r\n loader.brain_widget = brain_widget\r\n loader.network_tab = None\r\n \r\n # Parse and apply\r\n parsed = loader._parse(brain_def)\r\n if not parsed:\r\n return False, f\"Could not parse custom brain '{brain_name}'\"\r\n \r\n loader._apply(parsed)\r\n \r\n # Update global tracking\r\n _current_custom_brain = brain_def\r\n _current_custom_brain_name = brain_name\r\n _current_custom_brain_file = custom_brain_data.get('source_file')\r\n \r\n return True, f\"Restored custom brain: {brain_name}\"\r\n \r\n except Exception as e:\r\n return False, f\"Error restoring custom brain: {e}\"\r\n\r\n\r\ndef show_custom_brain_load_warning(parent, save_data: Dict) -> bool:\r\n \"\"\"\r\n Show warning dialog when loading a save with custom brain.\r\n \r\n Returns True if user wants to proceed, False to cancel.\r\n \"\"\"\r\n # VALIDATION FIX: Ensure parent is a QWidget or None\r\n if parent and not isinstance(parent, QtWidgets.QWidget):\r\n if hasattr(parent, 'mainwindow'):\r\n parent = parent.mainwindow\r\n elif hasattr(parent, 'central_widget'):\r\n parent = parent.central_widget\r\n else:\r\n # Fallback to None (desktop parent) to prevent crash\r\n parent = None\r\n\r\n custom_brain_data = save_data.get('custom_brain')\r\n \r\n if not custom_brain_data or not custom_brain_data.get('is_custom_brain'):\r\n return True # No custom brain, no warning needed\r\n \r\n brain_name = custom_brain_data.get('brain_name', 'Unknown')\r\n source_file = custom_brain_data.get('source_file', 'Unknown')\r\n \r\n # Validate the brain can be restored\r\n is_valid, message = validate_custom_brain_save(save_data)\r\n \r\n if not is_valid:\r\n QtWidgets.QMessageBox.critical(\r\n parent,\r\n \"Cannot Load Save\",\r\n f\"This save uses a custom brain that cannot be restored:\\n\\n\"\r\n f\"Brain: {brain_name}\\n\"\r\n f\"Error: {message}\\n\\n\"\r\n f\"The save file may be corrupted.\"\r\n )\r\n return False\r\n \r\n # Show info dialog\r\n reply = QtWidgets.QMessageBox.question(\r\n parent,\r\n \"Custom Brain Save\",\r\n f\"This save uses a custom brain architecture:\\n\\n\"\r\n f\"🧠 Brain: {brain_name}\\n\"\r\n f\"📁 Original file: {source_file}\\n\\n\"\r\n f\"The brain definition is embedded in the save and will be restored.\\n\\n\"\r\n f\"Continue loading?\",\r\n QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No,\r\n QtWidgets.QMessageBox.Yes\r\n )\r\n \r\n return reply == QtWidgets.QMessageBox.Yes\r\n\r\n\r\n# =============================================================================\r\n# BRAIN LOADER CLASS\r\n# =============================================================================\r\n\r\nclass BrainLoader:\r\n \"\"\"Handles brain file loading.\"\"\"\r\n \r\n def __init__(self, network_tab):\r\n self.network_tab = network_tab\r\n self.brain_widget = network_tab.brain_widget\r\n self.brains_folder = self._find_brains_folder()\r\n \r\n def _find_brains_folder(self) -> Path:\r\n \"\"\"Find or create custom_brains folder (one level up from Brain/).\"\"\"\r\n candidates = [\r\n Path(__file__).parent.parent / \"custom_brains\", # Up from Brain/ to project root\r\n Path.cwd() / \"custom_brains\",\r\n Path(__file__).parent / \"custom_brains\", # Fallback to Brain/custom_brains\r\n ]\r\n for p in candidates:\r\n if p.exists():\r\n return p\r\n \r\n # Create at project root level (one up from Brain/)\r\n default = candidates[0]\r\n default.mkdir(parents=True, exist_ok=True)\r\n return default\r\n \r\n def show_dialog(self):\r\n \"\"\"Show the brain selection dialog.\"\"\"\r\n dialog = BrainSelectDialog(self.brains_folder, self.network_tab)\r\n if dialog.exec_() == QtWidgets.QDialog.Accepted and dialog.selected_file:\r\n self.load_file(dialog.selected_file)\r\n \r\n def load_file(self, filepath: str) -> bool:\r\n \"\"\"Load and apply a brain file.\"\"\"\r\n global _current_custom_brain, _current_custom_brain_name, _current_custom_brain_file\r\n \r\n try:\r\n print(f\"🧠 Loading brain: {filepath}\")\r\n \r\n with open(filepath, 'r') as f:\r\n data = json.load(f)\r\n \r\n brain = self._parse(data)\r\n if not brain:\r\n raise ValueError(\"Could not parse brain format\")\r\n \r\n self._apply(brain)\r\n \r\n # 1. Send bindings to the live game logic\r\n if hasattr(self.network_tab, 'tamagotchi_logic'):\r\n logic = self.network_tab.tamagotchi_logic\r\n if hasattr(logic, 'neuron_output_monitor') and logic.neuron_output_monitor:\r\n logic.neuron_output_monitor.load_bindings_from_brain(brain)\r\n print(f\" ✓ Loaded {len(brain.get('output_bindings', []))} output bindings into Monitor\")\r\n\r\n # --- FIX: Force-sync live sensor values immediately ---\r\n # This prevents the saved \"0\" value from overwriting the real sensor input\r\n # in the first frame after loading.\r\n if hasattr(logic, 'brain_hooks'):\r\n print(\" -> Syncing live sensor inputs...\")\r\n input_values = logic.brain_hooks.get_input_neuron_values()\r\n \r\n # Update widget state directly\r\n bw = self.brain_widget\r\n if hasattr(bw, 'state'):\r\n bw.state.update(input_values)\r\n \r\n # Update internal simulation neurons if present\r\n if hasattr(bw, 'neurons'):\r\n for k, v in input_values.items():\r\n if k in bw.neurons:\r\n bw.neurons[k]['activation'] = v\r\n # --- END FIX ---\r\n\r\n # 2. UI OVERLAY SETUP\r\n # Check if the stats area exists. If not, create it manually.\r\n if hasattr(self.network_tab, '_create_functional_stats_area'):\r\n if not hasattr(self.network_tab, 'functional_stats_area') or self.network_tab.functional_stats_area is None:\r\n print(\" -> Creating functional stats area for overlay...\")\r\n self.network_tab._create_functional_stats_area()\r\n \r\n # Ensure the label has text so the widget has non-zero height!\r\n if hasattr(self.network_tab, 'functional_stats_label') and not self.network_tab.functional_stats_label.text():\r\n self.network_tab.functional_stats_label.setText(\"🧠 Custom Brain Loaded External Bindings Active\")\r\n self.network_tab.functional_stats_label.show()\r\n\r\n # Initialize overlay if missing\r\n if hasattr(self.network_tab, 'functional_stats_area'):\r\n if not hasattr(self.network_tab, 'binding_overlay') or self.network_tab.binding_overlay is None:\r\n try:\r\n from .brain_network_tab_banners import BindingOverlay\r\n self.network_tab.binding_overlay = BindingOverlay(self.network_tab, self.network_tab.functional_stats_area)\r\n print(\" -> BindingOverlay initialized\")\r\n except ImportError as e:\r\n print(f\" ! Could not import BindingOverlay: {e}\")\r\n\r\n # Update the overlay with data\r\n if hasattr(self.network_tab, 'binding_overlay') and self.network_tab.binding_overlay:\r\n bindings = brain.get('output_bindings', [])\r\n if bindings:\r\n print(f\" -> Sending {len(bindings)} bindings to overlay\")\r\n self.network_tab.binding_overlay.update_bindings(bindings)\r\n\r\n # 3. Finalize\r\n _current_custom_brain = data\r\n _current_custom_brain_name = Path(filepath).stem\r\n _current_custom_brain_file = filepath\r\n \r\n self._update_worker()\r\n \r\n if hasattr(self.network_tab, 'update_metrics_display'):\r\n self.network_tab.update_metrics_display()\r\n \r\n if self.brain_widget:\r\n self.brain_widget.update()\r\n \r\n name = Path(filepath).stem\r\n QtWidgets.QMessageBox.information(\r\n self.network_tab, \"Loaded\",\r\n f\"✅ {name}\\n\\nNeurons: {len(brain['positions'])}\\nConnections: {len(brain['weights'])}\\n\\n\"\r\n f\"This brain will be saved with your game.\"\r\n )\r\n return True\r\n \r\n except Exception as e:\r\n import traceback\r\n print(f\"❌ Failed to load brain: {e}\")\r\n traceback.print_exc()\r\n QtWidgets.QMessageBox.critical(self.network_tab, \"Error\", f\"Failed to load:\\n{e}\")\r\n return False\r\n \r\n def reset_to_default(self):\r\n \"\"\"Reset to the default brain.\"\"\"\r\n global _current_custom_brain, _current_custom_brain_name, _current_custom_brain_file\r\n \r\n bw = self.brain_widget\r\n if not bw or not hasattr(bw, '_orig_backup'):\r\n QtWidgets.QMessageBox.warning(\r\n self.network_tab, \"Cannot Reset\",\r\n \"No original brain backup available.\"\r\n )\r\n return\r\n \r\n backup = bw._orig_backup\r\n \r\n # Restore from backup\r\n if hasattr(bw, 'neuron_positions'):\r\n bw.neuron_positions.clear()\r\n bw.neuron_positions.update(backup['positions'])\r\n \r\n if hasattr(bw, 'weights'):\r\n bw.weights.clear()\r\n bw.weights.update(backup['weights'])\r\n \r\n if hasattr(bw, 'state'):\r\n # Only restore non-status neurons\r\n status = {'is_sick', 'is_eating', 'is_sleeping', 'pursuing_food', 'direction'}\r\n saved_status = {k: v for k, v in bw.state.items() if k in status}\r\n bw.state.clear()\r\n bw.state.update(backup['state'])\r\n bw.state.update(saved_status)\r\n \r\n if hasattr(bw, 'connections'):\r\n bw.connections = list(bw.weights.keys())\r\n \r\n # Clear custom brain tracking\r\n _current_custom_brain = None\r\n _current_custom_brain_name = None\r\n _current_custom_brain_file = None\r\n \r\n self._update_worker()\r\n \r\n if hasattr(self.network_tab, 'update_metrics_display'):\r\n self.network_tab.update_metrics_display()\r\n \r\n bw.update()\r\n \r\n QtWidgets.QMessageBox.information(\r\n self.network_tab, \"Reset\",\r\n \"Brain reset to default configuration.\"\r\n )\r\n \r\n def _parse(self, data: Dict) -> Optional[Dict]:\r\n \"\"\"Parse brain file to standard format.\"\"\"\r\n result = {'positions': {}, 'weights': {}, 'state': {}, 'excluded': set(), 'output_bindings': []}\r\n \r\n # Format 1: Dosidicus format (connections as dict with \"->\")\r\n if 'neurons' in data and isinstance(data.get('connections'), dict):\r\n for name, nd in data['neurons'].items():\r\n pos = nd.get('position', [0, 0])\r\n result['positions'][name] = tuple(pos) if isinstance(pos, list) else pos\r\n for key, w in data.get('connections', {}).items():\r\n if '->' in str(key):\r\n s, t = str(key).split('->')\r\n result['weights'][(s, t)] = w\r\n result['state'] = data.get('state', {})\r\n result['excluded'] = set(data.get('excluded_neurons', []))\r\n \r\n # Format 2: Designer format (connections as list)\r\n elif 'neurons' in data and isinstance(data.get('connections'), list):\r\n for name, nd in data['neurons'].items():\r\n pos = nd.get('position', [0, 0])\r\n result['positions'][name] = tuple(pos) if isinstance(pos, list) else pos\r\n result['state'][name] = nd.get('activation', 50.0)\r\n for c in data.get('connections', []):\r\n if c.get('source') and c.get('target'):\r\n result['weights'][(c['source'], c['target'])] = c.get('weight', 0.1)\r\n result['excluded'] = set(data.get('excluded_neurons', []))\r\n \r\n # Format 3: Layer format\r\n elif 'layers' in data:\r\n for i, layer in enumerate(data['layers']):\r\n neurons = layer.get('neurons', [])\r\n y = 80 + i * 150\r\n for j, name in enumerate(neurons):\r\n x = 100 + (j + 1) * (700 // (len(neurons) + 1))\r\n result['positions'][name] = (x, y)\r\n result['state'][name] = 50.0\r\n for c in data.get('custom_connections', []):\r\n if c.get('source') and c.get('target'):\r\n result['weights'][(c['source'], c['target'])] = c.get('weight', 0.1)\r\n else:\r\n return None\r\n \r\n # Parse output bindings\r\n result['output_bindings'] = data.get('output_bindings', [])\r\n \r\n # Defaults\r\n for n in result['positions']:\r\n if n not in result['state']:\r\n result['state'][n] = 50.0\r\n \r\n status = {'is_sick', 'is_eating', 'is_sleeping', 'pursuing_food', 'direction'}\r\n result['excluded'].update(status)\r\n \r\n return result if result['positions'] else None\r\n \r\n def _apply(self, brain: dict):\r\n \"\"\"Apply parsed brain data to the current brain widget.\"\"\"\r\n bw = self.brain_widget\r\n \r\n # Apply positions\r\n if 'positions' in brain:\r\n if hasattr(bw, 'neuron_positions'):\r\n bw.neuron_positions.clear()\r\n bw.neuron_positions.update(brain['positions'])\r\n \r\n # --- FIX: Ensure mandatory sensors are present ---\r\n # If the custom brain deleted core sensors, the game logic will break.\r\n # We restore them using original positions (or default) so inputs still work.\r\n MANDATORY_SENSORS = {\r\n 'can_see_food', 'external_stimulus', 'plant_proximity', \r\n 'is_eating', 'is_sleeping', 'is_sick', 'is_fleeing', 'is_startled', \r\n 'pursuing_food'\r\n }\r\n \r\n restored_sensors = 0\r\n if hasattr(bw, 'original_neuron_positions'):\r\n for sensor in MANDATORY_SENSORS:\r\n if sensor not in bw.neuron_positions:\r\n if sensor in bw.original_neuron_positions:\r\n bw.neuron_positions[sensor] = bw.original_neuron_positions[sensor]\r\n # Also ensure it has a state entry\r\n if hasattr(bw, 'state') and sensor not in bw.state:\r\n bw.state[sensor] = 0.0\r\n restored_sensors += 1\r\n \r\n if restored_sensors > 0:\r\n print(f\"🔧 Restored {restored_sensors} mandatory sensor neurons missing from custom brain\")\r\n \r\n # Apply weights/connections\r\n if 'weights' in brain:\r\n if hasattr(bw, 'weights'):\r\n bw.weights.clear()\r\n bw.weights.update(brain['weights'])\r\n \r\n # Apply state if present (neuron activations)\r\n if 'state' in brain:\r\n if hasattr(bw, 'state'):\r\n bw.state.clear()\r\n bw.state.update(brain['state'])\r\n\r\n # Populate bw.neurons for synchronous simulation fallback\r\n if hasattr(bw, 'neurons'):\r\n bw.neurons = {}\r\n for name in bw.neuron_positions:\r\n # Check if this is a binary/sensor neuron\r\n is_sensor = hasattr(bw, 'is_binary_neuron') and bw.is_binary_neuron(name)\r\n \r\n # FIX: Sensors get 1.0 decay so they persist. 0.0 decay zeroes them out instantly.\r\n bw.neurons[name] = {\r\n 'activation': bw.state.get(name, 50.0),\r\n 'decay': 1.0 if is_sensor else 0.9, \r\n 'noise': 0.0\r\n }\r\n \r\n # Apply excluded neurons\r\n if 'excluded' in brain:\r\n if hasattr(bw, 'excluded_neurons'):\r\n bw.excluded_neurons = list(brain['excluded'])\r\n \r\n # === OUTPUT BINDINGS (Neuron → Behavior) ===\r\n output_bindings_data = brain.get('output_bindings', [])\r\n \r\n if output_bindings_data:\r\n # Find the NeuronOutputMonitor\r\n monitor = None\r\n logic = getattr(bw, 'tamagotchi_logic', None)\r\n if logic and hasattr(logic, 'neuron_output_monitor'):\r\n monitor = logic.neuron_output_monitor\r\n # Fallback if attached differently\r\n elif hasattr(bw, 'parent') and hasattr(bw.parent(), 'tamagotchi_logic'):\r\n monitor = bw.parent().tamagotchi_logic.neuron_output_monitor\r\n \r\n if monitor:\r\n # Load the bindings\r\n monitor.bindings = [] # Clear old ones\r\n loaded_count = 0\r\n for bind_data in output_bindings_data:\r\n try:\r\n binding = NeuronOutputBinding.from_dict(bind_data)\r\n monitor.bindings.append(binding)\r\n loaded_count += 1\r\n except Exception as e:\r\n print(f\"[BrainLoader] Failed to load binding: {e}\")\r\n \r\n print(f\"[NeuronOutputMonitor] Loaded {loaded_count} neuron output bindings\")\r\n \r\n # Use the actual monitor() method to trigger initial thresholds\r\n if hasattr(bw, 'state') and bw.state:\r\n # Convert state values to float where needed\r\n activations = {}\r\n for name, value in bw.state.items():\r\n try:\r\n activations[name] = float(value)\r\n except (TypeError, ValueError):\r\n activations[name] = 100.0 if value else 0.0\r\n \r\n # Trigger the monitor with current activations\r\n monitor.monitor(activations)\r\n print(\"[NeuronOutputMonitor] Initial neuron activations processed via monitor()\")\r\n else:\r\n print(\"[NeuronOutputMonitor] ⚠️ No state data available for initial trigger\")\r\n else:\r\n print(\"[NeuronOutputMonitor] ⚠️ Monitor not found — bindings saved but not activated\")\r\n \r\n # Keep a copy on the widget for saving/exporting later\r\n bw.output_bindings = output_bindings_data\r\n \r\n # Update related attributes safely\r\n if hasattr(bw, 'connections'):\r\n bw.connections = list(brain['weights'].keys())\r\n if hasattr(bw, 'visible_neurons'):\r\n bw.visible_neurons = set(bw.neuron_positions.keys()) if hasattr(bw, 'neuron_positions') else set()\r\n if hasattr(bw, 'original_neuron_positions') and hasattr(bw, 'neuron_positions'):\r\n bw.original_neuron_positions = dict(bw.neuron_positions)\r\n if hasattr(bw, 'original_neurons') and hasattr(bw, 'neuron_positions'):\r\n status = {'is_sick', 'is_eating', 'is_sleeping', 'pursuing_food', 'direction'}\r\n bw.original_neurons = [n for n in bw.neuron_positions if n not in status]\r\n if hasattr(bw, 'communication_events') and hasattr(bw, 'neuron_positions'):\r\n bw.communication_events = {n: 0 for n in bw.neuron_positions}\r\n \r\n def _update_worker(self):\r\n \"\"\"Update BrainWorker cache if available.\"\"\"\r\n try:\r\n worker = None\r\n parent = self.network_tab.parent() if self.network_tab else None\r\n while parent:\r\n if hasattr(parent, 'brain_worker'):\r\n worker = parent.brain_worker\r\n break\r\n parent = parent.parent()\r\n \r\n if not worker:\r\n print(\"⚠️ BrainWorker not found - skipping cache update\")\r\n return\r\n \r\n # Try to update worker cache - different versions may have different APIs\r\n bw = self.brain_widget\r\n \r\n if hasattr(worker, 'update_cache') and callable(getattr(worker, 'update_cache')):\r\n worker.update_cache(\r\n state=bw.state,\r\n weights=bw.weights,\r\n neuron_positions=bw.neuron_positions,\r\n config=getattr(bw, 'config', None),\r\n excluded_neurons=getattr(bw, 'excluded_neurons', []),\r\n learning_rate=getattr(bw, 'learning_rate', 0.1),\r\n new_neurons=bw.neurogenesis_data.get('new_neurons', []) if hasattr(bw, 'neurogenesis_data') else []\r\n )\r\n print(\"✅ BrainWorker cache updated\")\r\n elif hasattr(worker, 'set_brain_data') and callable(getattr(worker, 'set_brain_data')):\r\n worker.set_brain_data(bw.state, bw.weights, bw.neuron_positions)\r\n print(\"✅ BrainWorker data updated\")\r\n else:\r\n # Just update the worker's direct references if it has them\r\n if hasattr(worker, 'state'):\r\n worker.state = bw.state\r\n if hasattr(worker, 'weights'):\r\n worker.weights = bw.weights\r\n if hasattr(worker, 'neuron_positions'):\r\n worker.neuron_positions = bw.neuron_positions\r\n print(\"✅ BrainWorker references updated\")\r\n \r\n except Exception as e:\r\n print(f\"⚠️ Could not update BrainWorker: {e}\")\r\n # Non-fatal - brain still loads, just learning might need restart\r\n\r\n def reset_positions_to_default(self):\r\n \"\"\"Reset only neuron positions to defaults, preserving network structure\"\"\"\r\n bw = self.brain_widget\r\n if not bw or not hasattr(bw, '_orig_backup'):\r\n raise ValueError(\"No original brain backup available\")\r\n \r\n # Reset positions only\r\n for neuron in list(bw.neuron_positions.keys()):\r\n if neuron in bw._orig_backup['positions']:\r\n bw.neuron_positions[neuron] = bw._orig_backup['positions'][neuron]\r\n \r\n # Update displays\r\n if hasattr(self.network_tab, 'update_metrics_display'):\r\n self.network_tab.update_metrics_display()\r\n \r\n # Repaint\r\n bw.update()\r\n \r\n print(\"✅ Neuron positions reset to defaults\")\r\n\r\n\r\n# =============================================================================\r\n# BRAIN SELECTION DIALOG\r\n# =============================================================================\r\n\r\nclass BrainSelectDialog(QtWidgets.QDialog):\r\n \"\"\"Simple dialog to select a brain file.\"\"\"\r\n \r\n def __init__(self, brains_folder: Path, parent=None):\r\n super().__init__(parent)\r\n self.brains_folder = brains_folder\r\n self.selected_file = None\r\n self.setWindowTitle(\"Load Custom Brain\")\r\n self.setMinimumSize(450, 350)\r\n self._setup_ui()\r\n self._refresh()\r\n \r\n def _setup_ui(self):\r\n layout = QtWidgets.QVBoxLayout(self)\r\n \r\n # List\r\n self.list = QtWidgets.QListWidget()\r\n self.list.setStyleSheet(\"font-size: 11pt;\")\r\n self.list.itemDoubleClicked.connect(self.accept)\r\n self.list.currentRowChanged.connect(self._on_select)\r\n layout.addWidget(self.list)\r\n \r\n # Info\r\n self.info = QtWidgets.QLabel(\"Select a brain file\")\r\n self.info.setStyleSheet(\"background: #f0f0f0; padding: 8px; border-radius: 4px;\")\r\n self.info.setWordWrap(True)\r\n layout.addWidget(self.info)\r\n \r\n # Buttons\r\n btns = QtWidgets.QHBoxLayout()\r\n \r\n browse = QtWidgets.QPushButton(\"Browse...\")\r\n browse.clicked.connect(self._browse)\r\n btns.addWidget(browse)\r\n \r\n folder = QtWidgets.QPushButton(\"Open Folder\")\r\n folder.clicked.connect(self._open_folder)\r\n btns.addWidget(folder)\r\n \r\n btns.addStretch()\r\n \r\n cancel = QtWidgets.QPushButton(\"Cancel\")\r\n cancel.clicked.connect(self.reject)\r\n btns.addWidget(cancel)\r\n \r\n load = QtWidgets.QPushButton(\"Load\")\r\n load.setStyleSheet(\"background: #5c6bc0; color: white; font-weight: bold;\")\r\n load.clicked.connect(self.accept)\r\n btns.addWidget(load)\r\n \r\n layout.addLayout(btns)\r\n \r\n # Hint\r\n hint = QtWidgets.QLabel(f\"Folder: {self.brains_folder}\")\r\n hint.setStyleSheet(\"color: #888; font-size: 9pt;\")\r\n layout.addWidget(hint)\r\n \r\n def _refresh(self):\r\n self.list.clear()\r\n files = list(self.brains_folder.glob(\"*.json\")) if self.brains_folder.exists() else []\r\n \r\n if not files:\r\n item = QtWidgets.QListWidgetItem(\"(No brain files - click Browse)\")\r\n item.setFlags(item.flags() & ~QtCore.Qt.ItemIsSelectable)\r\n self.list.addItem(item)\r\n return\r\n \r\n for f in sorted(files):\r\n item = QtWidgets.QListWidgetItem(f\"🧠 {f.stem}\")\r\n item.setData(QtCore.Qt.UserRole, str(f))\r\n self.list.addItem(item)\r\n \r\n def _on_select(self, row):\r\n item = self.list.item(row)\r\n if not item:\r\n return\r\n path = item.data(QtCore.Qt.UserRole)\r\n if not path:\r\n return\r\n \r\n try:\r\n with open(path) as f:\r\n data = json.load(f)\r\n neurons = len(data.get('neurons', {}))\r\n conns = data.get('connections', {})\r\n conn_count = len(conns) if isinstance(conns, (dict, list)) else 0\r\n meta = data.get('metadata', {})\r\n name = meta.get('name', Path(path).stem)\r\n desc = meta.get('description', '')\r\n self.info.setText(f\"{name} Neurons: {neurons} | Connections: {conn_count} {desc}\")\r\n except:\r\n self.info.setText(\"Could not read file\")\r\n \r\n def _browse(self):\r\n path, _ = QtWidgets.QFileDialog.getOpenFileName(\r\n self, \"Select Brain\", str(self.brains_folder), \"JSON (*.json)\"\r\n )\r\n if path:\r\n self.selected_file = path\r\n self.accept()\r\n \r\n def _open_folder(self):\r\n import subprocess, sys\r\n folder = str(self.brains_folder)\r\n if sys.platform == 'win32':\r\n subprocess.run(['explorer', folder])\r\n elif sys.platform == 'darwin':\r\n subprocess.run(['open', folder])\r\n else:\r\n subprocess.run(['xdg-open', folder])\r\n \r\n def accept(self):\r\n if not self.selected_file:\r\n item = self.list.currentItem()\r\n if item:\r\n self.selected_file = item.data(QtCore.Qt.UserRole)\r\n if self.selected_file:\r\n super().accept()"
},
{
"path": "src/decision_engine.py",
"content": "# DECISION ENGINE - https://github.com/ViciousSquid/Dosidicus\r\n# exploration of emergent behavioural complexity via dynamic, biologically-inspired neural architecture rather than a static state machine. \r\n# Version 4.0 — Fully Neural-Driven Decision Making | December 2025\r\n\r\nimport random\r\nimport math\r\nfrom .personality import Personality\r\n\r\n\r\nclass DecisionEngine:\r\n \"\"\"\r\n Neural-first decision engine.\r\n All perception flows through BrainNeuronHooks → no manual vision checks.\r\n Behaviour emerges purely from the current brain state + memory + personality.\r\n \"\"\"\r\n\r\n def __init__(self, squid):\r\n self.squid = squid\r\n self.last_decision_data = {}\r\n\r\n def get_decision_data(self):\r\n \"\"\"Return last decision trace for visualization in Brain Tool → Decisions tab\"\"\"\r\n return self.last_decision_data.copy()\r\n\r\n def make_decision(self):\r\n logic = self.squid.tamagotchi_logic\r\n\r\n # =================================================================\r\n # 1. BUILD FULL BRAIN STATE FROM HOOKS\r\n # =================================================================\r\n decision_data = {\r\n 'inputs': {},\r\n 'brain_state': {},\r\n 'base_weights': {},\r\n 'memory_influences': {},\r\n 'urgency_multipliers': {},\r\n 'personality_modifiers': {},\r\n 'adjusted_weights': {},\r\n 'final_decision': '',\r\n 'confidence': 0.0,\r\n 'personality': self.squid.personality.value if isinstance(self.squid.personality, Personality) else str(self.squid.personality),\r\n 'timestamp': time.time()\r\n }\r\n\r\n # --- Get dynamic perceptual inputs via hooks ---\r\n if not hasattr(logic, 'brain_hooks'):\r\n perceptual_inputs = {}\r\n else:\r\n try:\r\n perceptual_inputs = logic.brain_hooks.get_input_neuron_values()\r\n logic.brain_hooks.update_decay() # Critical: decay temporal sensors\r\n except Exception as e:\r\n print(f\"[DecisionEngine] Hook error: {e}\")\r\n perceptual_inputs = {}\r\n\r\n decision_data['inputs'] = perceptual_inputs\r\n\r\n # --- Get full current brain state (core + learned + input neurons) ---\r\n try:\r\n brain_state = logic.brain_window.brain_widget.state.copy()\r\n except:\r\n brain_state = {}\r\n\r\n # Ensure perceptual inputs are present even if brain_widget hasn't updated yet\r\n brain_state.update(perceptual_inputs)\r\n decision_data['brain_state'] = brain_state\r\n\r\n # =================================================================\r\n # 2. MEMORY INFLUENCE\r\n # =================================================================\r\n active_memories = self.squid.memory_manager.get_active_memories_data(6)\r\n memory_mod = {\r\n \"eating\": 1.0,\r\n \"playing\": 1.0,\r\n \"exploring\": 1.0,\r\n \"approaching_plant\": 1.0,\r\n \"throwing\": 1.0,\r\n }\r\n\r\n for mem in active_memories:\r\n effect = sum(v for v in mem.get('raw_value', {}).values() if isinstance(v, (int, float))) if isinstance(mem.get('raw_value'), dict) else 0\r\n\r\n if mem['category'] == 'food' and effect > 0:\r\n memory_mod['eating'] *= 1.25\r\n if 'rock' in mem['key'] and effect > 0:\r\n memory_mod['playing'] *= 1.2\r\n memory_mod['throwing'] *= 1.15\r\n if 'poop' in mem['key'] and effect > 0:\r\n memory_mod['playing'] *= 1.1\r\n if 'plant' in mem['key'] and effect > 0:\r\n memory_mod['approaching_plant'] *= 1.3\r\n if 'startled' in mem['key']:\r\n memory_mod['exploring'] *= 0.7\r\n memory_mod['approaching_plant'] *= 1.4\r\n\r\n decision_data['memory_influences'] = memory_mod\r\n\r\n # =================================================================\r\n # 3. URGENCY (NON-LINEAR PHYSIOLOGICAL DRIVE)\r\n # =================================================================\r\n hunger_level = brain_state.get('hunger', 50)\r\n sleepiness = brain_state.get('sleepiness', 50)\r\n\r\n urgency = {\r\n \"eating\": math.pow(1.6, hunger_level / 25),\r\n \"sleeping\": math.pow(1.7, sleepiness / 25),\r\n }\r\n decision_data['urgency_multipliers'] = urgency\r\n\r\n # Immediate overrides\r\n if sleepiness >= 95:\r\n self.squid.go_to_sleep()\r\n decision_data['final_decision'] = \"exhausted\"\r\n decision_data['confidence'] = 1.0\r\n self.last_decision_data = decision_data\r\n return \"exhausted\"\r\n\r\n if self.squid.is_sleeping:\r\n decision_data['final_decision'] = \"sleeping peacefully\"\r\n decision_data['confidence'] = 1.0\r\n self.last_decision_data = decision_data\r\n return \"sleeping peacefully\"\r\n\r\n if brain_state.get('external_stimulus', 0) > 90:\r\n decision_data['final_decision'] = \"startled!\"\r\n decision_data['confidence'] = 1.0\r\n self.last_decision_data = decision_data\r\n return \"startled!\"\r\n\r\n # =================================================================\r\n # 4. BUILD DECISION WEIGHTS FROM BRAIN STATE\r\n # =================================================================\r\n weights = {}\r\n\r\n # Exploration\r\n threat = brain_state.get('threat_level', brain_state.get('anxiety', 50))\r\n external = brain_state.get('external_stimulus', 0)\r\n weights[\"exploring\"] = (\r\n brain_state.get(\"curiosity\", 50) *\r\n max(0.1, 1.0 - threat / 140) *\r\n (0.2 if external > 80 else 1.0)\r\n )\r\n\r\n # Eating\r\n can_see_food = brain_state.get('can_see_food', 0)\r\n weights[\"eating\"] = (\r\n hunger_level *\r\n (3.0 if can_see_food > 80 else 0.3) *\r\n urgency[\"eating\"]\r\n )\r\n\r\n # Plant seeking (comfort)\r\n near_plant = brain_state.get('plant_proximity', 0) > 40\r\n weights[\"approaching_plant\"] = (\r\n (brain_state.get(\"anxiety\", 50) / 40) *\r\n (3.0 if near_plant else 0.5) *\r\n (4.0 if self.squid.personality == Personality.TIMID else 1.8)\r\n )\r\n\r\n # Play / Object interaction\r\n carrying = self.squid.carrying_rock or self.squid.carrying_poop\r\n weights[\"playing\"] = (\r\n brain_state.get(\"satisfaction\", 50) *\r\n brain_state.get(\"curiosity\", 50) / 50 *\r\n (2.2 if carrying else 1.0) *\r\n (0.4 if brain_state.get('is_sick', 0) > 50 else 1.0)\r\n )\r\n\r\n # Throwing (only if carrying)\r\n weights[\"throwing\"] = (\r\n brain_state.get(\"satisfaction\", 50) * 1.3\r\n if carrying else 0\r\n )\r\n\r\n # Sleeping (non-exhausted)\r\n weights[\"sleeping\"] = sleepiness * urgency[\"sleeping\"] * 0.6\r\n\r\n # Fleeing from threat\r\n if threat > 75 or external > 85:\r\n weights[\"fleeing\"] = threat * 1.8\r\n\r\n decision_data['base_weights'] = weights.copy()\r\n\r\n # =================================================================\r\n # 5. APPLY MEMORY + PERSONALITY MODIFIERS\r\n # =================================================================\r\n for action, mod in memory_mod.items():\r\n if action in weights:\r\n weights[action] *= mod\r\n\r\n # Apply personality\r\n if self.squid.personality == Personality.ADVENTUROUS:\r\n weights[\"exploring\"] *= 1.4\r\n weights[\"playing\"] *= 1.3\r\n elif self.squid.personality == Personality.TIMID:\r\n weights[\"exploring\"] *= 0.6\r\n weights[\"approaching_plant\"] *= 1.5\r\n elif self.squid.personality == Personality.GREEDY:\r\n weights[\"eating\"] *= 1.6\r\n elif self.squid.personality == Personality.LAZY:\r\n weights[\"playing\"] *= 0.5\r\n weights[\"exploring\"] *= 0.7\r\n elif self.squid.personality == Personality.ENERGETIC:\r\n weights[\"playing\"] *= 1.5\r\n weights[\"exploring\"] *= 1.2\r\n\r\n # Anxiety amplifies comfort-seeking\r\n if brain_state.get(\"anxiety\", 50) > 60:\r\n weights[\"approaching_plant\"] *= 1.8 + (brain_state.get(\"anxiety\", 0) - 60) / 80\r\n\r\n decision_data['personality_modifiers'] = {k: v/weights.get(k,1) for k,v in weights.items() if k in weights}\r\n\r\n # Add randomness\r\n for k in weights:\r\n weights[k] *= random.uniform(0.88, 1.12)\r\n\r\n decision_data['adjusted_weights'] = weights.copy()\r\n\r\n # =================================================================\r\n # 6. SELECT AND EXECUTE DECISION\r\n # =================================================================\r\n if not any(weights.values()):\r\n final = \"exploring\"\r\n else:\r\n final = max(weights, key=weights.get)\r\n\r\n # Confidence calculation\r\n sorted_w = sorted(weights.values(), reverse=True)\r\n confidence = 1.0 if len(sorted_w) < 2 else (sorted_w[0] - sorted_w[1]) / sorted_w[0]\r\n\r\n decision_data['final_decision'] = final\r\n decision_data['confidence'] = confidence\r\n self.last_decision_data = decision_data\r\n\r\n result = self._execute_neural_decision(final, brain_state)\r\n self.last_decision_data['final_decision'] = result # actual outcome\r\n return result\r\n\r\n def _execute_neural_decision(self, decision: str, brain_state: dict):\r\n \"\"\"Execute decision based purely on neural signals — no redundant scanning\"\"\"\r\n s = self.squid\r\n\r\n if decision == \"eating\" and brain_state.get('can_see_food', 0) > 70:\r\n # Find closest food using existing logic method\r\n food = s.tamagotchi_logic.food_items\r\n if food:\r\n closest = min(food, key=lambda f: s.distance_to(f.pos().x(), f.pos().y()))\r\n s.move_towards(closest.pos().x(), closest.pos().y())\r\n dist = s.distance_to(closest.pos().x(), closest.pos().y())\r\n if dist < 60:\r\n return \"eating\"\r\n elif dist < 120:\r\n return \"approaching food\"\r\n else:\r\n return \"eyeing food\"\r\n\r\n elif decision == \"approaching_plant\" and brain_state.get('plant_proximity', 0) > 30:\r\n # Use decoration cache or scene scan fallback\r\n plants = [item for item in s.tamagotchi_logic.user_interface.scene.items()\r\n if getattr(item, 'category', '') == 'plant']\r\n if plants:\r\n closest = min(plants, key=lambda p: s.distance_to(p.sceneBoundingRect().center().x(),\r\n p.sceneBoundingRect().center().y()))\r\n s.move_towards(closest.sceneBoundingRect().center().x(),\r\n closest.sceneBoundingRect().center().y())\r\n return \"seeking comfort in plant\"\r\n\r\n elif decision in (\"playing\", \"throwing\"):\r\n if s.carrying_rock:\r\n if s.throw_rock(random.choice([\"left\", \"right\"])):\r\n return \"playfully tossing rock\"\r\n elif s.carrying_poop:\r\n if s.throw_poop(random.choice([\"left\", \"right\"])):\r\n return \"flinging poop playfully\"\r\n # Approach nearest rock/poop if visible via brain\r\n elif brain_state.get('can_see_food', 0) == 0: # crude proxy, but better than nothing\r\n targets = [item for item in s.tamagotchi_logic.user_interface.scene.items()\r\n if getattr(item, 'category', '') in ('rock', 'poop')]\r\n if targets:\r\n closest = min(targets, key=lambda t: s.distance_to(t.sceneBoundingRect().center().x(),\r\n t.sceneBoundingRect().center().y()))\r\n s.move_towards(closest.sceneBoundingRect().center().x(),\r\n closest.sceneBoundingRect().center().y())\r\n return \"seeking toy\"\r\n\r\n elif decision == \"sleeping\":\r\n s.go_to_sleep()\r\n return \"settling down to sleep\"\r\n\r\n elif decision == \"fleeing\" or brain_state.get('external_stimulus', 0) > 85:\r\n s.flee_from_center()\r\n return \"fleeing!\"\r\n\r\n # Default: explore with personality flavor\r\n flavors = {\r\n Personality.TIMID: [\"cautiously peeking\", \"nervously watching\"],\r\n Personality.ADVENTUROUS: [\"boldly exploring\", \"seeking adventure\"],\r\n Personality.GREEDY: [\"hunting for food\", \"scouting\"],\r\n Personality.LAZY: [\"lounging\", \"drifting lazily\"],\r\n Personality.ENERGETIC: [\"zooming around\", \"bouncing energetically\"],\r\n Personality.STUBBORN: [\"patrolling territory\", \"standing ground\"],\r\n }.get(s.personality, [\"wandering\", \"exploring curiously\"])\r\n\r\n style = random.choice(flavors)\r\n if \"zoom\" in style or \"bounc\" in style:\r\n s.move_erratically()\r\n elif \"loung\" in style or \"drift\" in style:\r\n s.move_slowly()\r\n else:\r\n s.move_randomly()\r\n\r\n return style\r\n"
},
{
"path": "src/decoration_stats.json",
"content": "{\r\n \"plant01.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -2,\r\n \"category\": \"plant\"\r\n },\r\n \"plant02.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -3,\r\n \"category\": \"plant\"\r\n },\r\n \"plant03.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -2,\r\n \"category\": \"plant\"\r\n },\r\n \"plant04.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -3,\r\n \"category\": \"plant\"\r\n },\r\n \"plant05.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -4,\r\n \"category\": \"plant\"\r\n },\r\n \"plant06.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"category\": \"plant\",\r\n \"anxiety\": -2\r\n },\r\n \"plant07.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -3,\r\n \"category\": \"plant\"\r\n },\r\n \"plant08.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -4,\r\n \"category\": \"plant\"\r\n },\r\n \"plant09.png\": {\r\n \"happiness\": 1,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -2,\r\n \"category\": \"plant\"\r\n },\r\n \"plant10.png\": {\r\n \"happiness\": 1,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -3,\r\n \"category\": \"plant\"\r\n },\r\n \"plant11.png\": {\r\n \"happiness\": 1,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -4,\r\n \"category\": \"plant\"\r\n },\r\n \"plant12.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -5,\r\n \"category\": \"plant\"\r\n },\r\n \"sml_plant01.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -4,\r\n \"category\": \"plant\"\r\n },\r\n \"sml_plant02.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -5,\r\n \"category\": \"plant\"\r\n },\r\n \"rock03.png\": {\r\n \"happiness\": 4,\r\n \"satisfaction\": 4,\r\n \"category\": \"rock\"\r\n },\r\n \"rock01.png\": {\r\n \"happiness\": 4,\r\n \"satisfaction\": 4,\r\n \"category\": \"rock\"\r\n },\r\n \"rock02.png\": {\r\n \"happiness\": 4,\r\n \"satisfaction\": 3,\r\n \"category\": \"rock\"\r\n },\r\n \"Znewplant01.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -3,\r\n \"category\": \"plant\"\r\n },\r\n \"Znewplant02.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -4,\r\n \"category\": \"plant\"\r\n },\r\n \"Znewplant03.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"anxiety\": -2,\r\n \"category\": \"plant\"\r\n },\r\n \"Znewplant04.png\": {\r\n \"happiness\": 1,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -3,\r\n \"category\": \"plant\"\r\n },\r\n \"Znewplant05.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -5,\r\n \"category\": \"plant\"\r\n },\r\n \"Znewplant06.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 1,\r\n \"category\": \"plant\",\r\n \"anxiety\": -2\r\n },\r\n \"Znewplant07.png\": {\r\n \"happiness\": 1,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -4,\r\n \"category\": \"plant\"\r\n },\r\n \"Znewplant08.png\": {\r\n \"happiness\": 2,\r\n \"cleanliness\": 2,\r\n \"anxiety\": -5,\r\n \"category\": \"plant\"\r\n }\r\n}"
},
{
"path": "src/designer_canvas.py",
"content": "\"\"\"\r\nCanvas implementation for Brain Designer.\r\nHandles visual representation and interaction.\r\n\"\"\"\r\n\r\nimport math\r\nimport json\r\nimport os\r\nfrom PyQt5.QtWidgets import (\r\n QGraphicsItem, QGraphicsView, QGraphicsScene, QGraphicsEllipseItem, \r\n QGraphicsLineItem, QGraphicsTextItem, QGraphicsRectItem, QStyle, QToolTip,\r\n QDialog, QVBoxLayout, QHBoxLayout, QLabel, QDoubleSpinBox, QPushButton,\r\n QCheckBox, QMessageBox\r\n)\r\nfrom PyQt5.QtCore import Qt, QPointF, QRectF, QLineF, pyqtSignal, QTimer\r\nfrom PyQt5.QtGui import (\r\n QPainter, QPen, QBrush, QColor, QFont, QFontMetrics, QPainterPath, \r\n QRadialGradient, QTransform, QCursor, QPainterPathStroker, QPolygonF\r\n)\r\n\r\nfrom .designer_core import BrainDesign\r\nfrom .designer_constants import (\r\n NeuronType, CORE_NEURON_RING_COLOR, INPUT_SENSOR_RING_COLOR, \r\n CUSTOM_NEURON_RING_COLOR, PROTECTED_RING_WIDTH, NORMAL_RING_WIDTH, \r\n DEFAULT_LAYER_HEIGHT\r\n)\r\n\r\n\r\nclass SmartConnectionItem(QGraphicsItem):\r\n \"\"\"Visual representation of a neural connection with organic growth animation.\"\"\"\r\n \r\n def __init__(self, source_pos, target_pos, weight=0.5, source_name=\"\", target_name=\"\", parent=None):\r\n super().__init__(parent)\r\n self.source_pos = source_pos\r\n self.target_pos = target_pos\r\n self.weight = weight\r\n self.source_name = source_name\r\n self.target_name = target_name\r\n \r\n # Visual states\r\n self.is_selected = False\r\n self.is_hovered = False\r\n self.is_dying = False # If True, connection is retreating/fading out\r\n \r\n # Organic Animation States\r\n self.growth = 0.0 # 0.0 = at source, 1.0 = full connection\r\n self.opacity = 0.0 # 0.0 = invisible, 1.0 = fully visible\r\n \r\n # Randomized \"Personality\" for this vine\r\n self.growth_speed = 0.02 + (hash(str(source_pos) + str(target_pos)) % 50) * 0.0006\r\n self.growth = -0.1 # Start slightly delayed\r\n \r\n # Pulse animation (standard)\r\n self.pulse_phase = 0.0\r\n \r\n self.setAcceptHoverEvents(True)\r\n self.setZValue(-5) \r\n self.hit_thickness = 25 \r\n\r\n def boundingRect(self):\r\n extra = 30\r\n # protect against null-length line\r\n if self.source_pos == self.target_pos:\r\n return QRectF(self.source_pos.x() - extra, self.source_pos.y() - extra,\r\n 2 * extra, 2 * extra)\r\n return QRectF(self.source_pos, self.target_pos).normalized() \\\r\n .adjusted(-extra, -extra, extra, extra)\r\n\r\n def shape(self):\r\n \"\"\"Custom hit area for connection lines.\"\"\"\r\n path = QPainterPath()\r\n path.moveTo(self.source_pos)\r\n path.lineTo(self.target_pos)\r\n \r\n # Create a stroker to widen the hit area\r\n stroker = QPainterPathStroker()\r\n stroker.setWidth(self.hit_thickness)\r\n stroker.setCapStyle(Qt.RoundCap)\r\n return stroker.createStroke(path)\r\n \r\n def hoverEnterEvent(self, event):\r\n self.is_hovered = True\r\n self.update()\r\n super().hoverEnterEvent(event)\r\n\r\n def hoverLeaveEvent(self, event):\r\n self.is_hovered = False\r\n self.update()\r\n super().hoverLeaveEvent(event)\r\n \r\n def advance_animation(self):\r\n \"\"\"Calculates one frame of growth/retreat logic.\"\"\"\r\n \r\n # 1. Handle Dying (Retreating)\r\n if self.is_dying:\r\n self.growth -= self.growth_speed * 1.5\r\n self.opacity -= 0.05\r\n if self.opacity < 0: self.opacity = 0\r\n return self.opacity <= 0\r\n\r\n # 2. Handle Living (Growing)\r\n if self.growth < 1.0:\r\n self.growth += self.growth_speed\r\n if self.growth > 1.0: self.growth = 1.0\r\n \r\n # Fade in\r\n if self.growth > 0 and self.opacity < 1.0:\r\n self.opacity += 0.05\r\n if self.opacity > 1.0: self.opacity = 1.0\r\n \r\n # 3. Pulse Logic\r\n if self.growth > 0.8:\r\n current_speed = 0.02 + (abs(self.weight) * 0.06)\r\n self.pulse_phase += current_speed\r\n if self.pulse_phase > 1.0: self.pulse_phase = 0.0\r\n\r\n self.update()\r\n return False # Still alive\r\n\r\n def paint(self, painter, option, widget):\r\n painter.save()\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n\r\n # Draw hover glow (subtle blue when hovered but not selected)\r\n if self.is_hovered and not self.is_selected:\r\n pen_width = 12\r\n glow_color = QColor(100, 200, 255, 100)\r\n painter.setPen(QPen(glow_color, pen_width, Qt.SolidLine, Qt.RoundCap))\r\n painter.drawLine(self.source_pos, self.target_pos)\r\n\r\n # Draw the actual connection line\r\n # Determine color based on weight (Green=Excitatory, Red=Inhibitory)\r\n base_color = QColor(50, 205, 50) if self.weight >= 0 else QColor(220, 50, 50)\r\n \r\n # Adjust alpha by opacity (growth animation)\r\n base_color.setAlpha(int(255 * self.opacity))\r\n \r\n # Determine thickness (magnitude of weight)\r\n thickness = 2 + abs(self.weight) * 6\r\n \r\n # Pulse effect for thickness\r\n pulse = math.sin(self.pulse_phase * math.pi * 2) * 0.5 + 0.5\r\n thickness += pulse * 1.5\r\n\r\n # Draw selection highlight (yellow glow when selected)\r\n if self.is_selected:\r\n painter.setPen(QPen(QColor(255, 215, 0), thickness + 4, Qt.SolidLine, Qt.RoundCap))\r\n painter.drawLine(self.source_pos, self.target_pos)\r\n\r\n painter.setPen(QPen(base_color, thickness, Qt.SolidLine, Qt.RoundCap))\r\n painter.drawLine(self.source_pos, self.target_pos)\r\n \r\n painter.restore()\r\n\r\n\r\nclass ConnectorNeuronItem(QGraphicsItem):\r\n \"\"\"\r\n Connector Neuron: Black hexagon with a white 'c' inside.\r\n Matches brain_widget.py's draw_hexagon_neuron style.\r\n \"\"\"\r\n \r\n def __init__(self, x, y, radius, name, parent=None):\r\n super().__init__(parent)\r\n self.name = name\r\n self.radius = radius\r\n self.is_selected = False\r\n self.is_hovered = False\r\n self.neuron_type = NeuronType.CONNECTOR\r\n \r\n self.setPos(x, y)\r\n self.setAcceptHoverEvents(True)\r\n self.setData(0, ('neuron', name))\r\n self.setZValue(2)\r\n \r\n def boundingRect(self):\r\n extra = 15\r\n return QRectF(-self.radius - extra, -self.radius - extra,\r\n (self.radius + extra) * 2, (self.radius + extra) * 2)\r\n \r\n def shape(self):\r\n \"\"\"Custom hitbox for Hexagon.\"\"\"\r\n path = QPainterPath()\r\n sides = 6\r\n polygon = QPolygonF()\r\n angle_step = 360.0 / sides\r\n for i in range(sides):\r\n angle = math.radians(i * angle_step - 90)\r\n polygon.append(QPointF(self.radius * math.cos(angle), \r\n self.radius * math.sin(angle)))\r\n path.addPolygon(polygon)\r\n path.closeSubpath()\r\n return path\r\n \r\n def hoverEnterEvent(self, event):\r\n self.is_hovered = True\r\n self.update()\r\n super().hoverEnterEvent(event)\r\n \r\n def hoverLeaveEvent(self, event):\r\n self.is_hovered = False\r\n self.update()\r\n super().hoverLeaveEvent(event)\r\n \r\n def paint(self, painter, option, widget):\r\n painter.save()\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n # Draw hover glow\r\n if self.is_hovered and not self.is_selected:\r\n grad = QRadialGradient(0, 0, self.radius + 12)\r\n grad.setColorAt(0.5, QColor(100, 200, 255, 100))\r\n grad.setColorAt(1.0, QColor(100, 200, 255, 0))\r\n painter.setBrush(QBrush(grad))\r\n painter.setPen(Qt.NoPen)\r\n painter.drawEllipse(QPointF(0, 0), self.radius + 12, self.radius + 12)\r\n \r\n # Draw selection ring\r\n if self.is_selected:\r\n painter.setPen(QPen(QColor(255, 255, 255), 4))\r\n painter.setBrush(Qt.NoBrush)\r\n painter.drawEllipse(QPointF(0, 0), self.radius + 5, self.radius + 5)\r\n \r\n # Draw BLACK hexagon body\r\n sides = 6\r\n polygon = QPolygonF()\r\n angle_step = 360.0 / sides\r\n for i in range(sides):\r\n angle = math.radians(i * angle_step - 90)\r\n polygon.append(QPointF(self.radius * math.cos(angle), \r\n self.radius * math.sin(angle)))\r\n \r\n painter.setBrush(QBrush(QColor(0, 0, 0))) # BLACK fill\r\n painter.setPen(QPen(QColor(50, 50, 50), 2))\r\n painter.drawPolygon(polygon)\r\n \r\n # Draw WHITE 'c' inside\r\n font = QFont(\"Arial\", int(self.radius * 0.7))\r\n font.setBold(True)\r\n painter.setFont(font)\r\n painter.setPen(QColor(255, 255, 255)) # WHITE text\r\n \r\n rect = QRectF(-self.radius, -self.radius, self.radius * 2, self.radius * 2)\r\n painter.drawText(rect, Qt.AlignCenter, \"c\")\r\n \r\n painter.restore()\r\n\r\n\r\nclass NeuronItem(QGraphicsEllipseItem):\r\n \"\"\"\r\n Neuron body. \r\n Acts as the Parent item for the Ring and Label.\r\n \"\"\"\r\n \r\n def __init__(self, x, y, radius, name, neuron_type=None, parent=None):\r\n # Define geometry centered at (0,0) locally\r\n super().__init__(-radius, -radius, radius * 2, radius * 2, parent)\r\n self.name = name\r\n self.radius = radius\r\n self.is_selected = False\r\n self.is_hovered = False\r\n self.neuron_type = neuron_type\r\n # Set absolute position in the scene\r\n self.setPos(x, y)\r\n \r\n self.setAcceptHoverEvents(True)\r\n self.setData(0, ('neuron', name))\r\n self.setZValue(2)\r\n\r\n def event(self, event):\r\n if self.scene() is None:\r\n return False\r\n return super().event(event)\r\n \r\n def hoverEnterEvent(self, event):\r\n self.is_hovered = True\r\n self.update()\r\n super().hoverEnterEvent(event)\r\n \r\n def hoverLeaveEvent(self, event):\r\n self.is_hovered = False\r\n self.update()\r\n super().hoverLeaveEvent(event)\r\n \r\n def paint(self, painter, option, widget):\r\n # Draw hover glow\r\n if self.is_hovered and not self.is_selected:\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n # Glow is drawn relative to local center (0,0)\r\n grad = QRadialGradient(0, 0, self.radius + 12)\r\n grad.setColorAt(0.5, QColor(100, 200, 255, 100))\r\n grad.setColorAt(1.0, QColor(100, 200, 255, 0))\r\n painter.setBrush(QBrush(grad))\r\n painter.setPen(Qt.NoPen)\r\n painter.drawEllipse(-self.radius - 12, -self.radius - 12, (self.radius + 12)*2, (self.radius + 12)*2)\r\n \r\n super().paint(painter, option, widget)\r\n\r\n\r\nclass DesignerConfig:\r\n \"\"\"Manages designer preferences.\"\"\"\r\n def __init__(self, config_path=None):\r\n if config_path is None:\r\n config_dir = os.path.expanduser(\"~/.dosidicus\")\r\n os.makedirs(config_dir, exist_ok=True)\r\n config_path = os.path.join(config_dir, \"designer_config.json\")\r\n self.config_path = config_path\r\n self.config = self._load_config()\r\n \r\n def _load_config(self):\r\n if os.path.exists(self.config_path):\r\n try:\r\n with open(self.config_path, 'r') as f:\r\n return json.load(f)\r\n except: pass\r\n return {'confirm_connection_delete': True}\r\n \r\n def save(self):\r\n try:\r\n with open(self.config_path, 'w') as f:\r\n json.dump(self.config, f, indent=2)\r\n except: pass\r\n \r\n def get(self, key, default=None):\r\n return self.config.get(key, default)\r\n \r\n def set(self, key, value):\r\n self.config[key] = value\r\n self.save()\r\n\r\n\r\nclass ConfirmDeleteDialog(QDialog):\r\n \"\"\"Confirmation dialog.\"\"\"\r\n def __init__(self, source, target, parent=None):\r\n super().__init__(parent)\r\n self.setWindowTitle(\"Delete Connection\")\r\n self.dont_ask_again = False\r\n layout = QVBoxLayout()\r\n msg = QLabel(f\"Are you sure you want to delete the connection:\\n{source} → {target}?\")\r\n msg.setWordWrap(True)\r\n layout.addWidget(msg)\r\n self.checkbox = QCheckBox(\"Don't ask again\")\r\n layout.addWidget(self.checkbox)\r\n button_layout = QHBoxLayout()\r\n self.yes_button = QPushButton(\"Yes, Delete\")\r\n self.yes_button.clicked.connect(self.accept)\r\n self.no_button = QPushButton(\"Cancel\")\r\n self.no_button.clicked.connect(self.reject)\r\n button_layout.addWidget(self.no_button)\r\n button_layout.addWidget(self.yes_button)\r\n layout.addLayout(button_layout)\r\n self.setLayout(layout)\r\n self.yes_button.setDefault(True)\r\n \r\n def accept(self):\r\n self.dont_ask_again = self.checkbox.isChecked()\r\n super().accept()\r\n\r\n\r\nclass ConnectionWeightDialog(QDialog):\r\n \"\"\"Dialog for editing connection weight.\"\"\"\r\n def __init__(self, source, target, current_weight, config, parent=None):\r\n super().__init__(parent)\r\n self.source = source\r\n self.target = target\r\n self.config = config\r\n self.delete_requested = False\r\n self.setWindowTitle(\"Edit Connection\")\r\n self.setModal(True)\r\n layout = QVBoxLayout()\r\n info_label = QLabel(f\"Connection: {source} → {target}\")\r\n info_label.setStyleSheet(\"font-weight: bold;\")\r\n layout.addWidget(info_label)\r\n weight_layout = QHBoxLayout()\r\n weight_layout.addWidget(QLabel(\"Weight:\"))\r\n self.weight_spin = QDoubleSpinBox()\r\n self.weight_spin.setRange(-1.0, 1.0)\r\n self.weight_spin.setSingleStep(0.05)\r\n self.weight_spin.setDecimals(3)\r\n self.weight_spin.setValue(current_weight)\r\n self.weight_spin.setMinimumWidth(100)\r\n weight_layout.addWidget(self.weight_spin)\r\n layout.addLayout(weight_layout)\r\n info_text = QLabel(\"Positive = Excitatory (green), Negative = Inhibitory (red)\")\r\n info_text.setStyleSheet(\"color: gray; font-size: 9pt;\")\r\n layout.addWidget(info_text)\r\n layout.addSpacing(10)\r\n button_layout = QHBoxLayout()\r\n self.delete_button = QPushButton(\"Delete Connection\")\r\n self.delete_button.setStyleSheet(\"background-color: #d32f2f; color: white;\")\r\n self.delete_button.clicked.connect(self.on_delete_clicked)\r\n button_layout.addWidget(self.delete_button)\r\n button_layout.addStretch()\r\n self.cancel_button = QPushButton(\"Cancel\")\r\n self.cancel_button.clicked.connect(self.reject)\r\n button_layout.addWidget(self.cancel_button)\r\n self.ok_button = QPushButton(\"OK\")\r\n self.ok_button.clicked.connect(self.accept)\r\n self.ok_button.setDefault(True)\r\n button_layout.addWidget(self.ok_button)\r\n layout.addLayout(button_layout)\r\n self.setLayout(layout)\r\n self.weight_spin.setFocus()\r\n self.weight_spin.selectAll()\r\n \r\n def on_delete_clicked(self):\r\n should_confirm = self.config.get('confirm_connection_delete', True)\r\n if should_confirm:\r\n confirm_dlg = ConfirmDeleteDialog(self.source, self.target, self)\r\n result = confirm_dlg.exec_()\r\n if result == QDialog.Accepted:\r\n if confirm_dlg.dont_ask_again:\r\n self.config.set('confirm_connection_delete', False)\r\n self.delete_requested = True\r\n self.reject()\r\n else:\r\n self.delete_requested = True\r\n self.reject()\r\n \r\n def get_weight(self):\r\n return self.weight_spin.value()\r\n\r\n\r\nclass BrainCanvas(QGraphicsView):\r\n \"\"\"Main canvas for visualizing and editing brain designs.\"\"\"\r\n \r\n # Signals\r\n neuronSelected = pyqtSignal(str) \r\n neuronMoved = pyqtSignal(str, float, float)\r\n connectionCreated = pyqtSignal(str, str)\r\n connectionSelected = pyqtSignal(str, str)\r\n connectionDeleted = pyqtSignal(str, str)\r\n canvasClicked = pyqtSignal(float, float)\r\n weightChanged = pyqtSignal(str, str, float)\r\n connectionReversed = pyqtSignal(str, str)\r\n \r\n NEURON_RADIUS = 25\r\n WEIGHT_STEP = 0.05\r\n WEIGHT_STEP_LARGE = 0.25\r\n \r\n GRID_SIZE_MINOR = 25\r\n GRID_SIZE_MAJOR = 100\r\n GRID_COLOR_MINOR = QColor(220, 220, 230, 100)\r\n GRID_COLOR_MAJOR = QColor(200, 200, 215, 150)\r\n \r\n def __init__(self, design: BrainDesign, parent=None):\r\n super().__init__(parent)\r\n self.design = design\r\n self.scene = QGraphicsScene(self)\r\n self.setScene(self.scene)\r\n self.config = DesignerConfig()\r\n \r\n self.selected_neuron = None\r\n self.selected_connection_key = None\r\n \r\n self.pan_active = False\r\n self.pan_start_pos = QPointF()\r\n self.drag_line = None\r\n self.drag_source_id = None\r\n self.drag_start_pos = None\r\n self.zoom_level = 1.0\r\n \r\n self.dragging_neuron = None\r\n self.neuron_drag_start_pos = None\r\n \r\n self.neuron_items = {}\r\n self.connection_items = {}\r\n \r\n self.setRenderHint(QPainter.Antialiasing)\r\n self.setRenderHint(QPainter.SmoothPixmapTransform)\r\n self.setDragMode(QGraphicsView.NoDrag)\r\n self.setMouseTracking(True)\r\n self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)\r\n self.scene.setSceneRect(-500, -200, 1500, 800)\r\n self.setFocusPolicy(Qt.StrongFocus)\r\n \r\n self.rebuild()\r\n \r\n self.anim_timer = QTimer(self)\r\n self.anim_timer.timeout.connect(self.animate_network)\r\n self.anim_timer.start(33)\r\n\r\n def drawBackground(self, painter, rect):\r\n painter.fillRect(rect, QColor(245, 245, 250))\r\n left = int(rect.left()) - (int(rect.left()) % self.GRID_SIZE_MINOR) - self.GRID_SIZE_MINOR\r\n top = int(rect.top()) - (int(rect.top()) % self.GRID_SIZE_MINOR) - self.GRID_SIZE_MINOR\r\n right = int(rect.right()) + self.GRID_SIZE_MINOR\r\n bottom = int(rect.bottom()) + self.GRID_SIZE_MINOR\r\n \r\n painter.setRenderHint(QPainter.Antialiasing, False)\r\n painter.setPen(QPen(self.GRID_COLOR_MINOR, 1))\r\n \r\n x = left\r\n while x <= right:\r\n if x % self.GRID_SIZE_MAJOR != 0:\r\n painter.drawLine(x, top, x, bottom)\r\n x += self.GRID_SIZE_MINOR\r\n \r\n y = top\r\n while y <= bottom:\r\n if y % self.GRID_SIZE_MAJOR != 0:\r\n painter.drawLine(left, y, right, y)\r\n y += self.GRID_SIZE_MINOR\r\n \r\n painter.setPen(QPen(self.GRID_COLOR_MAJOR, 1.5))\r\n major_left = left - (left % self.GRID_SIZE_MAJOR)\r\n x = major_left\r\n while x <= right:\r\n painter.drawLine(x, top, x, bottom)\r\n x += self.GRID_SIZE_MAJOR\r\n \r\n major_top = top - (top % self.GRID_SIZE_MAJOR)\r\n y = major_top\r\n while y <= bottom:\r\n painter.drawLine(left, y, right, y)\r\n y += self.GRID_SIZE_MAJOR\r\n \r\n if left <= 0 <= right:\r\n painter.setPen(QPen(QColor(180, 180, 200, 180), 2))\r\n painter.drawLine(0, top, 0, bottom)\r\n if top <= 0 <= bottom:\r\n painter.setPen(QPen(QColor(180, 180, 200, 180), 2))\r\n painter.drawLine(left, 0, right, 0)\r\n\r\n def animate_network(self):\r\n for item in self.connection_items.values():\r\n item.advance_animation()\r\n if hasattr(self, 'dying_connections'):\r\n for i in range(len(self.dying_connections) - 1, -1, -1):\r\n item = self.dying_connections[i]\r\n is_dead = item.advance_animation()\r\n if is_dead:\r\n self.scene.removeItem(item)\r\n self.dying_connections.pop(i)\r\n\r\n def rebuild(self):\r\n \"\"\"Synchronizes the visual scene with the design data.\"\"\"\r\n self.scene.blockSignals(True)\r\n \r\n # 1. Update Layers\r\n for item in self.scene.items():\r\n if not isinstance(item, (NeuronItem, ConnectorNeuronItem, SmartConnectionItem)) and item.zValue() < 0:\r\n if isinstance(item, (QGraphicsRectItem, QGraphicsTextItem)): \r\n if item.zValue() < -5: self.scene.removeItem(item)\r\n self.draw_layers()\r\n\r\n # 2. Update Neurons\r\n existing_neurons = set(self.neuron_items.keys())\r\n design_neurons = set(self.design.neurons.keys())\r\n \r\n for name in existing_neurons - design_neurons:\r\n self.scene.removeItem(self.neuron_items[name])\r\n del self.neuron_items[name]\r\n \r\n for name in design_neurons:\r\n neuron = self.design.neurons[name]\r\n if neuron.position is None: continue\r\n \r\n x, y = neuron.position\r\n \r\n if name in self.neuron_items:\r\n # Update existing position\r\n self.neuron_items[name].setPos(x, y) \r\n else:\r\n self.draw_single_neuron(name, neuron)\r\n\r\n # 3. Connection Update\r\n existing_keys = set(self.connection_items.keys())\r\n design_keys = set()\r\n for conn in self.design.connections:\r\n design_keys.add((conn.source, conn.target))\r\n \r\n for key in existing_keys - design_keys:\r\n item = self.connection_items[key]\r\n item.is_dying = True\r\n del self.connection_items[key]\r\n if not hasattr(self, 'dying_connections'):\r\n self.dying_connections = []\r\n self.dying_connections.append(item)\r\n\r\n for conn in self.design.connections:\r\n key = (conn.source, conn.target)\r\n src_neuron = self.design.get_neuron(conn.source)\r\n tgt_neuron = self.design.get_neuron(conn.target)\r\n \r\n if not (src_neuron and tgt_neuron and src_neuron.position and tgt_neuron.position):\r\n continue\r\n\r\n src_pos = QPointF(*src_neuron.position)\r\n tgt_pos = QPointF(*tgt_neuron.position)\r\n\r\n if key not in existing_keys:\r\n item = SmartConnectionItem(src_pos, tgt_pos, conn.weight, conn.source, conn.target)\r\n item.setData(0, conn)\r\n if self.selected_connection_key == key: item.is_selected = True\r\n self.scene.addItem(item)\r\n self.connection_items[key] = item\r\n else:\r\n item = self.connection_items[key]\r\n item.is_dying = False \r\n \r\n # Check for weight change to ensure visual thickness updates\r\n if item.weight != conn.weight:\r\n item.weight = conn.weight\r\n item.update()\r\n \r\n if self.selected_connection_key == key: item.is_selected = True\r\n else: item.is_selected = False\r\n \r\n if src_pos != item.source_pos or tgt_pos != item.target_pos:\r\n item.prepareGeometryChange()\r\n item.source_pos = src_pos\r\n item.target_pos = tgt_pos\r\n item.update()\r\n\r\n self.center_on_neurons()\r\n self.scene.blockSignals(False)\r\n \r\n def draw_layers(self):\r\n for layer in self.design.layers:\r\n y_pos = layer.y_position\r\n rect_height = DEFAULT_LAYER_HEIGHT\r\n rect_top = y_pos - rect_height / 2\r\n \r\n lt = layer.layer_type.name.lower()\r\n if lt == 'input': fill, border = (180, 235, 180, 100), (120, 180, 120, 150)\r\n elif lt == 'output': fill, border = (235, 180, 180, 100), (180, 120, 120, 150)\r\n else: fill, border = (200, 200, 235, 100), (160, 160, 200, 150)\r\n\r\n rect = QGraphicsRectItem(-400, rect_top, 1300, rect_height)\r\n rect.setBrush(QBrush(QColor(*fill)))\r\n rect.setPen(QPen(QColor(*border), 2, Qt.DashLine))\r\n rect.setZValue(-10)\r\n self.scene.addItem(rect)\r\n\r\n label = QGraphicsTextItem(layer.name)\r\n label.setDefaultTextColor(QColor(*border[:3]))\r\n label.setFont(QFont(\"Arial\", 11, QFont.Bold))\r\n label.setPos(-380, rect_top + 5)\r\n label.setZValue(-9)\r\n self.scene.addItem(label)\r\n\r\n def draw_single_neuron(self, name, neuron):\r\n \"\"\"Draw a single neuron item (Body) and attach its children (Ring, Label).\"\"\"\r\n if neuron.position is None: return\r\n\r\n try:\r\n x, y = neuron.position\r\n except (TypeError, ValueError): return\r\n\r\n # Determine Shape\r\n shape = getattr(neuron, 'shape', 'circle')\r\n\r\n # --- CASE 1: CONNECTOR (Hexagon) ---\r\n is_connector = (neuron.neuron_type == NeuronType.CONNECTOR or \r\n name.startswith('connector_') or\r\n shape == 'hexagon')\r\n \r\n if is_connector:\r\n # Use the special ConnectorNeuronItem (black hexagon with 'c')\r\n body = ConnectorNeuronItem(x, y, self.NEURON_RADIUS, name)\r\n body.is_selected = (name == self.selected_neuron)\r\n self.scene.addItem(body)\r\n self.neuron_items[name] = body\r\n \r\n # Create Label (Child of Body) - simplified for connectors\r\n display = name.replace('_', ' ').title()\r\n label = QGraphicsTextItem(display)\r\n label.setDefaultTextColor(QColor(40, 40, 50))\r\n label.setFont(QFont(\"Arial\", 8, QFont.Bold))\r\n \r\n # Center text horizontally relative to body center (0,0)\r\n w = label.boundingRect().width()\r\n label.setPos(-w / 2, self.NEURON_RADIUS + 5)\r\n label.setZValue(3)\r\n label.setParentItem(body)\r\n return\r\n\r\n # --- CASE 2: POLYGONS (Diamond, Square, Triangle) ---\r\n if shape in ['diamond', 'square', 'triangle']:\r\n sides = 4\r\n rotation = 0\r\n if shape == 'diamond':\r\n sides = 4\r\n rotation = 0\r\n elif shape == 'square':\r\n sides = 4\r\n rotation = 45\r\n elif shape == 'triangle':\r\n sides = 3\r\n rotation = 0\r\n \r\n # Create Polygon Body\r\n body = PolygonNeuronItem(x, y, self.NEURON_RADIUS, name, \r\n sides=sides, rotation=rotation, \r\n color=neuron.color)\r\n body.is_selected = (name == self.selected_neuron)\r\n self.scene.addItem(body)\r\n self.neuron_items[name] = body\r\n\r\n # Create Label (Child of Body)\r\n display = name.replace('_', ' ').title()\r\n label = QGraphicsTextItem(display)\r\n label.setDefaultTextColor(QColor(40, 40, 50))\r\n label.setFont(QFont(\"Arial\", 9, QFont.Bold))\r\n \r\n w = label.boundingRect().width()\r\n label.setPos(-w / 2, self.NEURON_RADIUS + 5)\r\n label.setZValue(3)\r\n label.setParentItem(body)\r\n return\r\n\r\n # --- CASE 3: CIRCLE (Default) ---\r\n # 1. Create Neuron Body (The Parent Item) - standard ellipse\r\n body = NeuronItem(x, y, self.NEURON_RADIUS, name, neuron.neuron_type)\r\n body.setBrush(QBrush(QColor(*neuron.color)))\r\n body.setPen(QPen(QColor(50, 50, 50), 2))\r\n body.is_selected = (name == self.selected_neuron)\r\n \r\n self.scene.addItem(body)\r\n self.neuron_items[name] = body\r\n\r\n # 2. Determine Ring Style (Only for circles)\r\n if neuron.is_core:\r\n ring_color = QColor(*CORE_NEURON_RING_COLOR)\r\n ring_width = PROTECTED_RING_WIDTH\r\n elif neuron.is_required:\r\n ring_color = QColor(*INPUT_SENSOR_RING_COLOR)\r\n ring_width = PROTECTED_RING_WIDTH\r\n elif neuron.is_sensor:\r\n ring_color = QColor(*INPUT_SENSOR_RING_COLOR)\r\n ring_width = NORMAL_RING_WIDTH\r\n else:\r\n ring_color = QColor(*CUSTOM_NEURON_RING_COLOR)\r\n ring_width = NORMAL_RING_WIDTH\r\n\r\n if name == self.selected_neuron:\r\n ring_color = QColor(255, 255, 255)\r\n ring_width = 4\r\n\r\n # 3. Create Ring (Child of Body)\r\n r_outer = self.NEURON_RADIUS + 3\r\n outer = QGraphicsEllipseItem(-r_outer, -r_outer, r_outer * 2, r_outer * 2)\r\n outer.setPen(QPen(ring_color, ring_width))\r\n outer.setZValue(1) \r\n outer.setData(0, ('ring', name))\r\n outer.setParentItem(body)\r\n outer.setFlag(QGraphicsItem.ItemStacksBehindParent)\r\n\r\n # 4. Create Label (Child of Body)\r\n display = name.replace('_', ' ').title()\r\n # Add icons for specific types\r\n if neuron.is_core: display = f\"🟡 {display}\"\r\n elif name == 'can_see_food': display = f\"👁 {display}\"\r\n elif neuron.is_sensor: display = f\"📡 {display}\"\r\n \r\n label = QGraphicsTextItem(display)\r\n label.setDefaultTextColor(QColor(40, 40, 50))\r\n label.setFont(QFont(\"Arial\", 9, QFont.Bold))\r\n \r\n # Center text horizontally relative to body center (0,0)\r\n w = label.boundingRect().width()\r\n label.setPos(-w / 2, self.NEURON_RADIUS + 5)\r\n label.setZValue(3)\r\n label.setParentItem(body)\r\n\r\n\r\n def draw_neurons(self):\r\n for name, neuron in self.design.neurons.items():\r\n self.draw_single_neuron(name, neuron)\r\n\r\n def center_on_neurons(self):\r\n if not self.design.neurons or self.pan_active: return\r\n valid_positions = []\r\n for n in self.design.neurons.values():\r\n if n.position is not None:\r\n try:\r\n x, y = n.position\r\n if x is not None and y is not None:\r\n valid_positions.append((x, y))\r\n except: continue\r\n \r\n if not valid_positions: return\r\n xs = [p[0] for p in valid_positions]\r\n ys = [p[1] for p in valid_positions]\r\n self.scene.setSceneRect(QRectF(\r\n min(xs) - 100, min(ys) - 100, \r\n max(xs) - min(xs) + 200, max(ys) - min(ys) + 200\r\n ))\r\n\r\n def get_neuron_at(self, pos):\r\n for name, neuron in self.design.neurons.items():\r\n if neuron.position is None: continue\r\n x, y = neuron.position\r\n if math.hypot(pos.x() - x, pos.y() - y) <= self.NEURON_RADIUS + 5:\r\n return name\r\n return None\r\n \r\n def get_connection_at(self, pos):\r\n items = self.scene.items(pos)\r\n for item in items:\r\n if isinstance(item, SmartConnectionItem):\r\n return item\r\n return None\r\n\r\n # MOUSE EVENTS\r\n def mousePressEvent(self, event):\r\n self.setFocus()\r\n scene_pos = self.mapToScene(event.pos())\r\n \r\n if event.button() == Qt.RightButton or event.button() == Qt.MiddleButton:\r\n self.pan_active = True\r\n self.pan_start_pos = event.pos()\r\n self.setCursor(Qt.ClosedHandCursor)\r\n event.accept()\r\n return\r\n\r\n if event.button() == Qt.LeftButton:\r\n clicked_neuron = self.get_neuron_at(scene_pos)\r\n if clicked_neuron:\r\n self.select_neuron(clicked_neuron)\r\n if event.modifiers() & Qt.ControlModifier:\r\n self.dragging_neuron = clicked_neuron\r\n self.neuron_drag_start_pos = scene_pos\r\n event.accept()\r\n return\r\n \r\n n_obj = self.design.get_neuron(clicked_neuron)\r\n if n_obj.neuron_type != NeuronType.OUTPUT:\r\n self.start_connection_drag(clicked_neuron, scene_pos)\r\n event.accept()\r\n return\r\n\r\n conn_item = self.get_connection_at(scene_pos)\r\n if conn_item:\r\n conn_data = conn_item.data(0)\r\n self.select_connection(conn_data.source, conn_data.target)\r\n event.accept()\r\n return\r\n \r\n self.clear_selection()\r\n super().mousePressEvent(event)\r\n\r\n def mouseDoubleClickEvent(self, event):\r\n if event.button() == Qt.LeftButton:\r\n scene_pos = self.mapToScene(event.pos())\r\n conn_item = self.get_connection_at(scene_pos)\r\n if conn_item:\r\n conn_data = conn_item.data(0)\r\n self.open_weight_dialog(conn_data.source, conn_data.target)\r\n event.accept()\r\n return\r\n super().mouseDoubleClickEvent(event)\r\n\r\n def mouseMoveEvent(self, event):\r\n scene_pos = self.mapToScene(event.pos())\r\n \r\n if self.pan_active:\r\n delta = event.pos() - self.pan_start_pos\r\n self.pan_start_pos = event.pos()\r\n self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - delta.x())\r\n self.verticalScrollBar().setValue(self.verticalScrollBar().value() - delta.y())\r\n event.accept()\r\n return\r\n \r\n if self.dragging_neuron:\r\n delta = scene_pos - self.neuron_drag_start_pos\r\n neuron = self.design.get_neuron(self.dragging_neuron)\r\n if neuron:\r\n old_pos = neuron.position\r\n new_pos = (old_pos[0] + delta.x(), old_pos[1] + delta.y())\r\n neuron.position = new_pos\r\n self.neuron_drag_start_pos = scene_pos\r\n self.rebuild()\r\n event.accept()\r\n return\r\n \r\n if self.drag_line:\r\n target_id = self.get_neuron_at(scene_pos)\r\n if target_id and target_id != self.drag_source_id:\r\n end = QPointF(*self.design.get_neuron(target_id).position)\r\n valid = self.is_valid_connection(self.drag_source_id, target_id)\r\n color = QColor(50, 205, 50) if valid else QColor(220, 20, 60)\r\n style = Qt.SolidLine if valid else Qt.DashLine\r\n else:\r\n end = scene_pos\r\n color = QColor(255, 215, 0)\r\n style = Qt.DashLine\r\n self.drag_line.setLine(QLineF(self.drag_start_pos, end))\r\n self.drag_line.setPen(QPen(color, 3, style))\r\n event.accept()\r\n return\r\n super().mouseMoveEvent(event)\r\n\r\n def mouseReleaseEvent(self, event):\r\n if event.button() == Qt.RightButton or event.button() == Qt.MiddleButton:\r\n self.pan_active = False\r\n self.setCursor(Qt.ArrowCursor)\r\n event.accept()\r\n return\r\n \r\n if self.dragging_neuron:\r\n self.dragging_neuron = None\r\n self.neuron_drag_start_pos = None\r\n event.accept()\r\n return\r\n \r\n if self.drag_line:\r\n scene_pos = self.mapToScene(event.pos())\r\n target_id = self.get_neuron_at(scene_pos)\r\n self.scene.removeItem(self.drag_line)\r\n self.drag_line = None\r\n if target_id and target_id != self.drag_source_id:\r\n if self.is_valid_connection(self.drag_source_id, target_id):\r\n self.design.add_connection(self.drag_source_id, target_id, 0.5)\r\n self.connectionCreated.emit(self.drag_source_id, target_id)\r\n self.select_connection(self.drag_source_id, target_id)\r\n self.rebuild()\r\n else:\r\n QToolTip.showText(QCursor.pos(), \"Invalid connection\", self)\r\n self.drag_source_id = None\r\n event.accept()\r\n return\r\n super().mouseReleaseEvent(event)\r\n\r\n # KEY EVENTS\r\n def keyPressEvent(self, event):\r\n if event.key() == Qt.Key_Delete:\r\n if self.selected_connection_key:\r\n self.design.remove_connection(*self.selected_connection_key)\r\n self.selected_connection_key = None\r\n self.rebuild()\r\n event.accept()\r\n return\r\n if event.key() == Qt.Key_Space:\r\n if self.selected_connection_key:\r\n self.reverse_selected_connection()\r\n event.accept()\r\n return\r\n if event.key() in [Qt.Key_Plus, Qt.Key_Equal, Qt.Key_Minus, Qt.Key_Underscore]:\r\n self.adjust_connection_weight_by_key(event)\r\n event.accept()\r\n return\r\n if event.key() in [Qt.Key_PageUp, Qt.Key_PageDown]:\r\n self.adjust_connection_weight_page(event)\r\n event.accept()\r\n return\r\n super().keyPressEvent(event)\r\n\r\n def wheelEvent(self, event):\r\n \"\"\"\r\n Mouse wheel behavior:\r\n - If a connection is SELECTED (clicked), scroll changes its weight\r\n - Otherwise, scroll zooms the canvas\r\n \"\"\"\r\n # Only adjust weight if a connection is explicitly selected (clicked)\r\n if self.selected_connection_key:\r\n conn = self.design.get_connection(*self.selected_connection_key)\r\n if conn:\r\n delta = event.angleDelta().y()\r\n step = self.WEIGHT_STEP_LARGE if event.modifiers() & Qt.ShiftModifier else self.WEIGHT_STEP\r\n change = step if delta > 0 else -step\r\n new_weight = max(-1.0, min(1.0, conn.weight + change))\r\n if abs(new_weight) < 0.03: new_weight = 0.0\r\n conn.weight = new_weight\r\n self.rebuild()\r\n self.weightChanged.emit(conn.source, conn.target, new_weight)\r\n QToolTip.showText(QCursor.pos(), f\"Weight: {new_weight:+.2f}\", self)\r\n event.accept()\r\n return\r\n \r\n # Default: zoom canvas\r\n factor = 1.15 if event.angleDelta().y() > 0 else 1 / 1.15\r\n self.zoom_level = max(0.2, min(3.0, self.zoom_level * factor))\r\n self.setTransform(QTransform().scale(self.zoom_level, self.zoom_level))\r\n event.accept()\r\n\r\n # SELECTION HELPERS\r\n def select_neuron(self, name):\r\n self.selected_neuron = name\r\n self.selected_connection_key = None\r\n self.neuronSelected.emit(name)\r\n self.rebuild()\r\n \r\n def select_connection(self, source, target):\r\n self.selected_connection_key = (source, target)\r\n self.selected_neuron = None\r\n self.connectionSelected.emit(source, target)\r\n self.rebuild()\r\n \r\n def clear_selection(self):\r\n self.selected_neuron = None\r\n self.selected_connection_key = None\r\n self.rebuild()\r\n\r\n def start_connection_drag(self, neuron_name, scene_pos):\r\n n_obj = self.design.get_neuron(neuron_name)\r\n self.drag_source_id = neuron_name\r\n self.drag_start_pos = QPointF(*n_obj.position)\r\n self.drag_line = QGraphicsLineItem(QLineF(self.drag_start_pos, scene_pos))\r\n self.drag_line.setPen(QPen(QColor(255, 215, 0), 3, Qt.DashLine))\r\n self.drag_line.setZValue(10)\r\n self.scene.addItem(self.drag_line)\r\n\r\n def is_valid_connection(self, src_name, tgt_name):\r\n src = self.design.get_neuron(src_name)\r\n tgt = self.design.get_neuron(tgt_name)\r\n if not src or not tgt: return False\r\n if tgt.neuron_type in [NeuronType.INPUT, NeuronType.SENSOR]: return False\r\n if src.neuron_type == NeuronType.OUTPUT: return False\r\n if self.design.get_connection(src_name, tgt_name): return False\r\n return True\r\n\r\n def reverse_selected_connection(self):\r\n if not self.selected_connection_key: return\r\n source, target = self.selected_connection_key\r\n conn = self.design.get_connection(source, target)\r\n if not conn: return\r\n src_neuron = self.design.get_neuron(source)\r\n tgt_neuron = self.design.get_neuron(target)\r\n if self.design.get_connection(target, source): return\r\n if src_neuron and src_neuron.neuron_type in [NeuronType.SENSOR, NeuronType.INPUT]: return\r\n if tgt_neuron and tgt_neuron.neuron_type == NeuronType.OUTPUT: return\r\n weight = conn.weight\r\n self.design.remove_connection(source, target)\r\n self.design.add_connection(target, source, weight)\r\n self.selected_connection_key = (target, source)\r\n self.connectionReversed.emit(source, target)\r\n self.rebuild()\r\n\r\n def open_weight_dialog(self, source, target):\r\n conn = self.design.get_connection(source, target)\r\n if not conn: return\r\n dialog = ConnectionWeightDialog(source, target, conn.weight, self.config, self)\r\n result = dialog.exec_()\r\n if dialog.delete_requested:\r\n self.design.remove_connection(source, target)\r\n self.selected_connection_key = None\r\n self.connectionDeleted.emit(source, target)\r\n self.rebuild()\r\n return\r\n if result == QDialog.Accepted:\r\n new_weight = dialog.get_weight()\r\n if new_weight != conn.weight:\r\n conn.weight = new_weight\r\n self.weightChanged.emit(source, target, new_weight)\r\n self.rebuild()\r\n\r\n def adjust_connection_weight_by_key(self, event):\r\n pos = self.mapToScene(self.mapFromGlobal(QCursor.pos()))\r\n conn_item = self.get_connection_at(pos)\r\n if conn_item: conn = conn_item.data(0)\r\n elif self.selected_connection_key: conn = self.design.get_connection(*self.selected_connection_key)\r\n else: return\r\n if not conn: return\r\n step = self.WEIGHT_STEP_LARGE if event.modifiers() & Qt.ShiftModifier else self.WEIGHT_STEP\r\n if event.key() in [Qt.Key_Minus, Qt.Key_Underscore]: step = -step\r\n conn.weight = max(-1.0, min(1.0, conn.weight + step))\r\n self.rebuild()\r\n self.weightChanged.emit(conn.source, conn.target, conn.weight)\r\n QToolTip.showText(QCursor.pos(), f\"Weight: {conn.weight:+.2f}\", self)\r\n\r\n def adjust_connection_weight_page(self, event):\r\n pos = self.mapToScene(self.mapFromGlobal(QCursor.pos()))\r\n conn_item = self.get_connection_at(pos)\r\n if conn_item: conn = conn_item.data(0)\r\n elif self.selected_connection_key: conn = self.design.get_connection(*self.selected_connection_key)\r\n else: return\r\n if not conn: return\r\n step = self.WEIGHT_STEP_LARGE\r\n if event.key() == Qt.Key_PageDown: step = -step\r\n conn.weight = max(-1.0, min(1.0, conn.weight + step))\r\n self.rebuild()\r\n self.weightChanged.emit(conn.source, conn.target, conn.weight)\r\n QToolTip.showText(QCursor.pos(), f\"Weight: {conn.weight:+.2f}\", self)\r\n\r\n\r\nclass PolygonNeuronItem(QGraphicsItem):\r\n \"\"\"\r\n Polygonal Neuron Body (Diamond, Square, Triangle).\r\n Acts as Parent item for Label (Ring is usually not used for these shapes in Designer).\r\n \"\"\"\r\n \r\n def __init__(self, x, y, radius, name, sides=4, rotation=0, color=(150, 150, 220), parent=None):\r\n super().__init__(parent)\r\n self.name = name\r\n self.radius = radius\r\n self.sides = sides\r\n self.rotation_deg = rotation\r\n self.color = color\r\n self.is_selected = False\r\n self.is_hovered = False\r\n \r\n self.setPos(x, y)\r\n self.setAcceptHoverEvents(True)\r\n self.setData(0, ('neuron', name))\r\n self.setZValue(2)\r\n \r\n def boundingRect(self):\r\n extra = 5\r\n return QRectF(-self.radius - extra, -self.radius - extra,\r\n (self.radius + extra) * 2, (self.radius + extra) * 2)\r\n \r\n def shape(self):\r\n path = QPainterPath()\r\n polygon = QPolygonF()\r\n angle_step = 360.0 / self.sides\r\n # Apply rotation offset\r\n offset_rad = math.radians(self.rotation_deg - 90)\r\n \r\n for i in range(self.sides):\r\n angle = math.radians(i * angle_step) + offset_rad\r\n polygon.append(QPointF(self.radius * math.cos(angle), \r\n self.radius * math.sin(angle)))\r\n path.addPolygon(polygon)\r\n path.closeSubpath()\r\n return path\r\n\r\n def paint(self, painter, option, widget):\r\n painter.save()\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n # Draw hover glow\r\n if self.is_hovered and not self.is_selected:\r\n painter.setBrush(Qt.NoBrush)\r\n painter.setPen(QPen(QColor(100, 200, 255, 150), 6))\r\n # Re-calculate polygon for glow path\r\n path = self.shape()\r\n painter.drawPath(path)\r\n\r\n # Draw Selection Highlight\r\n if self.is_selected:\r\n painter.setPen(QPen(QColor(255, 255, 255), 4))\r\n painter.setBrush(Qt.NoBrush)\r\n painter.drawPath(self.shape())\r\n\r\n # Draw Polygon Body\r\n painter.setBrush(QBrush(QColor(*self.color)))\r\n painter.setPen(QPen(QColor(50, 50, 50), 2))\r\n \r\n polygon = QPolygonF()\r\n angle_step = 360.0 / self.sides\r\n offset_rad = math.radians(self.rotation_deg - 90)\r\n \r\n for i in range(self.sides):\r\n angle = math.radians(i * angle_step) + offset_rad\r\n polygon.append(QPointF(self.radius * math.cos(angle), \r\n self.radius * math.sin(angle)))\r\n \r\n painter.drawPolygon(polygon)\r\n painter.restore()\r\n \r\n def hoverEnterEvent(self, event):\r\n self.is_hovered = True\r\n self.update()\r\n super().hoverEnterEvent(event)\r\n \r\n def hoverLeaveEvent(self, event):\r\n self.is_hovered = False\r\n self.update()\r\n super().hoverLeaveEvent(event)"
},
{
"path": "src/designer_canvas_utils.py",
"content": "\"\"\"\r\nEnhanced Canvas Utilities for Brain Designer\r\n\r\nAdditional visual feedback for wiring operations and activation display.\r\n\"\"\"\r\n\r\nfrom PyQt5.QtWidgets import (\r\n QGraphicsItem, QGraphicsEllipseItem, QGraphicsTextItem, \r\n QGraphicsRectItem, QGraphicsPathItem, QToolTip\r\n)\r\nfrom PyQt5.QtCore import Qt, QPointF, QRectF, QTimer\r\nfrom PyQt5.QtGui import (\r\n QPainter, QPen, QBrush, QColor, QFont, QFontMetrics,\r\n QPainterPath, QRadialGradient, QLinearGradient\r\n)\r\n\r\nimport math\r\n\r\n\r\nclass WiringPreviewItem(QGraphicsItem):\r\n \"\"\"\r\n Enhanced preview of a connection being dragged.\r\n Shows validity feedback, snapping, and weight preview.\r\n \"\"\"\r\n \r\n def __init__(self, start_pos: QPointF, parent=None):\r\n super().__init__(parent)\r\n self.start_pos = start_pos\r\n self.end_pos = start_pos\r\n self.is_valid = False\r\n self.target_name = \"\"\r\n self.preview_weight = 0.5\r\n self.is_snapped = False\r\n \r\n # Animation\r\n self.pulse_phase = 0.0\r\n \r\n self.setZValue(100) # Above everything\r\n \r\n def set_end(self, pos: QPointF, is_valid: bool = False, \r\n target_name: str = \"\", snapped: bool = False):\r\n \"\"\"Update the end position and validity state.\"\"\"\r\n self.end_pos = pos\r\n self.is_valid = is_valid\r\n self.target_name = target_name\r\n self.is_snapped = snapped\r\n self.update()\r\n \r\n def boundingRect(self) -> QRectF:\r\n return QRectF(self.start_pos, self.end_pos).normalized().adjusted(-50, -50, 50, 50)\r\n \r\n def paint(self, painter, option, widget):\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n # Determine colors\r\n if self.is_valid and self.is_snapped:\r\n # Valid and snapped to target\r\n color = QColor(50, 205, 50) # Green\r\n glow_color = QColor(50, 205, 50, 80)\r\n style = Qt.SolidLine\r\n elif self.is_valid:\r\n # Valid but not snapped\r\n color = QColor(100, 180, 100)\r\n glow_color = QColor(100, 180, 100, 60)\r\n style = Qt.DashLine\r\n else:\r\n # Invalid or dragging in open space\r\n color = QColor(255, 215, 0) # Gold\r\n glow_color = QColor(255, 215, 0, 60)\r\n style = Qt.DashLine\r\n \r\n # Draw glow\r\n painter.setPen(QPen(glow_color, 12, Qt.SolidLine, Qt.RoundCap))\r\n painter.drawLine(self.start_pos, self.end_pos)\r\n \r\n # Draw main line\r\n painter.setPen(QPen(color, 3, style, Qt.RoundCap))\r\n painter.drawLine(self.start_pos, self.end_pos)\r\n \r\n # Draw arrowhead at end\r\n line_vec = self.end_pos - self.start_pos\r\n length = math.sqrt(line_vec.x()**2 + line_vec.y()**2)\r\n if length > 10:\r\n angle = math.atan2(line_vec.y(), line_vec.x())\r\n arrow_size = 15\r\n \r\n p1 = self.end_pos - QPointF(\r\n math.cos(angle + 0.5) * arrow_size,\r\n math.sin(angle + 0.5) * arrow_size\r\n )\r\n p2 = self.end_pos - QPointF(\r\n math.cos(angle - 0.5) * arrow_size,\r\n math.sin(angle - 0.5) * arrow_size\r\n )\r\n \r\n painter.setBrush(QBrush(color))\r\n painter.setPen(Qt.NoPen)\r\n path = QPainterPath()\r\n path.moveTo(self.end_pos)\r\n path.lineTo(p1)\r\n path.lineTo(p2)\r\n path.closeSubpath()\r\n painter.drawPath(path)\r\n \r\n # Draw target label if snapped\r\n if self.is_snapped and self.target_name:\r\n mid = (self.start_pos + self.end_pos) / 2\r\n \r\n # Background\r\n font = QFont(\"Arial\", 10, QFont.Bold)\r\n painter.setFont(font)\r\n fm = QFontMetrics(font)\r\n \r\n label = f\"→ {self.target_name.replace('_', ' ').title()}\"\r\n text_width = fm.horizontalAdvance(label)\r\n text_height = fm.height()\r\n \r\n rect = QRectF(mid.x() - text_width/2 - 8, mid.y() - text_height/2 - 4,\r\n text_width + 16, text_height + 8)\r\n \r\n bg_color = QColor(50, 50, 50, 200) if not self.is_valid else QColor(30, 100, 30, 200)\r\n painter.setBrush(QBrush(bg_color))\r\n painter.setPen(Qt.NoPen)\r\n painter.drawRoundedRect(rect, 5, 5)\r\n \r\n # Text\r\n painter.setPen(Qt.white)\r\n painter.drawText(rect, Qt.AlignCenter, label)\r\n\r\n\r\nclass ActivationBadge(QGraphicsItem):\r\n \"\"\"\r\n Badge showing a neuron's current activation value.\r\n \"\"\"\r\n \r\n def __init__(self, center: QPointF, value: float, \r\n is_binary: bool = False, parent=None):\r\n super().__init__(parent)\r\n self.center = center\r\n self.value = value\r\n self.is_binary = is_binary\r\n \r\n # Position below the neuron\r\n self.setPos(center.x() - 20, center.y() + 35)\r\n self.setZValue(5)\r\n \r\n def boundingRect(self) -> QRectF:\r\n return QRectF(0, 0, 40, 18)\r\n \r\n def paint(self, painter, option, widget):\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n rect = self.boundingRect()\r\n \r\n # Color based on value\r\n if self.is_binary:\r\n if self.value > 50:\r\n color = QColor(50, 205, 50) # Green = ON\r\n text = \"ON\"\r\n else:\r\n color = QColor(150, 150, 150) # Gray = OFF\r\n text = \"OFF\"\r\n else:\r\n # Gradient from blue (low) to red (high)\r\n ratio = self.value / 100.0\r\n if ratio < 0.5:\r\n # Blue to yellow\r\n r = int(50 + ratio * 2 * 205)\r\n g = int(50 + ratio * 2 * 155)\r\n b = int(200 - ratio * 2 * 150)\r\n else:\r\n # Yellow to red\r\n r = 255\r\n g = int(205 - (ratio - 0.5) * 2 * 155)\r\n b = int(50 - (ratio - 0.5) * 2 * 50)\r\n color = QColor(r, g, b)\r\n text = f\"{self.value:.0f}\"\r\n \r\n # Background\r\n painter.setBrush(QBrush(color))\r\n painter.setPen(QPen(color.darker(120), 1))\r\n painter.drawRoundedRect(rect, 4, 4)\r\n \r\n # Text\r\n painter.setPen(Qt.white if color.lightness() < 150 else Qt.black)\r\n painter.setFont(QFont(\"Arial\", 8, QFont.Bold))\r\n painter.drawText(rect, Qt.AlignCenter, text)\r\n\r\n\r\nclass ConnectionStrengthIndicator(QGraphicsItem):\r\n \"\"\"\r\n Visual indicator of connection strength shown during weight editing.\r\n \"\"\"\r\n \r\n def __init__(self, pos: QPointF, weight: float, parent=None):\r\n super().__init__(parent)\r\n self.weight = weight\r\n self.setPos(pos)\r\n self.setZValue(50)\r\n \r\n def boundingRect(self) -> QRectF:\r\n return QRectF(-60, -20, 120, 40)\r\n \r\n def paint(self, painter, option, widget):\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n rect = QRectF(-55, -15, 110, 30)\r\n \r\n # Background\r\n painter.setBrush(QBrush(QColor(40, 40, 40, 230)))\r\n painter.setPen(Qt.NoPen)\r\n painter.drawRoundedRect(rect, 6, 6)\r\n \r\n # Weight bar background\r\n bar_rect = QRectF(-45, 2, 90, 8)\r\n painter.setBrush(QBrush(QColor(80, 80, 80)))\r\n painter.drawRoundedRect(bar_rect, 3, 3)\r\n \r\n # Weight bar fill\r\n bar_width = abs(self.weight) * 45\r\n if self.weight >= 0:\r\n fill_rect = QRectF(0, 2, bar_width, 8)\r\n color = QColor(50, 205, 50)\r\n else:\r\n fill_rect = QRectF(-bar_width, 2, bar_width, 8)\r\n color = QColor(220, 50, 50)\r\n \r\n painter.setBrush(QBrush(color))\r\n painter.drawRoundedRect(fill_rect, 3, 3)\r\n \r\n # Center line\r\n painter.setPen(QPen(QColor(150, 150, 150), 1))\r\n painter.drawLine(QPointF(0, 0), QPointF(0, 12))\r\n \r\n # Weight text\r\n painter.setPen(Qt.white)\r\n painter.setFont(QFont(\"Arial\", 9, QFont.Bold))\r\n text = f\"{self.weight:+.2f}\"\r\n painter.drawText(QRectF(-50, -14, 100, 14), Qt.AlignCenter, text)\r\n\r\n\r\nclass NeuronHighlightRing(QGraphicsEllipseItem):\r\n \"\"\"\r\n Animated highlight ring for neuron selection/hover states.\r\n \"\"\"\r\n \r\n def __init__(self, center: QPointF, radius: float, \r\n color: QColor, parent=None):\r\n super().__init__(\r\n center.x() - radius - 5,\r\n center.y() - radius - 5,\r\n (radius + 5) * 2,\r\n (radius + 5) * 2,\r\n parent\r\n )\r\n self.center = center\r\n self.base_radius = radius\r\n self.highlight_color = color\r\n self.pulse_phase = 0.0\r\n \r\n self.setPen(Qt.NoPen)\r\n self.setBrush(Qt.NoBrush)\r\n self.setZValue(0)\r\n \r\n def advance_pulse(self):\r\n self.pulse_phase += 0.1\r\n if self.pulse_phase > math.pi * 2:\r\n self.pulse_phase = 0\r\n self.update()\r\n \r\n def paint(self, painter, option, widget):\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n # Pulsing glow\r\n pulse = math.sin(self.pulse_phase) * 0.3 + 0.7\r\n alpha = int(100 * pulse)\r\n \r\n glow_color = QColor(\r\n self.highlight_color.red(),\r\n self.highlight_color.green(),\r\n self.highlight_color.blue(),\r\n alpha\r\n )\r\n \r\n # Outer glow\r\n gradient = QRadialGradient(self.center, self.base_radius + 15)\r\n gradient.setColorAt(0.6, glow_color)\r\n gradient.setColorAt(1.0, QColor(glow_color.red(), glow_color.green(), \r\n glow_color.blue(), 0))\r\n \r\n painter.setBrush(QBrush(gradient))\r\n painter.setPen(Qt.NoPen)\r\n painter.drawEllipse(self.center, self.base_radius + 15, self.base_radius + 15)\r\n \r\n # Ring\r\n ring_width = 2 + pulse\r\n painter.setPen(QPen(self.highlight_color, ring_width))\r\n painter.setBrush(Qt.NoBrush)\r\n painter.drawEllipse(self.center, self.base_radius + 3, self.base_radius + 3)\r\n\r\n\r\ndef get_weight_color(weight: float) -> QColor:\r\n \"\"\"Get color for a connection weight.\"\"\"\r\n if weight >= 0:\r\n # Green gradient for excitatory\r\n intensity = min(1.0, weight)\r\n return QColor(\r\n int(50 + intensity * 0),\r\n int(150 + intensity * 55),\r\n int(50 + intensity * 0)\r\n )\r\n else:\r\n # Red gradient for inhibitory\r\n intensity = min(1.0, abs(weight))\r\n return QColor(\r\n int(150 + intensity * 70),\r\n int(50 + intensity * 0),\r\n int(50 + intensity * 10)\r\n )\r\n\r\n\r\ndef format_neuron_name(name: str) -> str:\r\n \"\"\"Format a neuron name for display.\"\"\"\r\n return name.replace('_', ' ').title()\r\n"
},
{
"path": "src/designer_constants.py",
"content": "from enum import Enum, auto\r\nimport random\r\n\r\n# --- Enums ---\r\nclass NeuronType(Enum):\r\n INPUT = auto()\r\n OUTPUT = auto()\r\n HIDDEN = auto()\r\n CORE = auto()\r\n SENSOR = auto()\r\n CONNECTOR = auto()\r\n\r\n# --- Visual Constants ---\r\nCORE_NEURON_RING_COLOR = (255, 215, 0)\r\nINPUT_SENSOR_RING_COLOR = (100, 149, 237)\r\nCUSTOM_NEURON_RING_COLOR = (180, 180, 180)\r\nCONNECTOR_COLOR = (0, 0, 000)\r\nPROTECTED_RING_WIDTH = 3\r\nNORMAL_RING_WIDTH = 2\r\nDEFAULT_LAYER_HEIGHT = 120\r\nDEFAULT_LAYER_SPACING = 150\r\n\r\nDEFAULT_COLORS = {\r\n 'core': (150, 150, 220),\r\n 'required': (100, 180, 100),\r\n 'input': (100, 200, 150),\r\n 'output': (220, 150, 150),\r\n 'hidden': (180, 180, 200),\r\n 'sensor': (150, 200, 220),\r\n 'connector': (000, 0, 0)\r\n \r\n}\r\n\r\nLAYER_COLORS = {\r\n 'input': {'fill': (200, 255, 200, 80), 'border': (150, 220, 150, 120)},\r\n 'output': {'fill': (255, 200, 200, 80), 'border': (220, 150, 150, 120)},\r\n 'hidden': {'fill': (230, 230, 255, 80), 'border': (200, 200, 240, 120)}\r\n}\r\n\r\n# --- Logic Constants ---\r\nCORE_NEURONS = {\r\n \"hunger\": (127, 81), \"happiness\": (361, 81), \"cleanliness\": (627, 81),\r\n \"sleepiness\": (840, 81), \"satisfaction\": (271, 380), \"anxiety\": (491, 389),\r\n \"curiosity\": (701, 386),\r\n}\r\nMANDATORY_SENSOR = {\"can_see_food\": (50, 200)}\r\nREQUIRED_NEURONS = {**CORE_NEURONS, **MANDATORY_SENSOR}\r\nCORE_NEURON_NAMES = list(CORE_NEURONS.keys())\r\nREQUIRED_NEURON_NAMES = CORE_NEURON_NAMES + [\"can_see_food\"]\r\n\r\nINPUT_SENSORS = {\r\n \"external_stimulus\": (50, 50), \"plant_proximity\": (50, 250),\r\n \"threat_level\": (50, 350), \"pursuing_food\": (150, 50),\r\n \"is_sick\": (150, 150), \"is_fleeing\": (150, 250),\r\n \"is_eating\": (150, 350), \"is_sleeping\": (250, 50),\r\n \"is_startled\": (250, 150),\r\n}\r\n\r\nBINARY_NEURONS = {\r\n 'can_see_food', 'is_eating', 'is_sleeping', 'is_sick',\r\n 'pursuing_food', 'is_fleeing', 'is_startled', 'external_stimulus'\r\n}\r\n\r\ndef is_core_neuron(name): return name in CORE_NEURONS\r\ndef is_required_neuron(name): return name in REQUIRED_NEURONS\r\ndef is_input_sensor(name): return name in INPUT_SENSORS\r\ndef is_binary_neuron(name): return name in BINARY_NEURONS\r\ndef is_protected_neuron(name): return is_required_neuron(name)\r\ndef get_neuron_category(name):\r\n if is_core_neuron(name): return 'core'\r\n elif name == 'can_see_food': return 'required'\r\n elif is_input_sensor(name): return 'sensor'\r\n return 'custom'\r\ndef get_missing_required(existing): return [n for n in REQUIRED_NEURONS if n not in existing]\r\n\r\n# --- Default Connections ---\r\nDEFAULT_SENSOR_CONNECTIONS = {\r\n 'can_see_food': [('hunger', 0.4, 1.0), ('happiness', 0.2, 0.5), ('satisfaction', 0.15, 0.2)],\r\n 'external_stimulus': [('curiosity', 0.35, 1.0), ('anxiety', 0.15, 0.3)],\r\n 'threat_level': [('anxiety', 0.6, 1.0), ('happiness', -0.3, 0.7), ('curiosity', -0.2, 0.4)],\r\n 'plant_proximity': [('happiness', 0.2, 1.0), ('curiosity', 0.15, 0.5)],\r\n 'is_sick': [('happiness', -0.5, 1.0), ('anxiety', 0.4, 0.8), ('sleepiness', 0.3, 0.6)],\r\n 'is_fleeing': [('anxiety', 0.4, 1.0), ('curiosity', -0.3, 0.7)],\r\n 'is_eating': [('satisfaction', 0.5, 1.0), ('happiness', 0.3, 0.8), ('hunger', -0.4, 1.0)],\r\n 'is_sleeping': [('sleepiness', -0.5, 1.0), ('anxiety', -0.2, 0.6)],\r\n 'is_startled': [('anxiety', 0.5, 1.0), ('curiosity', 0.2, 0.4)],\r\n 'pursuing_food': [('hunger', 0.2, 1.0), ('curiosity', 0.25, 0.5)],\r\n}\r\n\r\ndef get_default_connections_for_sensor(sensor_name: str) -> list:\r\n if sensor_name not in DEFAULT_SENSOR_CONNECTIONS:\r\n return []\r\n connections = []\r\n for target, weight, probability in DEFAULT_SENSOR_CONNECTIONS[sensor_name]:\r\n if random.random() < probability:\r\n connections.append((target, weight))\r\n return connections"
},
{
"path": "src/designer_core.py",
"content": "import json\r\nimport random\r\nimport time\r\nimport math\r\nfrom typing import Dict, List, Optional, Tuple, Set\r\nfrom dataclasses import dataclass\r\n\r\nfrom .designer_constants import (\r\n NeuronType, DEFAULT_COLORS, REQUIRED_NEURONS, CORE_NEURONS,\r\n INPUT_SENSORS, is_core_neuron, is_required_neuron, is_input_sensor,\r\n is_binary_neuron, get_neuron_category, get_default_connections_for_sensor\r\n)\r\n\r\n@dataclass\r\nclass DesignerLayer:\r\n name: str\r\n layer_type: NeuronType\r\n y_position: float\r\n color: Tuple[int, int, int, int] = (200, 200, 220, 80)\r\n \r\n def to_dict(self) -> dict:\r\n return {\r\n 'name': self.name,\r\n 'layer_type': self.layer_type.name.lower(),\r\n 'y_position': self.y_position,\r\n 'color': self.color\r\n }\r\n \r\n @classmethod\r\n def from_dict(cls, data: dict) -> 'DesignerLayer':\r\n layer_type_str = data.get('layer_type', 'hidden').upper()\r\n try:\r\n layer_type = NeuronType[layer_type_str]\r\n except KeyError:\r\n layer_type = NeuronType.HIDDEN\r\n return cls(\r\n name=data['name'],\r\n layer_type=layer_type,\r\n y_position=data['y_position'],\r\n color=tuple(data.get('color', (200, 200, 220, 80)))\r\n )\r\n\r\n@dataclass \r\nclass DesignerNeuron:\r\n name: str\r\n neuron_type: NeuronType\r\n position: Tuple[float, float]\r\n layer_index: int = 0\r\n color: Tuple[int, int, int] = (150, 150, 220)\r\n description: str = \"\"\r\n is_binary: bool = False\r\n shape: str = 'circle'\r\n \r\n def __post_init__(self):\r\n # 1. CORE neurons (Circle)\r\n if is_core_neuron(self.name):\r\n self.neuron_type = NeuronType.CORE\r\n self.color = DEFAULT_COLORS['core']\r\n self.shape = 'circle'\r\n \r\n # 2. REQUIRED SENSOR (Square)\r\n elif self.name == 'can_see_food':\r\n self.neuron_type = NeuronType.SENSOR\r\n self.color = DEFAULT_COLORS.get('required', (100, 180, 100))\r\n self.is_binary = True\r\n self.shape = 'square'\r\n \r\n # 3. CONNECTORS (Hexagon)\r\n elif self.name.startswith('connector_') or self.neuron_type == NeuronType.CONNECTOR:\r\n self.neuron_type = NeuronType.CONNECTOR\r\n self.color = DEFAULT_COLORS['connector']\r\n self.shape = 'hexagon'\r\n \r\n # 4. NEUROGENESIS TYPES (Shapes)\r\n elif self.name.startswith('novelty_'):\r\n self.shape = 'diamond'\r\n # Typically yellowish\r\n elif self.name.startswith('stress_'):\r\n self.shape = 'square'\r\n # Typically reddish\r\n elif self.name.startswith('reward_'):\r\n self.shape = 'triangle'\r\n # Typically greenish or blueish\r\n \r\n # 5. INPUT SENSORS (Square)\r\n elif is_input_sensor(self.name):\r\n self.neuron_type = NeuronType.SENSOR\r\n self.color = DEFAULT_COLORS['sensor']\r\n self.is_binary = is_binary_neuron(self.name)\r\n self.shape = 'square'\r\n\r\n @property\r\n def is_core(self) -> bool: return is_core_neuron(self.name)\r\n @property\r\n def is_required(self) -> bool: return is_required_neuron(self.name)\r\n @property\r\n def is_sensor(self) -> bool: \r\n return self.neuron_type == NeuronType.SENSOR or self.name == 'can_see_food'\r\n @property\r\n def is_protected(self) -> bool: return self.is_required\r\n @property\r\n def category(self) -> str: return get_neuron_category(self.name)\r\n \r\n def to_dict(self) -> dict:\r\n return {\r\n 'name': self.name,\r\n 'neuron_type': self.neuron_type.name.lower(),\r\n 'position': list(self.position),\r\n 'layer_index': self.layer_index,\r\n 'color': list(self.color),\r\n 'description': self.description,\r\n 'is_binary': self.is_binary,\r\n 'category': self.category,\r\n 'shape': self.shape\r\n }\r\n \r\n @classmethod\r\n def from_dict(cls, data: dict) -> 'DesignerNeuron':\r\n type_str = data.get('neuron_type', 'hidden').upper()\r\n try:\r\n neuron_type = NeuronType[type_str]\r\n except KeyError:\r\n neuron_type = NeuronType.HIDDEN\r\n \r\n pos = data.get('position', (0, 0))\r\n try:\r\n if isinstance(pos, (list, tuple)) and len(pos) == 2:\r\n x, y = pos\r\n if isinstance(x, (int, float)) and isinstance(y, (int, float)):\r\n position = tuple(pos)\r\n else:\r\n position = (0, 0) \r\n else:\r\n position = (0, 0)\r\n except (TypeError, ValueError):\r\n position = (0, 0)\r\n \r\n return cls(\r\n name=data['name'],\r\n neuron_type=neuron_type,\r\n position=position,\r\n layer_index=data.get('layer_index', 0),\r\n color=tuple(data.get('color', (150, 150, 220))),\r\n description=data.get('description', ''),\r\n is_binary=data.get('is_binary', False),\r\n shape=data.get('shape', 'circle')\r\n )\r\n\r\n# ... (rest of designer_core.py is compatible as provided in prompt) ...\r\n@dataclass\r\nclass DesignerConnection:\r\n source: str\r\n target: str\r\n weight: float = 0.5\r\n \r\n def to_dict(self) -> dict:\r\n return {'source': self.source, 'target': self.target, 'weight': self.weight}\r\n \r\n @classmethod\r\n def from_dict(cls, data: dict) -> 'DesignerConnection':\r\n return cls(source=data['source'], target=data['target'], weight=data.get('weight', 0.5))\r\n\r\nclass BrainDesign:\r\n def __init__(self):\r\n self.neurons: Dict[str, DesignerNeuron] = {}\r\n self.connections: List[DesignerConnection] = []\r\n self.layers: List[DesignerLayer] = []\r\n self.output_bindings: List[Dict] = []\r\n self.metadata: Dict = {\r\n 'name': 'Untitled', 'description': '', 'author': '',\r\n 'version': '1.0', 'created': '', 'modified': ''\r\n }\r\n self._next_custom_neuron_x = 400\r\n self._next_custom_neuron_y = 200\r\n\r\n def remove_optional_sensors(self) -> int:\r\n sensors_to_remove = []\r\n for name, neuron in self.neurons.items():\r\n if neuron.is_sensor and name != 'can_see_food':\r\n sensors_to_remove.append(name)\r\n \r\n removed_count = 0\r\n for name in sensors_to_remove:\r\n if self.remove_neuron(name)[0]:\r\n removed_count += 1\r\n return removed_count\r\n \r\n def _validate_and_fix_position(self, position: any) -> Tuple[float, float]:\r\n if position is None:\r\n return self._generate_custom_position()\r\n try:\r\n if not isinstance(position, (tuple, list)) or len(position) != 2:\r\n return self._generate_custom_position()\r\n x, y = position\r\n if not isinstance(x, (int, float)) or not isinstance(y, (int, float)):\r\n return self._generate_custom_position()\r\n if x is None or y is None:\r\n return self._generate_custom_position()\r\n return (float(x), float(y))\r\n except (TypeError, ValueError):\r\n return self._generate_custom_position()\r\n \r\n def _generate_custom_position(self) -> Tuple[float, float]:\r\n pos = (self._next_custom_neuron_x, self._next_custom_neuron_y)\r\n self._next_custom_neuron_x += 120\r\n if self._next_custom_neuron_x > 600:\r\n self._next_custom_neuron_x = 400\r\n self._next_custom_neuron_y += 100\r\n return pos\r\n \r\n def add_neuron(self, neuron: DesignerNeuron) -> bool:\r\n if neuron.name in self.neurons: return False\r\n neuron.position = self._validate_and_fix_position(neuron.position)\r\n self.neurons[neuron.name] = neuron\r\n return True\r\n \r\n def remove_neuron(self, name: str) -> Tuple[bool, str]:\r\n if name not in self.neurons: return False, f\"Neuron '{name}' not found\"\r\n if is_required_neuron(name):\r\n return False, f\"Cannot delete required neuron '{name}'\"\r\n del self.neurons[name]\r\n self.connections = [c for c in self.connections if c.source != name and c.target != name]\r\n return True, f\"Removed neuron '{name}'\"\r\n \r\n def rename_neuron(self, old_name: str, new_name: str) -> Tuple[bool, str]:\r\n if old_name not in self.neurons: return False, f\"Neuron '{old_name}' not found\"\r\n if is_required_neuron(old_name): return False, f\"Cannot rename required neuron '{old_name}'\"\r\n if new_name in self.neurons: return False, f\"Neuron '{new_name}' already exists\"\r\n neuron = self.neurons.pop(old_name)\r\n neuron.name = new_name\r\n self.neurons[new_name] = neuron\r\n for conn in self.connections:\r\n if conn.source == old_name: conn.source = new_name\r\n if conn.target == old_name: conn.target = new_name\r\n return True, f\"Renamed '{old_name}' to '{new_name}'\"\r\n \r\n def get_neuron(self, name: str) -> Optional[DesignerNeuron]:\r\n return self.neurons.get(name)\r\n \r\n def add_connection(self, source: str, target: str, weight: float = 0.5) -> bool:\r\n if source not in self.neurons or target not in self.neurons: return False\r\n for conn in self.connections:\r\n if conn.source == source and conn.target == target:\r\n conn.weight = weight\r\n return True\r\n self.connections.append(DesignerConnection(source, target, weight))\r\n return True\r\n \r\n def remove_connection(self, source: str, target: str) -> bool:\r\n for i, conn in enumerate(self.connections):\r\n if conn.source == source and conn.target == target:\r\n self.connections.pop(i)\r\n return True\r\n return False\r\n \r\n def get_connection(self, source: str, target: str) -> Optional[DesignerConnection]:\r\n for conn in self.connections:\r\n if conn.source == source and conn.target == target: return conn\r\n return None\r\n \r\n def add_layer(self, layer: DesignerLayer) -> bool:\r\n self.layers.append(layer)\r\n self.layers.sort(key=lambda l: l.y_position)\r\n return True\r\n \r\n def remove_layer(self, index: int) -> bool:\r\n if 0 <= index < len(self.layers):\r\n self.layers.pop(index)\r\n return True\r\n return False\r\n\r\n def get_missing_required_neurons(self) -> List[str]:\r\n return [name for name in REQUIRED_NEURONS if name not in self.neurons]\r\n \r\n def has_all_required_neurons(self) -> bool:\r\n return len(self.get_missing_required_neurons()) == 0\r\n \r\n def add_missing_required_neurons(self) -> int:\r\n added = 0\r\n for name, pos in REQUIRED_NEURONS.items():\r\n if name not in self.neurons:\r\n ntype = NeuronType.SENSOR if name == 'can_see_food' else NeuronType.CORE\r\n desc = \"Required neuron\"\r\n self.add_neuron(DesignerNeuron(name=name, neuron_type=ntype, position=pos, description=desc))\r\n added += 1\r\n return added\r\n\r\n def add_missing_core_neurons(self) -> int:\r\n added = 0\r\n for name, pos in CORE_NEURONS.items():\r\n if name not in self.neurons:\r\n self.add_neuron(DesignerNeuron(\r\n name=name, neuron_type=NeuronType.CORE, position=pos, description=\"Core neuron\"))\r\n added += 1\r\n return added\r\n \r\n def get_orphan_neurons(self) -> List[str]:\r\n if not self.connections:\r\n return [n for n in self.neurons if not is_required_neuron(n)]\r\n connected = set()\r\n for conn in self.connections:\r\n connected.add(conn.source)\r\n connected.add(conn.target)\r\n return [name for name in self.neurons if name not in connected and not is_required_neuron(name)]\r\n \r\n def get_island_neurons(self) -> List[Set[str]]:\r\n if not self.neurons: return []\r\n adj = {name: set() for name in self.neurons}\r\n for conn in self.connections:\r\n if conn.source in adj and conn.target in adj:\r\n adj[conn.source].add(conn.target)\r\n adj[conn.target].add(conn.source)\r\n \r\n visited = set()\r\n components = []\r\n for start in self.neurons:\r\n if start in visited: continue\r\n component = set()\r\n queue = [start]\r\n while queue:\r\n node = queue.pop(0)\r\n if node in visited: continue\r\n visited.add(node)\r\n component.add(node)\r\n for neighbor in adj[node]:\r\n if neighbor not in visited: queue.append(neighbor)\r\n components.append(component)\r\n \r\n main_component = None\r\n for comp in components:\r\n if any(is_required_neuron(n) for n in comp):\r\n main_component = comp\r\n break\r\n return [comp for comp in components if comp != main_component and len(comp) > 0]\r\n \r\n def auto_fix_connectivity(self) -> Tuple[int, List[str]]:\r\n actions = []\r\n connections_created = 0\r\n \r\n def get_suggested_weight(source_cat: str, target_cat: str, rng: random.Random) -> float:\r\n tendencies = {\r\n ('sensor', 'core'): (0.3, 0.6), ('sensor', 'sensor'): (-0.2, 0.4),\r\n ('custom', 'core'): (-0.4, 0.8), ('custom', 'custom'): (-0.5, 0.5),\r\n ('core', 'core'): (-0.3, 0.7),\r\n }\r\n key = (source_cat, target_cat)\r\n if key not in tendencies: key = (target_cat, source_cat)\r\n if key not in tendencies: key = ('custom', 'custom')\r\n min_w, max_w = tendencies[key]\r\n return rng.uniform(min_w, max_w)\r\n \r\n def find_nearest_core(neuron_pos: Tuple[float, float]) -> Optional[str]:\r\n core_neurons = [n for n in self.neurons.values() if n.is_core]\r\n if not core_neurons: return None\r\n return min(core_neurons, key=lambda n: math.hypot(neuron_pos[0] - n.position[0], neuron_pos[1] - n.position[1])).name\r\n\r\n fix_rng = random.Random()\r\n fix_rng.seed(time.time() + hash(tuple(sorted(self.neurons.keys()))) % 10000)\r\n \r\n for orphan_name in self.get_orphan_neurons():\r\n orphan = self.neurons[orphan_name]\r\n target_name = find_nearest_core(orphan.position)\r\n if target_name:\r\n w1 = get_suggested_weight(orphan.category, self.neurons[target_name].category, fix_rng)\r\n w2 = get_suggested_weight(self.neurons[target_name].category, orphan.category, fix_rng)\r\n self.add_connection(orphan_name, target_name, w1)\r\n self.add_connection(target_name, orphan_name, w2)\r\n connections_created += 2\r\n actions.append(f\"Connected orphan '{orphan_name}' ↔ '{target_name}'\")\r\n\r\n main_network = set()\r\n for conn in self.connections:\r\n if is_core_neuron(conn.source) or is_core_neuron(conn.target):\r\n main_network.add(conn.source)\r\n main_network.add(conn.target)\r\n if not main_network:\r\n main_network = set(self.neurons.keys()) \r\n\r\n for island in self.get_island_neurons():\r\n island_list = list(island)\r\n island_center = (\r\n sum(self.neurons[n].position[0] for n in island_list) / len(island_list),\r\n sum(self.neurons[n].position[1] for n in island_list) / len(island_list)\r\n )\r\n nearest_main = find_nearest_core(island_center)\r\n if nearest_main:\r\n connect_count = min(2, len(island_list))\r\n for i in range(connect_count):\r\n n = island_list[i % len(island_list)]\r\n w = get_suggested_weight(self.neurons[n].category, self.neurons[nearest_main].category, fix_rng)\r\n self.add_connection(n, nearest_main, w)\r\n connections_created += 1\r\n actions.append(f\"Connected island node '{n}' → '{nearest_main}'\")\r\n \r\n return connections_created, actions\r\n\r\n def add_sensor(self, name: str, create_default_connections: bool = True) -> Tuple[bool, str]:\r\n if name not in INPUT_SENSORS and name != 'can_see_food':\r\n return False, f\"'{name}' is not a valid input sensor\"\r\n if name in self.neurons:\r\n return False, f\"Sensor '{name}' already exists\"\r\n \r\n pos = REQUIRED_NEURONS[name] if name == 'can_see_food' else INPUT_SENSORS[name]\r\n self.add_neuron(DesignerNeuron(name=name, neuron_type=NeuronType.SENSOR, position=pos, is_binary=is_binary_neuron(name)))\r\n \r\n conns_made = []\r\n if create_default_connections:\r\n for target, weight in get_default_connections_for_sensor(name):\r\n if target in self.neurons:\r\n self.add_connection(name, target, weight)\r\n conns_made.append(f\"{name}→{target}\")\r\n return True, f\"Added sensor '{name}' with connections: {', '.join(conns_made)}\"\r\n\r\n def add_all_sensors(self) -> int:\r\n added = 0\r\n for name in INPUT_SENSORS:\r\n if self.add_sensor(name)[0]: added += 1\r\n return added\r\n \r\n def get_sensors_in_design(self) -> List[str]:\r\n return [name for name, neuron in self.neurons.items() if neuron.is_sensor]\r\n \r\n def validate(self, auto_fix: bool = True) -> Tuple[bool, List[str], int]:\r\n issues = []\r\n auto_added = 0\r\n missing_required = self.get_missing_required_neurons()\r\n \r\n if missing_required:\r\n if auto_fix:\r\n auto_added = self.add_missing_required_neurons()\r\n issues.append(f\"Auto-added missing required: {', '.join(missing_required)}\")\r\n else:\r\n issues.append(f\"BLOCKING: Missing required: {', '.join(missing_required)}\")\r\n \r\n orphans = self.get_orphan_neurons()\r\n if orphans:\r\n if auto_fix:\r\n conns, actions = self.auto_fix_connectivity()\r\n issues.append(f\"Auto-fixed orphans with {conns} new connections\")\r\n issues.extend(actions)\r\n auto_added += conns\r\n else:\r\n issues.append(f\"WARNING: Orphan neurons: {', '.join(orphans)}\")\r\n \r\n if 'can_see_food' not in self.neurons:\r\n issues.append(\"WARNING: Missing 'can_see_food' sensor!\")\r\n \r\n return not any(\"BLOCKING\" in i for i in issues), issues, auto_added\r\n \r\n def get_stats(self) -> Dict:\r\n return {\r\n 'total_neurons': len(self.neurons),\r\n 'connections': len(self.connections),\r\n 'has_all_required': self.has_all_required_neurons(),\r\n 'missing_required': self.get_missing_required_neurons(),\r\n 'orphan_neurons': self.get_orphan_neurons(),\r\n 'island_groups': len(self.get_island_neurons()),\r\n 'sensors_used': self.get_sensors_in_design(),\r\n 'required_neurons': sum(1 for n in self.neurons.values() if n.is_required),\r\n 'sensor_neurons': sum(1 for n in self.neurons.values() if n.is_sensor and not n.is_required),\r\n 'custom_neurons': sum(1 for n in self.neurons.values() if not n.is_required and not n.is_sensor),\r\n 'layers': len(self.layers)\r\n }\r\n\r\n def to_dosidicus_format(self) -> dict:\r\n neurons = {}\r\n for name, obj in self.neurons.items():\r\n neurons[name] = {\r\n 'position': list(obj.position),\r\n 'type': obj.neuron_type.name.lower(),\r\n 'is_binary': obj.is_binary,\r\n 'is_core': obj.is_core,\r\n 'is_sensor': obj.is_sensor,\r\n 'activation': 0.0 if obj.is_binary else (50.0 if obj.is_core else 0.0),\r\n }\r\n \r\n connections = {}\r\n for c in self.connections:\r\n key = f\"{c.source}->{c.target}\"\r\n connections[key] = c.weight\r\n \r\n state = {}\r\n for name, obj in self.neurons.items():\r\n if obj.is_binary:\r\n state[name] = False\r\n elif obj.is_core:\r\n state[name] = 50.0\r\n else:\r\n state[name] = 0.0\r\n \r\n return {\r\n 'version': '2.0',\r\n 'format': 'dosidicus',\r\n 'metadata': self.metadata.copy(),\r\n 'neurons': neurons,\r\n 'connections': connections,\r\n 'state': state,\r\n 'neuron_shapes': {n: obj.shape for n, obj in self.neurons.items()}, \r\n 'excluded_neurons': [],\r\n 'output_bindings': self.output_bindings,\r\n 'neuron_positions': {n: tuple(obj.position) for n, obj in self.neurons.items()},\r\n 'weights': {f\"{c.source}|{c.target}\": c.weight for c in self.connections},\r\n 'layer_structure': [l.to_dict() for l in self.layers],\r\n 'neuron_details': {n: obj.to_dict() for n, obj in self.neurons.items()},\r\n 'sensors_used': self.get_sensors_in_design(),\r\n 'required_complete': self.has_all_required_neurons()\r\n }\r\n \r\n def to_designer_format(self) -> dict:\r\n neurons = {}\r\n for n in self.neurons.values():\r\n neurons[n.name] = {\r\n 'name': n.name,\r\n 'position': list(n.position),\r\n 'neuron_type': n.neuron_type.name.lower(),\r\n 'layer_index': n.layer_index,\r\n 'color': list(n.color),\r\n 'description': n.description,\r\n 'is_binary': n.is_binary,\r\n 'category': n.category,\r\n 'activation': 0.0 if n.is_binary else (50.0 if n.is_core else 0.0),\r\n 'shape': n.shape\r\n }\r\n \r\n connections = [c.to_dict() for c in self.connections]\r\n \r\n return {\r\n 'version': '2.0',\r\n 'format': 'brain_designer',\r\n 'metadata': self.metadata.copy(),\r\n 'neurons': neurons,\r\n 'connections': connections,\r\n 'layers': [l.to_dict() for l in self.layers],\r\n 'excluded_neurons': [],\r\n 'output_bindings': self.output_bindings,\r\n }\r\n \r\n @classmethod\r\n def from_designer_format(cls, data: dict) -> 'BrainDesign':\r\n design = cls()\r\n design.metadata = data.get('metadata', {})\r\n for l in data.get('layers', []):\r\n design.layers.append(DesignerLayer.from_dict(l))\r\n \r\n neurons_data = data.get('neurons', [])\r\n if isinstance(neurons_data, dict):\r\n for name, n in neurons_data.items():\r\n if 'name' not in n:\r\n n['name'] = name\r\n neuron = DesignerNeuron.from_dict(n)\r\n design.add_neuron(neuron)\r\n else:\r\n for n in neurons_data:\r\n neuron = DesignerNeuron.from_dict(n)\r\n design.add_neuron(neuron)\r\n \r\n for c in data.get('connections', []):\r\n design.connections.append(DesignerConnection.from_dict(c))\r\n \r\n design.output_bindings = data.get('output_bindings', [])\r\n return design\r\n \r\n @classmethod\r\n def from_dosidicus_format(cls, data: dict) -> 'BrainDesign':\r\n design = cls()\r\n design.metadata = data.get('metadata', {'name': 'Imported Brain'})\r\n for l in data.get('layer_structure', []):\r\n design.layers.append(DesignerLayer.from_dict(l))\r\n \r\n neurons_data = data.get('neurons', {})\r\n shapes_data = data.get('neuron_shapes', {})\r\n \r\n if neurons_data and isinstance(neurons_data, dict):\r\n for name, nd in neurons_data.items():\r\n pos = nd.get('position', [0, 0])\r\n ntype_str = nd.get('type', 'hidden').upper()\r\n try:\r\n ntype = NeuronType[ntype_str]\r\n except KeyError:\r\n ntype = NeuronType.CORE if is_core_neuron(name) else (\r\n NeuronType.SENSOR if is_input_sensor(name) else NeuronType.HIDDEN\r\n )\r\n \r\n shape = shapes_data.get(name, 'circle')\r\n \r\n neuron = DesignerNeuron(\r\n name=name,\r\n neuron_type=ntype,\r\n position=tuple(pos) if isinstance(pos, list) else pos,\r\n is_binary=nd.get('is_binary', False),\r\n shape=shape\r\n )\r\n design.add_neuron(neuron)\r\n else:\r\n details = data.get('neuron_details', {})\r\n for name, pos in data.get('neuron_positions', {}).items():\r\n if name in details:\r\n neuron = DesignerNeuron.from_dict(details[name])\r\n design.add_neuron(neuron)\r\n else:\r\n ntype = NeuronType.CORE if is_core_neuron(name) else (\r\n NeuronType.SENSOR if is_input_sensor(name) else NeuronType.HIDDEN\r\n )\r\n shape = shapes_data.get(name, 'circle')\r\n neuron = DesignerNeuron(name=name, neuron_type=ntype, position=tuple(pos), shape=shape)\r\n design.add_neuron(neuron)\r\n \r\n connections_data = data.get('connections', {})\r\n if isinstance(connections_data, dict):\r\n for k, w in connections_data.items():\r\n if '->' in k:\r\n s, t = k.split('->')\r\n elif '|' in k:\r\n s, t = k.split('|')\r\n else:\r\n continue\r\n design.connections.append(DesignerConnection(s.strip(), t.strip(), w))\r\n elif isinstance(connections_data, list):\r\n for c in connections_data:\r\n if c.get('source') and c.get('target'):\r\n design.connections.append(DesignerConnection(\r\n c['source'], c['target'], c.get('weight', 0.1)\r\n ))\r\n \r\n if not design.connections:\r\n for k, w in data.get('weights', {}).items():\r\n if '|' in k:\r\n s, t = k.split('|')\r\n design.connections.append(DesignerConnection(s, t, w))\r\n \r\n design.output_bindings = data.get('output_bindings', [])\r\n return design\r\n \r\n def save(self, filepath: str, format: str = 'designer') -> Tuple[bool, str]:\r\n is_valid, issues, auto_added = self.validate(auto_fix=True)\r\n if not is_valid: \r\n return False, \"Save blocked by validation issues.\"\r\n \r\n try:\r\n data = self.to_dosidicus_format() if format == 'dosidicus' else self.to_designer_format()\r\n with open(filepath, 'w') as f: json.dump(data, f, indent=2)\r\n \r\n msg = f\"Saved successfully ({len(self.neurons)} neurons)\"\r\n if auto_added > 0: msg += f\"\\n(Applied {auto_added} auto-fixes)\"\r\n return True, msg\r\n except Exception as e:\r\n return False, f\"Error saving: {e}\"\r\n \r\n @classmethod\r\n def load(cls, filepath: str) -> 'BrainDesign':\r\n with open(filepath, 'r') as f: data = json.load(f)\r\n return cls.from_dosidicus_format(data) if data.get('format') == 'dosidicus' else cls.from_designer_format(data)\r\n\r\n def export_dosidicus(self, filepath):\r\n return self.save(filepath, format='dosidicus')"
},
{
"path": "src/designer_dialogs.py",
"content": "\"\"\"\r\nSparse Network Generation Dialog\r\n\r\nProvides UI for generating random sparse networks with various presets.\r\n\"\"\"\r\n\r\nfrom PyQt5.QtWidgets import (\r\n QDialog, QVBoxLayout, QHBoxLayout, QGroupBox, QLabel, QPushButton,\r\n QComboBox, QDoubleSpinBox, QCheckBox, QTextEdit, QFrame, QProgressBar,\r\n QSizePolicy\r\n)\r\nfrom PyQt5.QtCore import Qt, QTimer\r\nfrom PyQt5.QtGui import QFont\r\n\r\nfrom .designer_network_generator import SparseNetworkGenerator\r\n\r\n\r\nclass SparseNetworkDialog(QDialog):\r\n \"\"\"Dialog for generating sparse neural networks.\"\"\"\r\n \r\n def __init__(self, design, parent=None):\r\n super().__init__(parent)\r\n self.design = design\r\n self.generator = SparseNetworkGenerator()\r\n self.result_connections = []\r\n self.result_actions = []\r\n \r\n self.setWindowTitle(\"🎲 Generate Sparse Network\")\r\n self.setMinimumWidth(500)\r\n self.setMinimumHeight(550)\r\n \r\n self.setup_ui()\r\n self.load_preset('balanced')\r\n \r\n def setup_ui(self):\r\n layout = QVBoxLayout(self)\r\n \r\n # Header\r\n header = QLabel(\"Generate Random Neural Connections\")\r\n header.setFont(QFont(\"Arial\", 12, QFont.Bold))\r\n header.setAlignment(Qt.AlignCenter)\r\n layout.addWidget(header)\r\n \r\n desc = QLabel(\r\n \"Creates biologically-inspired connections between the 8 required neurons.\\n\"\r\n \"Each generation is unique due to random noise.\"\r\n )\r\n desc.setStyleSheet(\"color: #666; font-size: 10pt;\")\r\n desc.setAlignment(Qt.AlignCenter)\r\n desc.setWordWrap(True)\r\n layout.addWidget(desc)\r\n \r\n layout.addSpacing(10)\r\n \r\n # Preset selection\r\n preset_group = QGroupBox(\"Style Preset\")\r\n preset_layout = QHBoxLayout(preset_group)\r\n \r\n self.preset_combo = QComboBox()\r\n presets = self.generator.get_preset_styles()\r\n for key, info in presets.items():\r\n self.preset_combo.addItem(info['name'], key)\r\n self.preset_combo.currentIndexChanged.connect(self.on_preset_changed)\r\n preset_layout.addWidget(self.preset_combo)\r\n \r\n self.preset_desc = QLabel()\r\n self.preset_desc.setStyleSheet(\"color: #888; font-style: italic;\")\r\n preset_layout.addWidget(self.preset_desc, stretch=1)\r\n \r\n layout.addWidget(preset_group)\r\n \r\n # Advanced options\r\n advanced_group = QGroupBox(\"Fine Tuning\")\r\n advanced_layout = QVBoxLayout(advanced_group)\r\n \r\n # Density & Noise\r\n row1 = QHBoxLayout()\r\n row1.addWidget(QLabel(\"Density:\"))\r\n self.density_spin = QDoubleSpinBox()\r\n self.density_spin.setRange(0.2, 2.0)\r\n self.density_spin.setSingleStep(0.1)\r\n self.density_spin.setDecimals(1)\r\n self.density_spin.setValue(1.0)\r\n self.density_spin.setToolTip(\"Lower = fewer connections, Higher = more connections\")\r\n row1.addWidget(self.density_spin)\r\n \r\n row1.addSpacing(20)\r\n \r\n row1.addWidget(QLabel(\"Weight Noise:\"))\r\n self.noise_spin = QDoubleSpinBox()\r\n self.noise_spin.setRange(0.1, 3.0)\r\n self.noise_spin.setSingleStep(0.1)\r\n self.noise_spin.setDecimals(1)\r\n self.noise_spin.setValue(1.0)\r\n self.noise_spin.setToolTip(\"How much randomness in connection weights\")\r\n row1.addWidget(self.noise_spin)\r\n advanced_layout.addLayout(row1)\r\n\r\n # Variance & Sensors (NEW)\r\n row2 = QHBoxLayout()\r\n row2.addWidget(QLabel(\"Pos Variance:\"))\r\n self.variance_spin = QDoubleSpinBox()\r\n self.variance_spin.setRange(0.0, 1.0)\r\n self.variance_spin.setSingleStep(0.1)\r\n self.variance_spin.setDecimals(2)\r\n self.variance_spin.setValue(0.0)\r\n self.variance_spin.setToolTip(\"Jitter neuron positions (0.0 = fixed, 0.5 = chaotic)\")\r\n row2.addWidget(self.variance_spin)\r\n \r\n row2.addSpacing(20)\r\n \r\n row2.addWidget(QLabel(\"Sensor Prob:\"))\r\n self.sensor_prob_spin = QDoubleSpinBox()\r\n self.sensor_prob_spin.setRange(0.0, 1.0)\r\n self.sensor_prob_spin.setSingleStep(0.1)\r\n self.sensor_prob_spin.setDecimals(2)\r\n self.sensor_prob_spin.setValue(0.0)\r\n self.sensor_prob_spin.setToolTip(\"Probability of adding random extra sensors\")\r\n row2.addWidget(self.sensor_prob_spin)\r\n advanced_layout.addLayout(row2)\r\n \r\n # Options row\r\n options_row = QHBoxLayout()\r\n \r\n self.feedback_check = QCheckBox(\"Include feedback loops\")\r\n self.feedback_check.setChecked(True)\r\n self.feedback_check.setToolTip(\"Allow bidirectional connections where biologically plausible\")\r\n options_row.addWidget(self.feedback_check)\r\n \r\n self.clear_check = QCheckBox(\"Clear existing connections\")\r\n self.clear_check.setChecked(True)\r\n self.clear_check.setToolTip(\"Remove all existing connections before generating\")\r\n options_row.addWidget(self.clear_check)\r\n \r\n options_row.addStretch()\r\n advanced_layout.addLayout(options_row)\r\n \r\n layout.addWidget(advanced_group)\r\n \r\n # Preview area\r\n preview_group = QGroupBox(\"Preview\")\r\n preview_layout = QVBoxLayout(preview_group)\r\n \r\n self.preview_text = QTextEdit()\r\n self.preview_text.setReadOnly(True)\r\n self.preview_text.setMaximumHeight(150)\r\n self.preview_text.setStyleSheet(\"\"\"\r\n QTextEdit {\r\n font-family: monospace;\r\n font-size: 9pt;\r\n background-color: #f5f5f5;\r\n }\r\n \"\"\")\r\n preview_layout.addWidget(self.preview_text)\r\n \r\n preview_btn_row = QHBoxLayout()\r\n self.preview_btn = QPushButton(\"🔄 Preview Generation\")\r\n self.preview_btn.clicked.connect(self.generate_preview)\r\n preview_btn_row.addWidget(self.preview_btn)\r\n preview_btn_row.addStretch()\r\n \r\n self.count_label = QLabel()\r\n self.count_label.setStyleSheet(\"color: #666;\")\r\n preview_btn_row.addWidget(self.count_label)\r\n \r\n preview_layout.addLayout(preview_btn_row)\r\n layout.addWidget(preview_group)\r\n \r\n # Separator\r\n line = QFrame()\r\n line.setFrameShape(QFrame.HLine)\r\n line.setFrameShadow(QFrame.Sunken)\r\n layout.addWidget(line)\r\n \r\n # Buttons\r\n btn_layout = QHBoxLayout()\r\n \r\n self.cancel_btn = QPushButton(\"Cancel\")\r\n self.cancel_btn.clicked.connect(self.reject)\r\n btn_layout.addWidget(self.cancel_btn)\r\n \r\n btn_layout.addStretch()\r\n \r\n self.apply_btn = QPushButton(\"✨ Generate && Apply\")\r\n self.apply_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #4CAF50;\r\n color: white;\r\n font-weight: bold;\r\n padding: 8px 20px;\r\n }\r\n QPushButton:hover {\r\n background-color: #45a049;\r\n }\r\n \"\"\")\r\n self.apply_btn.clicked.connect(self.apply_generation)\r\n btn_layout.addWidget(self.apply_btn)\r\n \r\n layout.addLayout(btn_layout)\r\n \r\n # Initial preview\r\n QTimer.singleShot(100, self.generate_preview)\r\n \r\n def on_preset_changed(self, index):\r\n key = self.preset_combo.currentData()\r\n self.load_preset(key)\r\n \r\n def load_preset(self, key):\r\n presets = self.generator.get_preset_styles()\r\n if key not in presets:\r\n return\r\n \r\n preset = presets[key]\r\n self.preset_desc.setText(preset['description'])\r\n \r\n # Block signals during update\r\n self.density_spin.blockSignals(True)\r\n self.noise_spin.blockSignals(True)\r\n self.variance_spin.blockSignals(True)\r\n self.sensor_prob_spin.blockSignals(True)\r\n self.feedback_check.blockSignals(True)\r\n \r\n self.density_spin.setValue(preset['density'])\r\n self.noise_spin.setValue(preset.get('weight_noise', 1.0))\r\n self.variance_spin.setValue(preset.get('position_variance', 0.0))\r\n self.sensor_prob_spin.setValue(preset.get('sensor_probability', 0.0))\r\n self.feedback_check.setChecked(preset.get('include_feedback', True))\r\n \r\n self.density_spin.blockSignals(False)\r\n self.noise_spin.blockSignals(False)\r\n self.variance_spin.blockSignals(False)\r\n self.sensor_prob_spin.blockSignals(False)\r\n self.feedback_check.blockSignals(False)\r\n \r\n self.generate_preview()\r\n \r\n def generate_preview(self):\r\n \"\"\"Generate a preview without applying.\"\"\"\r\n # Create fresh generator (no seed for variety)\r\n gen = SparseNetworkGenerator()\r\n \r\n # Pass the weight_noise parameter\r\n connections = gen.generate_connections(\r\n density=self.density_spin.value(),\r\n include_feedback_loops=self.feedback_check.isChecked(),\r\n weight_noise=self.noise_spin.value()\r\n )\r\n \r\n self.result_connections = connections\r\n \r\n # Format preview\r\n lines = []\r\n excitatory = 0\r\n inhibitory = 0\r\n \r\n for source, target, weight in connections:\r\n sign = \"+\" if weight > 0 else \"\"\r\n arrow = \"→\" if weight > 0 else \"⊣\"\r\n lines.append(f\" {source:15} {arrow} {target:15} ({sign}{weight:.3f})\")\r\n if weight > 0:\r\n excitatory += 1\r\n else:\r\n inhibitory += 1\r\n \r\n # Add note about sensors/variance if active\r\n if self.sensor_prob_spin.value() > 0:\r\n lines.insert(0, f\"NOTE: Will attempt to add random sensors (Prob: {self.sensor_prob_spin.value()})\")\r\n if self.variance_spin.value() > 0:\r\n lines.insert(0, f\"NOTE: Will randomly perturb positions (Var: {self.variance_spin.value()})\")\r\n \r\n if lines:\r\n self.preview_text.setPlainText(\"\\n\".join(lines))\r\n else:\r\n self.preview_text.setPlainText(\"No connections would be created with these settings.\")\r\n \r\n # Update count\r\n total = len(connections)\r\n self.count_label.setText(\r\n f\"{total} connections ({excitatory} excitatory, {inhibitory} inhibitory)\"\r\n )\r\n \r\n def apply_generation(self):\r\n \"\"\"Apply the generated network to the design.\"\"\"\r\n gen = SparseNetworkGenerator()\r\n \r\n # Now passing all new arguments to fix the TypeError\r\n count, actions = gen.generate_for_design(\r\n self.design,\r\n clear_existing=self.clear_check.isChecked(),\r\n density=self.density_spin.value(),\r\n include_feedback=self.feedback_check.isChecked(),\r\n weight_noise=self.noise_spin.value(),\r\n position_variance=self.variance_spin.value(),\r\n sensor_probability=self.sensor_prob_spin.value()\r\n )\r\n \r\n self.result_actions = actions\r\n self.accept()\r\n \r\n def get_result_summary(self) -> str:\r\n \"\"\"Get a summary of what was generated.\"\"\"\r\n return f\"Created {len(self.result_connections)} connections\"\r\n\r\n\r\nclass ActivationEditorDialog(QDialog):\r\n \"\"\"Dialog for viewing and editing neuron activation values.\"\"\"\r\n \r\n def __init__(self, neuron_name: str, current_activation: float, \r\n is_binary: bool = False, parent=None):\r\n super().__init__(parent)\r\n self.neuron_name = neuron_name\r\n self.is_binary = is_binary\r\n self.result_value = current_activation\r\n \r\n self.setWindowTitle(f\"Activation: {neuron_name}\")\r\n self.setMinimumWidth(300)\r\n \r\n self.setup_ui(current_activation)\r\n \r\n def setup_ui(self, current_value):\r\n layout = QVBoxLayout(self)\r\n \r\n # Header\r\n name_label = QLabel(self.neuron_name.replace('_', ' ').title())\r\n name_label.setFont(QFont(\"Arial\", 11, QFont.Bold))\r\n name_label.setAlignment(Qt.AlignCenter)\r\n layout.addWidget(name_label)\r\n \r\n if self.is_binary:\r\n # Binary neuron: on/off toggle\r\n info = QLabel(\"Binary neuron (On/Off)\")\r\n info.setStyleSheet(\"color: #666;\")\r\n info.setAlignment(Qt.AlignCenter)\r\n layout.addWidget(info)\r\n \r\n btn_row = QHBoxLayout()\r\n \r\n self.off_btn = QPushButton(\"OFF (0)\")\r\n self.off_btn.setCheckable(True)\r\n self.off_btn.setChecked(current_value < 50)\r\n self.off_btn.clicked.connect(lambda: self.set_binary(False))\r\n btn_row.addWidget(self.off_btn)\r\n \r\n self.on_btn = QPushButton(\"ON (100)\")\r\n self.on_btn.setCheckable(True)\r\n self.on_btn.setChecked(current_value >= 50)\r\n self.on_btn.clicked.connect(lambda: self.set_binary(True))\r\n btn_row.addWidget(self.on_btn)\r\n \r\n layout.addLayout(btn_row)\r\n \r\n else:\r\n # Continuous neuron: spinner\r\n info = QLabel(\"Activation (0-100)\")\r\n info.setStyleSheet(\"color: #666;\")\r\n info.setAlignment(Qt.AlignCenter)\r\n layout.addWidget(info)\r\n \r\n spin_row = QHBoxLayout()\r\n spin_row.addStretch()\r\n \r\n self.value_spin = QDoubleSpinBox()\r\n self.value_spin.setRange(0, 100)\r\n self.value_spin.setSingleStep(5)\r\n self.value_spin.setDecimals(1)\r\n self.value_spin.setValue(current_value)\r\n self.value_spin.setMinimumWidth(100)\r\n spin_row.addWidget(self.value_spin)\r\n \r\n spin_row.addStretch()\r\n layout.addLayout(spin_row)\r\n \r\n # Quick buttons\r\n quick_row = QHBoxLayout()\r\n for val, label in [(0, \"Min\"), (25, \"Low\"), (50, \"Mid\"), (75, \"High\"), (100, \"Max\")]:\r\n btn = QPushButton(label)\r\n btn.setMaximumWidth(50)\r\n btn.clicked.connect(lambda checked, v=val: self.value_spin.setValue(v))\r\n quick_row.addWidget(btn)\r\n layout.addLayout(quick_row)\r\n \r\n layout.addSpacing(15)\r\n \r\n # Buttons\r\n btn_layout = QHBoxLayout()\r\n \r\n cancel_btn = QPushButton(\"Cancel\")\r\n cancel_btn.clicked.connect(self.reject)\r\n btn_layout.addWidget(cancel_btn)\r\n \r\n btn_layout.addStretch()\r\n \r\n ok_btn = QPushButton(\"OK\")\r\n ok_btn.clicked.connect(self.accept_value)\r\n ok_btn.setDefault(True)\r\n btn_layout.addWidget(ok_btn)\r\n \r\n layout.addLayout(btn_layout)\r\n \r\n def set_binary(self, is_on: bool):\r\n self.off_btn.setChecked(not is_on)\r\n self.on_btn.setChecked(is_on)\r\n self.result_value = 100.0 if is_on else 0.0\r\n \r\n def accept_value(self):\r\n if self.is_binary:\r\n self.result_value = 100.0 if self.on_btn.isChecked() else 0.0\r\n else:\r\n self.result_value = self.value_spin.value()\r\n self.accept()\r\n \r\n def get_value(self) -> float:\r\n return self.result_value"
},
{
"path": "src/designer_logging.py",
"content": "\"\"\"\r\nDesigner Logging - Centralized logging for Brain Designer\r\n\r\nProvides logging utilities that can be enabled/disabled based on debug mode.\r\n\"\"\"\r\n\r\nimport logging\r\nimport os\r\nimport sys\r\nimport traceback\r\nfrom datetime import datetime\r\nfrom contextlib import contextmanager\r\n\r\n\r\n# Global logger instance\r\n_logger = None\r\n_logging_enabled = False\r\n\r\n\r\nclass NullHandler(logging.Handler):\r\n \"\"\"A handler that does nothing - used when logging is disabled.\"\"\"\r\n def emit(self, record):\r\n pass\r\n\r\n\r\nclass CrashReporter:\r\n \"\"\"Handles crash reporting and error dialogs.\"\"\"\r\n \r\n def __init__(self, enable_logging: bool = False):\r\n self._error_dialog_callback = None\r\n self._logging_enabled = enable_logging\r\n \r\n def set_error_dialog_callback(self, callback):\r\n \"\"\"Set the callback function for showing error dialogs.\"\"\"\r\n self._error_dialog_callback = callback\r\n \r\n def report_crash(self, exc_type, exc_value, exc_tb):\r\n \"\"\"Report a crash - log it and optionally show dialog.\"\"\"\r\n error_msg = ''.join(traceback.format_exception(exc_type, exc_value, exc_tb))\r\n \r\n if self._logging_enabled:\r\n logger = get_logger()\r\n logger.critical(f\"Crash reported:\\n{error_msg}\")\r\n \r\n if self._error_dialog_callback:\r\n self._error_dialog_callback(\r\n \"Critical Error\",\r\n f\"An unexpected error occurred:\\n\\n{exc_value}\"\r\n )\r\n\r\n\r\ndef get_log_directory() -> str:\r\n \"\"\"Get the directory for log files.\"\"\"\r\n # Logs go in the root folder's logs/ directory (one level up from src/)\r\n script_dir = os.path.dirname(os.path.abspath(__file__))\r\n parent_dir = os.path.dirname(script_dir) # Go up one level from src/\r\n log_dir = os.path.join(parent_dir, 'logs')\r\n return log_dir\r\n\r\n\r\ndef initialize_error_handling(enable_logging: bool = False) -> CrashReporter:\r\n \"\"\"\r\n Initialize error handling and optionally set up logging.\r\n \r\n Args:\r\n enable_logging: If True, creates log files and enables logging.\r\n If False, logging calls are no-ops.\r\n \r\n Returns:\r\n CrashReporter instance\r\n \"\"\"\r\n global _logger, _logging_enabled\r\n _logging_enabled = enable_logging\r\n \r\n # Create logger\r\n _logger = logging.getLogger('brain_designer')\r\n _logger.handlers.clear() # Remove any existing handlers\r\n \r\n if enable_logging:\r\n # Set up actual logging\r\n _logger.setLevel(logging.DEBUG)\r\n \r\n # Create logs directory\r\n log_dir = get_log_directory()\r\n os.makedirs(log_dir, exist_ok=True)\r\n \r\n # Create file handler with timestamp\r\n timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')\r\n log_file = os.path.join(log_dir, f'designer_{timestamp}.log')\r\n \r\n file_handler = logging.FileHandler(log_file, encoding='utf-8')\r\n file_handler.setLevel(logging.DEBUG)\r\n \r\n # Create console handler\r\n console_handler = logging.StreamHandler(sys.stdout)\r\n console_handler.setLevel(logging.INFO)\r\n \r\n # Create formatter\r\n formatter = logging.Formatter(\r\n '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\r\n )\r\n file_handler.setFormatter(formatter)\r\n console_handler.setFormatter(formatter)\r\n \r\n _logger.addHandler(file_handler)\r\n _logger.addHandler(console_handler)\r\n \r\n _logger.info(f\"Logging initialized. Log file: {log_file}\")\r\n else:\r\n # Disable logging - use null handler\r\n _logger.setLevel(logging.CRITICAL + 1) # Effectively disable all logging\r\n _logger.addHandler(NullHandler())\r\n \r\n # Create crash reporter\r\n crash_reporter = CrashReporter(enable_logging)\r\n \r\n # Install global exception handler\r\n def exception_handler(exc_type, exc_value, exc_tb):\r\n if exc_type != KeyboardInterrupt:\r\n crash_reporter.report_crash(exc_type, exc_value, exc_tb)\r\n sys.__excepthook__(exc_type, exc_value, exc_tb)\r\n \r\n sys.excepthook = exception_handler\r\n \r\n return crash_reporter\r\n\r\n\r\ndef get_logger(name: str = None) -> logging.Logger:\r\n \"\"\"\r\n Get a logger instance.\r\n \r\n Args:\r\n name: Optional sub-logger name. If None, returns the main designer logger.\r\n \r\n Returns:\r\n Logger instance\r\n \"\"\"\r\n global _logger\r\n \r\n if _logger is None:\r\n # Initialize with logging disabled by default\r\n initialize_error_handling(enable_logging=False)\r\n \r\n if name:\r\n return _logger.getChild(name)\r\n return _logger\r\n\r\n\r\n@contextmanager\r\ndef OperationLogger(operation_name: str, logger: logging.Logger = None):\r\n \"\"\"\r\n Context manager for logging operations with timing.\r\n \r\n Usage:\r\n with OperationLogger(\"Loading data\"):\r\n load_data()\r\n \r\n Args:\r\n operation_name: Name of the operation being performed\r\n logger: Optional specific logger to use\r\n \"\"\"\r\n if logger is None:\r\n logger = get_logger()\r\n \r\n if not _logging_enabled:\r\n # Just execute the block without logging\r\n yield\r\n return\r\n \r\n start_time = datetime.now()\r\n logger.debug(f\"Starting: {operation_name}\")\r\n \r\n try:\r\n yield\r\n elapsed = (datetime.now() - start_time).total_seconds()\r\n logger.debug(f\"Completed: {operation_name} ({elapsed:.3f}s)\")\r\n except Exception as e:\r\n elapsed = (datetime.now() - start_time).total_seconds()\r\n logger.error(f\"Failed: {operation_name} ({elapsed:.3f}s) - {e}\")\r\n raise\r\n\r\n\r\ndef log_exceptions(func):\r\n \"\"\"\r\n Decorator to log exceptions from a function.\r\n \r\n Usage:\r\n @log_exceptions\r\n def my_function():\r\n ...\r\n \"\"\"\r\n def wrapper(*args, **kwargs):\r\n try:\r\n return func(*args, **kwargs)\r\n except Exception as e:\r\n if _logging_enabled:\r\n logger = get_logger()\r\n logger.error(f\"Exception in {func.__name__}: {e}\", exc_info=True)\r\n raise\r\n return wrapper\r\n\r\n\r\ndef safe_call(func, *args, default=None, **kwargs):\r\n \"\"\"\r\n Safely call a function, returning default on exception.\r\n \r\n Args:\r\n func: Function to call\r\n *args: Positional arguments\r\n default: Value to return on exception\r\n **kwargs: Keyword arguments\r\n \r\n Returns:\r\n Function result or default value\r\n \"\"\"\r\n try:\r\n return func(*args, **kwargs)\r\n except Exception as e:\r\n if _logging_enabled:\r\n logger = get_logger()\r\n logger.warning(f\"safe_call caught exception in {func.__name__}: {e}\")\r\n return default\r\n"
},
{
"path": "src/designer_network_generator.py",
"content": "\"\"\"\r\nSparse Neural Network Generator\r\n\r\nGenerates realistic, biologically-inspired connections between the core neurons\r\nwith random noise so no two generations are identical.\r\n\"\"\"\r\n\r\nimport random\r\nimport math\r\nfrom typing import List, Tuple, Dict, Optional\r\nfrom dataclasses import dataclass\r\n\r\nfrom .designer_constants import CORE_NEURONS, REQUIRED_NEURON_NAMES\r\n\r\n\r\n@dataclass\r\nclass ConnectionTemplate:\r\n \"\"\"Template for a potential connection with probability and weight range.\"\"\"\r\n source: str\r\n target: str\r\n base_weight: float # Central weight value\r\n weight_variance: float # +/- variance\r\n probability: float # Chance this connection is created (0.0 - 1.0)\r\n description: str = \"\"\r\n\r\n\r\n# ============================================================================\r\n# BIOLOGICALLY-INSPIRED CONNECTION TEMPLATES\r\n# These define the \"tendencies\" of the neural network - realistic relationships\r\n# between hunger, emotions, and sensory input\r\n# ============================================================================\r\n\r\nCORE_CONNECTION_TEMPLATES = [\r\n # === HUNGER dynamics ===\r\n # Hunger creates dissatisfaction and negative mood\r\n ConnectionTemplate(\"hunger\", \"satisfaction\", -0.35, 0.15, 0.85,\r\n \"Being hungry reduces satisfaction\"),\r\n ConnectionTemplate(\"hunger\", \"happiness\", -0.25, 0.12, 0.70,\r\n \"Hunger negatively affects mood\"),\r\n ConnectionTemplate(\"hunger\", \"anxiety\", 0.20, 0.10, 0.60,\r\n \"Hunger can cause anxiety\"),\r\n ConnectionTemplate(\"hunger\", \"curiosity\", 0.15, 0.10, 0.45,\r\n \"Hunger may drive food-seeking curiosity\"),\r\n \r\n # === HAPPINESS dynamics ===\r\n # Happiness is calming and promotes exploration\r\n ConnectionTemplate(\"happiness\", \"anxiety\", -0.30, 0.12, 0.80,\r\n \"Being happy reduces anxiety\"),\r\n ConnectionTemplate(\"happiness\", \"curiosity\", 0.25, 0.10, 0.65,\r\n \"Happy creatures are more curious\"),\r\n ConnectionTemplate(\"happiness\", \"satisfaction\", 0.20, 0.08, 0.55,\r\n \"Happiness contributes to satisfaction\"),\r\n \r\n # === CLEANLINESS dynamics ===\r\n # Being clean improves mood and reduces stress\r\n ConnectionTemplate(\"cleanliness\", \"happiness\", 0.25, 0.10, 0.75,\r\n \"Being clean improves mood\"),\r\n ConnectionTemplate(\"cleanliness\", \"anxiety\", -0.20, 0.08, 0.60,\r\n \"Cleanliness reduces stress\"),\r\n ConnectionTemplate(\"cleanliness\", \"satisfaction\", 0.15, 0.08, 0.50,\r\n \"Cleanliness contributes to overall satisfaction\"),\r\n \r\n # === SLEEPINESS dynamics ===\r\n # Tiredness affects cognition and mood negatively\r\n ConnectionTemplate(\"sleepiness\", \"curiosity\", -0.30, 0.12, 0.70,\r\n \"Tiredness suppresses curiosity\"),\r\n ConnectionTemplate(\"sleepiness\", \"happiness\", -0.20, 0.10, 0.65,\r\n \"Being tired affects mood\"),\r\n ConnectionTemplate(\"sleepiness\", \"anxiety\", 0.15, 0.08, 0.55,\r\n \"Sleep deprivation increases anxiety\"),\r\n ConnectionTemplate(\"sleepiness\", \"satisfaction\", -0.15, 0.08, 0.45,\r\n \"Tiredness reduces satisfaction\"),\r\n \r\n # === SATISFACTION dynamics ===\r\n # Satisfaction is calming and mood-boosting\r\n ConnectionTemplate(\"satisfaction\", \"happiness\", 0.35, 0.12, 0.85,\r\n \"Satisfaction promotes happiness\"),\r\n ConnectionTemplate(\"satisfaction\", \"anxiety\", -0.25, 0.10, 0.75,\r\n \"Being satisfied reduces anxiety\"),\r\n ConnectionTemplate(\"satisfaction\", \"curiosity\", 0.10, 0.08, 0.40,\r\n \"Satisfied creatures may explore more\"),\r\n \r\n # === ANXIETY dynamics ===\r\n # Anxiety suppresses positive states and exploration\r\n ConnectionTemplate(\"anxiety\", \"curiosity\", -0.35, 0.12, 0.80,\r\n \"Anxiety suppresses exploration\"),\r\n ConnectionTemplate(\"anxiety\", \"happiness\", -0.25, 0.10, 0.70,\r\n \"Anxiety reduces happiness\"),\r\n ConnectionTemplate(\"anxiety\", \"satisfaction\", -0.15, 0.08, 0.50,\r\n \"Anxiety reduces overall satisfaction\"),\r\n ConnectionTemplate(\"anxiety\", \"sleepiness\", 0.10, 0.08, 0.35,\r\n \"Anxiety can cause fatigue\"),\r\n \r\n # === CURIOSITY dynamics ===\r\n # Curiosity promotes positive mood and engagement\r\n ConnectionTemplate(\"curiosity\", \"happiness\", 0.20, 0.10, 0.60,\r\n \"Curiosity brings joy\"),\r\n ConnectionTemplate(\"curiosity\", \"satisfaction\", 0.15, 0.08, 0.45,\r\n \"Exploration satisfies\"),\r\n ConnectionTemplate(\"curiosity\", \"anxiety\", -0.10, 0.08, 0.35,\r\n \"Curiosity can reduce anxiety through engagement\"),\r\n \r\n # === CAN_SEE_FOOD dynamics (vision input) ===\r\n # Seeing food triggers hunger awareness and emotional responses\r\n ConnectionTemplate(\"can_see_food\", \"hunger\", 0.30, 0.12, 0.90,\r\n \"Seeing food activates hunger awareness\"),\r\n ConnectionTemplate(\"can_see_food\", \"happiness\", 0.25, 0.10, 0.75,\r\n \"Food sighting is exciting\"),\r\n ConnectionTemplate(\"can_see_food\", \"curiosity\", 0.20, 0.10, 0.65,\r\n \"Food triggers investigative behavior\"),\r\n ConnectionTemplate(\"can_see_food\", \"satisfaction\", 0.15, 0.08, 0.50,\r\n \"Food sight brings anticipatory satisfaction\"),\r\n ConnectionTemplate(\"can_see_food\", \"anxiety\", -0.10, 0.08, 0.40,\r\n \"Food sighting may reduce food-seeking anxiety\"),\r\n]\r\n\r\n\r\nclass SparseNetworkGenerator:\r\n \"\"\"\r\n Generates sparse neural networks with biologically-inspired connections.\r\n \"\"\"\r\n \r\n def __init__(self, seed: Optional[int] = None):\r\n \"\"\"\r\n Initialize generator with optional seed for reproducibility.\r\n \r\n Args:\r\n seed: Random seed. If None, uses system entropy.\r\n \"\"\"\r\n self.seed = seed\r\n self.rng = random.Random(seed)\r\n self.templates = CORE_CONNECTION_TEMPLATES.copy()\r\n \r\n def set_seed(self, seed: int):\r\n \"\"\"Set random seed for reproducible generation.\"\"\"\r\n self.seed = seed\r\n self.rng = random.Random(seed)\r\n \r\n def _generate_weight(self, template: ConnectionTemplate) -> float:\r\n \"\"\"Generate a noisy weight from a template.\"\"\"\r\n # Gaussian noise centered on base_weight\r\n noise = self.rng.gauss(0, template.weight_variance)\r\n weight = template.base_weight + noise\r\n \r\n # Clamp to valid range and round\r\n weight = max(-1.0, min(1.0, weight))\r\n return round(weight, 3)\r\n\r\n def perturb_positions(self, design, variance: float = 0.3,\r\n bounds: Tuple[float, float, float, float] = (-400, -150, 900, 750)):\r\n \"\"\"\r\n Randomly perturb neuron positions with organic variance.\r\n \r\n Args:\r\n design: BrainDesign to modify\r\n variance: Variance multiplier (0.3 = ±30% from original position)\r\n bounds: (min_x, min_y, max_x, max_y) to constrain neurons within view window\r\n \"\"\"\r\n if variance <= 0:\r\n return\r\n \r\n min_x, min_y, max_x, max_y = bounds\r\n rng = self.rng\r\n \r\n # Calculate center for organic spreading\r\n if not design.neurons:\r\n return\r\n \r\n for name, neuron in design.neurons.items():\r\n # Skip required/core neurons to keep the brain structure recognizable\r\n # but allow custom neurons (connectors, neurogenesis types) to move\r\n if neuron.is_required or neuron.is_core:\r\n continue\r\n \r\n # Ensure position is valid\r\n if neuron.position is None:\r\n continue\r\n \r\n x, y = neuron.position\r\n \r\n # Add Gaussian noise scaled by variance\r\n # Using a larger base scale (100px) so variance=0.2 moves things visibly (~20px)\r\n noise_scale = variance * 100 \r\n new_x = x + rng.gauss(0, noise_scale)\r\n new_y = y + rng.gauss(0, noise_scale)\r\n \r\n # Clamp to view bounds to keep them on canvas\r\n new_x = max(min_x, min(max_x, new_x))\r\n new_y = max(min_y, min(max_y, new_y))\r\n \r\n neuron.position = (new_x, new_y)\r\n\r\n def add_random_sensors(self, design, probability: float = 0.3):\r\n \"\"\"\r\n Randomly add input sensors to the design based on specific game rules.\r\n \r\n Rules:\r\n - 'can_see_food' is required (handled by design validation, but implicitly part of valid set)\r\n - 'plant_proximity': 20% chance\r\n - 'is_fleeing': 10% chance\r\n - No other sensors are generated.\r\n \r\n Args:\r\n design: BrainDesign to modify\r\n probability: Ignored. Probabilities are hardcoded per requirements.\r\n \r\n Returns:\r\n Number of sensors added\r\n \"\"\"\r\n # Specific probabilities requested\r\n sensor_rules = {\r\n 'plant_proximity': 0.20,\r\n 'is_fleeing': 0.10\r\n }\r\n \r\n added = 0\r\n for sensor_name, chance in sensor_rules.items():\r\n # Skip if already present\r\n if sensor_name in design.neurons:\r\n continue\r\n\r\n # Roll the dice\r\n if self.rng.random() < chance:\r\n # add_sensor handles both creation and sensible wiring via defaults\r\n success, _ = design.add_sensor(sensor_name, create_default_connections=True)\r\n if success:\r\n added += 1\r\n \r\n return added\r\n \r\n def _should_create_connection(self, template: ConnectionTemplate, \r\n density_multiplier: float = 1.0) -> bool:\r\n \"\"\"Decide if a connection should be created based on probability.\"\"\"\r\n adjusted_prob = min(1.0, template.probability * density_multiplier)\r\n return self.rng.random() < adjusted_prob\r\n \r\n def generate_connections(self, \r\n density: float = 1.0,\r\n include_feedback_loops: bool = True,\r\n weight_noise: float = 1.0\r\n ) -> List[Tuple[str, str, float]]:\r\n \"\"\"\r\n Generate sparse connections between core neurons.\r\n \r\n Args:\r\n density: Multiplier for connection probability (0.5 = sparser, 1.5 = denser)\r\n include_feedback_loops: If True, may add some bidirectional connections\r\n weight_noise: Multiplier for weight variance (0.5 = less noise, 2.0 = more noise)\r\n \r\n Returns:\r\n List of (source, target, weight) tuples\r\n \"\"\"\r\n connections = []\r\n created_pairs = set()\r\n \r\n # Process each template\r\n for template in self.templates:\r\n if not self._should_create_connection(template, density):\r\n continue\r\n \r\n # Generate noisy weight\r\n adjusted_template = ConnectionTemplate(\r\n template.source, template.target,\r\n template.base_weight,\r\n template.weight_variance * weight_noise,\r\n template.probability,\r\n template.description\r\n )\r\n weight = self._generate_weight(adjusted_template)\r\n \r\n # Skip very weak connections\r\n if abs(weight) < 0.02:\r\n continue\r\n \r\n connections.append((template.source, template.target, weight))\r\n created_pairs.add((template.source, template.target))\r\n \r\n # Optionally add feedback loops (reverse connections)\r\n if include_feedback_loops:\r\n feedback_candidates = [\r\n (\"satisfaction\", \"hunger\", -0.15, 0.4), # Being satisfied reduces hunger drive\r\n (\"happiness\", \"sleepiness\", -0.10, 0.3), # Being happy reduces tiredness\r\n (\"anxiety\", \"hunger\", 0.10, 0.25), # Stress eating?\r\n (\"curiosity\", \"anxiety\", 0.08, 0.2), # Exploration can be slightly stressful\r\n ]\r\n \r\n for source, target, base_w, prob in feedback_candidates:\r\n # Don't create if forward connection doesn't exist or reverse already exists\r\n if (target, source) not in created_pairs:\r\n continue\r\n if (source, target) in created_pairs:\r\n continue\r\n \r\n if self.rng.random() < prob * density:\r\n noise = self.rng.gauss(0, 0.05 * weight_noise)\r\n weight = round(max(-1.0, min(1.0, base_w + noise)), 3)\r\n if abs(weight) >= 0.02:\r\n connections.append((source, target, weight))\r\n created_pairs.add((source, target))\r\n \r\n # Shuffle to avoid predictable order\r\n self.rng.shuffle(connections)\r\n \r\n return connections\r\n \r\n def generate_for_design(self, design, \r\n clear_existing: bool = True,\r\n density: float = 1.0,\r\n include_feedback: bool = True,\r\n weight_noise: float = 1.0, # ADDED to match call sig\r\n position_variance: float = 0.0, # ADDED to fix Error\r\n sensor_probability: float = 0.0, # ADDED to match call sig\r\n bounds: Tuple[float, float, float, float] = (-400, -150, 900, 750),\r\n seed: Optional[int] = None,\r\n silent: bool = False) -> Tuple[int, List[str]]:\r\n \"\"\"\r\n Generate and apply sparse network to a BrainDesign.\r\n \r\n Args:\r\n design: BrainDesign instance to modify\r\n clear_existing: If True, removes existing connections first\r\n density: Connection density multiplier\r\n include_feedback: Include feedback loops\r\n weight_noise: Multiplier for random weight variance\r\n position_variance: If > 0, randomly moves neurons (perturbation)\r\n sensor_probability: Chance to add random input sensors\r\n bounds: (min_x, min_y, max_x, max_y) to constrain neurons within view window\r\n seed: Optional seed for reproducible generation.\r\n silent: If True, suppresses generation of action description strings\r\n \r\n Returns:\r\n Tuple of (connections_created, list of action descriptions)\r\n \"\"\"\r\n actions = []\r\n \r\n # Apply seed if provided\r\n if seed is not None:\r\n self.set_seed(seed)\r\n if not silent:\r\n actions.append(f\"Using seed: {seed}\")\r\n \r\n # Ensure required neurons exist\r\n missing = design.get_missing_required_neurons()\r\n if missing:\r\n design.add_missing_required_neurons()\r\n if not silent:\r\n actions.append(f\"Added missing required neurons: {', '.join(missing)}\")\r\n \r\n # 1. Handle Random Sensors (if requested)\r\n if sensor_probability > 0:\r\n added_sensors = self.add_random_sensors(design, sensor_probability)\r\n if added_sensors > 0 and not silent:\r\n actions.append(f\"Added {added_sensors} random input sensors\")\r\n\r\n # 2. Handle Position Perturbation (if requested)\r\n if position_variance > 0:\r\n self.perturb_positions(design, variance=position_variance, bounds=bounds)\r\n if not silent:\r\n actions.append(f\"Perturbed neuron positions (variance: {position_variance})\")\r\n\r\n # 3. Clear existing connections (if requested)\r\n if clear_existing:\r\n old_count = len(design.connections)\r\n design.connections.clear()\r\n if old_count > 0 and not silent:\r\n actions.append(f\"Cleared {old_count} existing connections\")\r\n \r\n # 4. Generate new connections\r\n connections = self.generate_connections(\r\n density=density,\r\n include_feedback_loops=include_feedback,\r\n weight_noise=weight_noise\r\n )\r\n \r\n # Apply to design\r\n created = 0\r\n for source, target, weight in connections:\r\n # Verify both neurons exist in design\r\n if source not in design.neurons or target not in design.neurons:\r\n continue\r\n \r\n if design.add_connection(source, target, weight):\r\n created += 1\r\n if not silent:\r\n sign = \"+\" if weight > 0 else \"\"\r\n actions.append(f\" {source} → {target} ({sign}{weight:.3f})\")\r\n \r\n return created, actions\r\n \r\n def get_preset_styles(self) -> Dict[str, Dict]:\r\n \"\"\"Return preset generation styles with new variance and sensor options.\"\"\"\r\n return {\r\n 'balanced': {\r\n 'name': '⚖️ Balanced',\r\n 'description': 'Standard density, moderate noise, slight position variance',\r\n 'density': 1.0,\r\n 'include_feedback': True,\r\n 'weight_noise': 1.0,\r\n 'position_variance': 0.2,\r\n 'sensor_probability': 0.15\r\n },\r\n 'sparse': {\r\n 'name': '🔬 Minimal',\r\n 'description': 'Fewer connections, minimal position variance',\r\n 'density': 0.5,\r\n 'include_feedback': False,\r\n 'weight_noise': 0.7,\r\n 'position_variance': 0.1,\r\n 'sensor_probability': 0.0\r\n },\r\n 'dense': {\r\n 'name': '🕸️ Dense',\r\n 'description': 'More connections, rich dynamics, moderate sensors',\r\n 'density': 1.4,\r\n 'include_feedback': True,\r\n 'weight_noise': 1.2,\r\n 'position_variance': 0.3,\r\n 'sensor_probability': 0.3\r\n },\r\n 'chaotic': {\r\n 'name': '🌀 Chaotic',\r\n 'description': 'High noise, unpredictable, high position variance',\r\n 'density': 1.1,\r\n 'include_feedback': True,\r\n 'weight_noise': 2.5,\r\n 'position_variance': 0.5,\r\n 'sensor_probability': 0.4\r\n },\r\n 'calm': {\r\n 'name': '🧘 Calm',\r\n 'description': 'Weaker connections, stable, low variance',\r\n 'density': 0.8,\r\n 'include_feedback': True,\r\n 'weight_noise': 0.5,\r\n 'position_variance': 0.1,\r\n 'sensor_probability': 0.0\r\n },\r\n 'wild': {\r\n 'name': '🌿 Wild',\r\n 'description': 'Organic positions, many sensors, natural feel',\r\n 'density': 1.2,\r\n 'include_feedback': True,\r\n 'weight_noise': 1.5,\r\n 'position_variance': 0.4,\r\n 'sensor_probability': 0.5\r\n }\r\n }\r\n\r\n\r\n# ============================================================================\r\n# UTILITY FUNCTIONS\r\n# ============================================================================\r\n\r\ndef generate_sparse_core_network(density: float = 1.0, \r\n seed: Optional[int] = None) -> List[Tuple[str, str, float]]:\r\n \"\"\"\r\n Convenience function to generate sparse network connections.\r\n \"\"\"\r\n generator = SparseNetworkGenerator(seed)\r\n return generator.generate_connections(density=density)\r\n\r\n\r\ndef describe_connection(source: str, target: str, weight: float) -> str:\r\n \"\"\"Generate a human-readable description of a connection.\"\"\"\r\n effect = \"excites\" if weight > 0 else \"inhibits\"\r\n strength = abs(weight)\r\n \r\n if strength < 0.15:\r\n strength_word = \"weakly\"\r\n elif strength < 0.35:\r\n strength_word = \"moderately\"\r\n elif strength < 0.6:\r\n strength_word = \"strongly\"\r\n else:\r\n strength_word = \"powerfully\"\r\n \r\n return f\"{source} {strength_word} {effect} {target}\"\r\n"
},
{
"path": "src/designer_outputs_panel.py",
"content": "# designer_outputs_panel.py\r\n\"\"\"\r\nBrain Designer panel for configuring neuron output bindings.\r\n\r\nThis panel allows users to:\r\n1. Bind neurons to output hooks (actuators)\r\n2. Configure trigger thresholds and modes\r\n3. Manage cooldowns and parameters (including colour selection)\r\n\r\nWhen the squid runs this brain, neurons that exceed their threshold\r\nwill trigger the bound behaviors (flee, seek food, ink, etc.)\r\n\"\"\"\r\n\r\nfrom PyQt5.QtWidgets import (\r\n QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QFormLayout,\r\n QPushButton, QLabel, QComboBox, QDoubleSpinBox, QCheckBox,\r\n QTableWidget, QTableWidgetItem, QHeaderView, QDialog,\r\n QDialogButtonBox, QScrollArea, QFrame, QMessageBox, QSpinBox,\r\n QColorDialog\r\n)\r\nfrom PyQt5.QtCore import Qt, pyqtSignal\r\nfrom PyQt5.QtGui import QColor\r\n\r\ntry:\r\n from .brain_neuron_outputs import (\r\n NeuronOutputBinding, OutputTriggerMode,\r\n STANDARD_OUTPUT_HOOKS, get_output_hooks_by_category\r\n )\r\nexcept ImportError:\r\n from brain_neuron_outputs import (\r\n NeuronOutputBinding, OutputTriggerMode,\r\n STANDARD_OUTPUT_HOOKS, get_output_hooks_by_category\r\n )\r\n\r\n\r\nclass OutputBindingDialog(QDialog):\r\n \"\"\"Dialog for creating or editing a neuron output binding.\"\"\"\r\n \r\n def __init__(self, design, existing_binding=None, parent=None):\r\n super().__init__(parent)\r\n self.design = design\r\n self.existing_binding = existing_binding\r\n self.result_binding = None\r\n \r\n # Store dynamic parameters here\r\n self.current_params = {}\r\n if existing_binding and existing_binding.hook_params:\r\n self.current_params = existing_binding.hook_params.copy()\r\n \r\n self.setWindowTitle(\"Configure Output Binding\" if existing_binding else \"Add Output Binding\")\r\n self.setMinimumWidth(450)\r\n self.setup_ui()\r\n \r\n if existing_binding:\r\n self._populate_from_binding(existing_binding)\r\n \r\n def setup_ui(self):\r\n layout = QVBoxLayout(self)\r\n \r\n # 1. Selection Group\r\n type_group = QGroupBox(\"Select Neuron Type\")\r\n type_layout = QFormLayout(type_group)\r\n \r\n self.neuron_combo = QComboBox()\r\n self._populate_neurons()\r\n type_layout.addRow(\"Neuron:\", self.neuron_combo)\r\n \r\n # Show current activation hint\r\n self.activation_label = QLabel(\"Current: --\")\r\n self.activation_label.setStyleSheet(\"color: #888;\")\r\n type_layout.addRow(\"\", self.activation_label)\r\n \r\n layout.addWidget(type_group)\r\n \r\n # 2. Output hook selection\r\n hook_group = QGroupBox(\"Output Behavior\")\r\n hook_layout = QFormLayout(hook_group)\r\n \r\n self.hook_combo = QComboBox()\r\n self._populate_hooks()\r\n self.hook_combo.currentTextChanged.connect(self._on_hook_changed)\r\n hook_layout.addRow(\"Trigger:\", self.hook_combo)\r\n \r\n self.hook_description = QLabel(\"\")\r\n self.hook_description.setWordWrap(True)\r\n self.hook_description.setStyleSheet(\"color: #666; font-style: italic;\")\r\n hook_layout.addRow(\"\", self.hook_description)\r\n \r\n layout.addWidget(hook_group)\r\n\r\n # === Dynamic Parameters Area ===\r\n self.params_group = QGroupBox(\"Behavior Parameters\")\r\n self.params_layout = QVBoxLayout(self.params_group)\r\n \r\n # Color Picker UI (Hidden by default)\r\n self.color_widget = QWidget()\r\n color_layout = QHBoxLayout(self.color_widget)\r\n color_layout.setContentsMargins(0,0,0,0)\r\n \r\n self.color_preview = QLabel()\r\n self.color_preview.setFixedSize(30, 30)\r\n self.color_preview.setStyleSheet(\"background-color: #CCCCCC; border: 1px solid #888;\")\r\n \r\n self.pick_color_btn = QPushButton(\"Pick Colour...\")\r\n self.pick_color_btn.clicked.connect(self._pick_color)\r\n \r\n self.reset_color_btn = QPushButton(\"Reset (Random)\")\r\n self.reset_color_btn.clicked.connect(self._reset_color)\r\n \r\n color_layout.addWidget(QLabel(\"Tint Colour:\"))\r\n color_layout.addWidget(self.color_preview)\r\n color_layout.addWidget(self.pick_color_btn)\r\n color_layout.addWidget(self.reset_color_btn)\r\n color_layout.addStretch()\r\n \r\n self.params_layout.addWidget(self.color_widget)\r\n self.color_widget.hide() # Hide initially\r\n \r\n layout.addWidget(self.params_group)\r\n self.params_group.hide() # Hide group initially\r\n \r\n # Trigger configuration\r\n trigger_group = QGroupBox(\"Trigger Settings\")\r\n trigger_layout = QFormLayout(trigger_group)\r\n \r\n # Threshold\r\n self.threshold_spin = QDoubleSpinBox()\r\n self.threshold_spin.setRange(0, 100)\r\n self.threshold_spin.setValue(70)\r\n self.threshold_spin.setSuffix(\" %\")\r\n self.threshold_spin.setToolTip(\"Activation level required to trigger the output\")\r\n trigger_layout.addRow(\"Threshold:\", self.threshold_spin)\r\n \r\n # Trigger mode\r\n self.mode_combo = QComboBox()\r\n self.mode_combo.addItem(\"Rising Edge (cross threshold going up)\", OutputTriggerMode.THRESHOLD_RISING.value)\r\n self.mode_combo.addItem(\"Falling Edge (cross threshold going down)\", OutputTriggerMode.THRESHOLD_FALLING.value)\r\n self.mode_combo.addItem(\"While Above (continuous while > threshold)\", OutputTriggerMode.THRESHOLD_ABOVE.value)\r\n self.mode_combo.addItem(\"While Below (continuous while < threshold)\", OutputTriggerMode.THRESHOLD_BELOW.value)\r\n self.mode_combo.addItem(\"On Change (any significant change)\", OutputTriggerMode.ON_CHANGE.value)\r\n trigger_layout.addRow(\"Mode:\", self.mode_combo)\r\n \r\n # Cooldown\r\n self.cooldown_spin = QDoubleSpinBox()\r\n self.cooldown_spin.setRange(0.1, 60)\r\n self.cooldown_spin.setValue(1.0)\r\n self.cooldown_spin.setSuffix(\" sec\")\r\n self.cooldown_spin.setToolTip(\"Minimum time between triggers\")\r\n trigger_layout.addRow(\"Cooldown:\", self.cooldown_spin)\r\n \r\n # Enabled\r\n self.enabled_check = QCheckBox(\"Enabled\")\r\n self.enabled_check.setChecked(True)\r\n trigger_layout.addRow(\"\", self.enabled_check)\r\n \r\n layout.addWidget(trigger_group)\r\n \r\n # Buttons\r\n buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)\r\n buttons.accepted.connect(self.accept)\r\n buttons.rejected.connect(self.reject)\r\n layout.addWidget(buttons)\r\n \r\n # Initialize hook description\r\n self._on_hook_changed()\r\n \r\n def _populate_neurons(self):\r\n \"\"\"Populate neuron combo with available neurons.\"\"\"\r\n self.neuron_combo.clear()\r\n \r\n # Get all non-core neurons (outputs typically come from processing neurons)\r\n for name, neuron in sorted(self.design.neurons.items()):\r\n if not neuron.is_core:\r\n display = name\r\n \r\n # Add icons for special types\r\n if neuron.is_sensor:\r\n display = f\"📡 {name}\"\r\n elif name.startswith('connector_'):\r\n display = f\"🔗 {name}\"\r\n elif name.startswith('novelty_'):\r\n display = f\"✨ {name}\"\r\n elif name.startswith('stress_'):\r\n display = f\"🔥 {name}\"\r\n elif name.startswith('reward_'):\r\n display = f\"💎 {name}\"\r\n \r\n self.neuron_combo.addItem(display, name)\r\n \r\n # Also add core neurons (they might want anxiety to trigger flee, etc.)\r\n self.neuron_combo.insertSeparator(self.neuron_combo.count())\r\n for name, neuron in sorted(self.design.neurons.items()):\r\n if neuron.is_core:\r\n self.neuron_combo.addItem(f\"⚡ {name}\", name)\r\n \r\n def _populate_hooks(self):\r\n \"\"\"Populate hook combo with available output hooks.\"\"\"\r\n self.hook_combo.clear()\r\n \r\n by_category = get_output_hooks_by_category()\r\n \r\n for category in sorted(by_category.keys()):\r\n hooks = by_category[category]\r\n \r\n # Add category header\r\n self.hook_combo.addItem(f\"── {category.title()} ──\", None)\r\n \r\n # Make header non-selectable\r\n idx = self.hook_combo.count() - 1\r\n self.hook_combo.model().item(idx).setEnabled(False)\r\n \r\n for hook_name, info in sorted(hooks.items()):\r\n display_name = hook_name.replace('neuron_output_', '').replace('_', ' ').title()\r\n self.hook_combo.addItem(f\" {display_name}\", hook_name)\r\n \r\n def _on_hook_changed(self):\r\n \"\"\"Update description and param UI when hook selection changes.\"\"\"\r\n hook_name = self.hook_combo.currentData()\r\n self._update_param_ui(hook_name)\r\n\r\n if hook_name and hook_name in STANDARD_OUTPUT_HOOKS:\r\n info = STANDARD_OUTPUT_HOOKS[hook_name]\r\n self.hook_description.setText(info.get('description', ''))\r\n \r\n # Update default threshold\r\n default_thresh = info.get('default_threshold', 70)\r\n if not self.existing_binding: # Only auto-set for new bindings\r\n self.threshold_spin.setValue(default_thresh)\r\n else:\r\n self.hook_description.setText(\"\")\r\n \r\n def _update_param_ui(self, hook_name):\r\n \"\"\"Show specific UI elements based on the selected hook.\"\"\"\r\n self.params_group.hide()\r\n self.color_widget.hide()\r\n \r\n if hook_name == 'neuron_output_change_color':\r\n self.params_group.show()\r\n self.color_widget.show()\r\n self._update_color_preview()\r\n\r\n def _update_color_preview(self):\r\n \"\"\"Update the color preview box based on current params.\"\"\"\r\n if 'red' in self.current_params:\r\n r = self.current_params.get('red', 255)\r\n g = self.current_params.get('green', 255)\r\n b = self.current_params.get('blue', 255)\r\n self.color_preview.setStyleSheet(f\"background-color: rgb({r},{g},{b}); border: 1px solid #000;\")\r\n self.color_preview.setText(\"\")\r\n else:\r\n self.color_preview.setStyleSheet(\"background-color: #EEE; border: 1px dashed #888;\")\r\n self.color_preview.setText(\"?\")\r\n\r\n def _pick_color(self):\r\n \"\"\"Open color picker dialog.\"\"\"\r\n initial = QColor(255, 255, 255)\r\n if 'red' in self.current_params:\r\n initial = QColor(\r\n self.current_params['red'], \r\n self.current_params['green'], \r\n self.current_params['blue']\r\n )\r\n \r\n color = QColorDialog.getColor(initial, self, \"Select Output Tint\")\r\n \r\n if color.isValid():\r\n self.current_params['red'] = color.red()\r\n self.current_params['green'] = color.green()\r\n self.current_params['blue'] = color.blue()\r\n self._update_color_preview()\r\n\r\n def _reset_color(self):\r\n \"\"\"Clear color params to revert to random.\"\"\"\r\n self.current_params.pop('red', None)\r\n self.current_params.pop('green', None)\r\n self.current_params.pop('blue', None)\r\n self._update_color_preview()\r\n\r\n def _populate_from_binding(self, binding: NeuronOutputBinding):\r\n \"\"\"Fill dialog fields from existing binding.\"\"\"\r\n # Find and select neuron\r\n for i in range(self.neuron_combo.count()):\r\n if self.neuron_combo.itemData(i) == binding.neuron_name:\r\n self.neuron_combo.setCurrentIndex(i)\r\n break\r\n \r\n # Find and select hook\r\n for i in range(self.hook_combo.count()):\r\n if self.hook_combo.itemData(i) == binding.output_hook:\r\n self.hook_combo.setCurrentIndex(i)\r\n break\r\n \r\n self.threshold_spin.setValue(binding.threshold)\r\n self.cooldown_spin.setValue(binding.cooldown)\r\n self.enabled_check.setChecked(binding.enabled)\r\n \r\n # Find and select mode\r\n for i in range(self.mode_combo.count()):\r\n if self.mode_combo.itemData(i) == binding.trigger_mode.value:\r\n self.mode_combo.setCurrentIndex(i)\r\n break\r\n \r\n # Load params\r\n self.current_params = binding.hook_params.copy() if binding.hook_params else {}\r\n self._on_hook_changed()\r\n\r\n def accept(self):\r\n \"\"\"Validate and create binding.\"\"\"\r\n neuron_name = self.neuron_combo.currentData()\r\n hook_name = self.hook_combo.currentData()\r\n \r\n if not neuron_name:\r\n QMessageBox.warning(self, \"Error\", \"Please select a neuron\")\r\n return\r\n \r\n if not hook_name:\r\n QMessageBox.warning(self, \"Error\", \"Please select an output behavior\")\r\n return\r\n \r\n mode_value = self.mode_combo.currentData()\r\n trigger_mode = OutputTriggerMode(mode_value)\r\n \r\n self.result_binding = NeuronOutputBinding(\r\n neuron_name=neuron_name,\r\n output_hook=hook_name,\r\n threshold=self.threshold_spin.value(),\r\n trigger_mode=trigger_mode,\r\n cooldown=self.cooldown_spin.value(),\r\n enabled=self.enabled_check.isChecked(),\r\n hook_params=self.current_params # Save collected params\r\n )\r\n \r\n super().accept()\r\n\r\n\r\nclass NeuronOutputsPanel(QWidget):\r\n \"\"\"\r\n Panel for managing neuron output bindings in the brain designer.\r\n \r\n Shows a table of all output bindings and allows adding/editing/removing them.\r\n \"\"\"\r\n \r\n outputsChanged = pyqtSignal()\r\n \r\n def __init__(self, design, parent=None):\r\n super().__init__(parent)\r\n self.design = design\r\n \r\n # Store bindings locally (will be exported with brain)\r\n self.bindings: list = []\r\n \r\n self.setup_ui()\r\n \r\n def setup_ui(self):\r\n layout = QVBoxLayout(self)\r\n \r\n # Header with description\r\n header = QLabel(\r\n \"Output Bindings \"\r\n \"Connect neurons to squid behaviors. When a neuron's activation \"\r\n \"exceeds the threshold, it triggers the bound action.\"\r\n )\r\n header.setWordWrap(True)\r\n layout.addWidget(header)\r\n \r\n # Toolbar\r\n toolbar = QHBoxLayout()\r\n \r\n add_btn = QPushButton(\"➕ Add Binding\")\r\n add_btn.clicked.connect(self.add_binding)\r\n toolbar.addWidget(add_btn)\r\n \r\n edit_btn = QPushButton(\"✏️ Edit\")\r\n edit_btn.clicked.connect(self.edit_binding)\r\n toolbar.addWidget(edit_btn)\r\n \r\n remove_btn = QPushButton(\"🗑️ Remove\")\r\n remove_btn.clicked.connect(self.remove_binding)\r\n toolbar.addWidget(remove_btn)\r\n \r\n toolbar.addStretch()\r\n layout.addLayout(toolbar)\r\n \r\n # Bindings table\r\n self.table = QTableWidget()\r\n self.table.setColumnCount(5)\r\n self.table.setHorizontalHeaderLabels([\r\n \"Neuron\", \"→ Behavior\", \"Threshold\", \"Mode\", \"Enabled\"\r\n ])\r\n \r\n # [CHANGED] Enable interactive column resizing and set default widths\r\n self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)\r\n self.table.setColumnWidth(0, 150) # Neuron\r\n self.table.setColumnWidth(1, 200) # Behavior (wider to show color)\r\n self.table.setColumnWidth(2, 100) # Threshold\r\n self.table.setColumnWidth(3, 150) # Mode\r\n self.table.setColumnWidth(4, 80) # Enabled\r\n \r\n self.table.setSelectionBehavior(QTableWidget.SelectRows)\r\n self.table.setSelectionMode(QTableWidget.SingleSelection)\r\n self.table.doubleClicked.connect(self.edit_binding)\r\n layout.addWidget(self.table)\r\n \r\n # Quick info\r\n self.info_label = QLabel(\"\")\r\n self.info_label.setStyleSheet(\"color: #888;\")\r\n layout.addWidget(self.info_label)\r\n \r\n self.refresh()\r\n \r\n def refresh(self):\r\n \"\"\"Refresh the bindings table.\"\"\"\r\n self.table.setRowCount(len(self.bindings))\r\n \r\n for row, binding in enumerate(self.bindings):\r\n # Neuron name\r\n neuron_item = QTableWidgetItem(binding.neuron_name)\r\n if binding.neuron_name not in self.design.neurons:\r\n neuron_item.setForeground(QColor(255, 100, 100)) # Red if missing\r\n neuron_item.setToolTip(\"⚠️ Neuron not found in design\")\r\n self.table.setItem(row, 0, neuron_item)\r\n \r\n # Output hook (formatted nicely)\r\n hook_display = binding.output_hook.replace('neuron_output_', '').replace('_', ' ').title()\r\n \r\n # [CHANGED] For color bindings, show color as cell background instead of RGB text\r\n hook_item = QTableWidgetItem(hook_display)\r\n if binding.output_hook in STANDARD_OUTPUT_HOOKS:\r\n hook_item.setToolTip(STANDARD_OUTPUT_HOOKS[binding.output_hook].get('description', ''))\r\n \r\n # If this is a color binding, set the background color\r\n if binding.hook_params and 'red' in binding.hook_params:\r\n r = binding.hook_params.get('red', 255)\r\n g = binding.hook_params.get('green', 255)\r\n b = binding.hook_params.get('blue', 255)\r\n color = QColor(r, g, b)\r\n hook_item.setBackground(color)\r\n \r\n # Adjust text color for contrast\r\n brightness = (r * 299 + g * 587 + b * 114) / 1000\r\n if brightness < 128:\r\n hook_item.setForeground(QColor(255, 255, 255))\r\n else:\r\n hook_item.setForeground(QColor(0, 0, 0))\r\n \r\n self.table.setItem(row, 1, hook_item)\r\n \r\n # Threshold\r\n thresh_item = QTableWidgetItem(f\"{binding.threshold:.0f}%\")\r\n self.table.setItem(row, 2, thresh_item)\r\n \r\n # Mode\r\n mode_display = binding.trigger_mode.value.replace('_', ' ').title()\r\n mode_item = QTableWidgetItem(mode_display)\r\n self.table.setItem(row, 3, mode_item)\r\n \r\n # Enabled\r\n enabled_item = QTableWidgetItem(\"✓\" if binding.enabled else \"✗\")\r\n enabled_item.setTextAlignment(Qt.AlignCenter)\r\n if not binding.enabled:\r\n enabled_item.setForeground(QColor(150, 150, 150))\r\n self.table.setItem(row, 4, enabled_item)\r\n \r\n # Update info\r\n enabled_count = sum(1 for b in self.bindings if b.enabled)\r\n self.info_label.setText(f\"{len(self.bindings)} binding(s), {enabled_count} enabled\")\r\n \r\n def add_binding(self):\r\n \"\"\"Show dialog to add a new binding.\"\"\"\r\n dialog = OutputBindingDialog(self.design, parent=self)\r\n if dialog.exec_() == QDialog.Accepted and dialog.result_binding:\r\n # Duplicate check REMOVED to allow multiple bindings for same neuron/hook\r\n # (e.g. one for Rising threshold, one for Falling)\r\n \r\n self.bindings.append(dialog.result_binding)\r\n self.refresh()\r\n self.outputsChanged.emit()\r\n \r\n def edit_binding(self):\r\n \"\"\"Edit the selected binding.\"\"\"\r\n row = self.table.currentRow()\r\n if row < 0 or row >= len(self.bindings):\r\n return\r\n \r\n binding = self.bindings[row]\r\n dialog = OutputBindingDialog(self.design, existing_binding=binding, parent=self)\r\n \r\n if dialog.exec_() == QDialog.Accepted and dialog.result_binding:\r\n self.bindings[row] = dialog.result_binding\r\n self.refresh()\r\n self.outputsChanged.emit()\r\n \r\n def remove_binding(self):\r\n \"\"\"Remove the selected binding.\"\"\"\r\n row = self.table.currentRow()\r\n if row < 0 or row >= len(self.bindings):\r\n return\r\n \r\n binding = self.bindings[row]\r\n reply = QMessageBox.question(\r\n self, \"Remove Binding\",\r\n f\"Remove binding: {binding.neuron_name} → {binding.output_hook}?\",\r\n QMessageBox.Yes | QMessageBox.No\r\n )\r\n \r\n if reply == QMessageBox.Yes:\r\n self.bindings.pop(row)\r\n self.refresh()\r\n self.outputsChanged.emit()\r\n \r\n def load_bindings(self, bindings_data: list):\r\n \"\"\"Load bindings from saved data.\"\"\"\r\n self.bindings.clear()\r\n for data in bindings_data:\r\n try:\r\n binding = NeuronOutputBinding.from_dict(data)\r\n self.bindings.append(binding)\r\n except Exception as e:\r\n print(f\"[OutputsPanel] Error loading binding: {e}\")\r\n self.refresh()\r\n \r\n def export_bindings(self) -> list:\r\n \"\"\"Export bindings for saving.\"\"\"\r\n return [b.to_dict() for b in self.bindings]\r\n \r\n def validate_bindings(self) -> list:\r\n \"\"\"\r\n Validate bindings against current design.\r\n \r\n Returns list of warning messages.\r\n \"\"\"\r\n warnings = []\r\n for binding in self.bindings:\r\n if binding.neuron_name not in self.design.neurons:\r\n warnings.append(f\"Binding references missing neuron: {binding.neuron_name}\")\r\n return warnings"
},
{
"path": "src/designer_panels.py",
"content": "from PyQt5.QtWidgets import (\n QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QFormLayout, QListWidget, QListWidgetItem, \n QPushButton, QLabel, QLineEdit, QDoubleSpinBox, QCheckBox, QComboBox, QTextEdit, \n QTableWidget, QTableWidgetItem, QHeaderView, QScrollArea, QDialog, QMessageBox, QInputDialog\n)\nfrom PyQt5.QtCore import Qt, pyqtSignal\nfrom typing import Optional, Dict\n\nfrom .designer_core import BrainDesign, DesignerNeuron, DesignerLayer\nfrom .designer_constants import (\n NeuronType, INPUT_SENSORS, REQUIRED_NEURONS, DEFAULT_SENSOR_CONNECTIONS,\n is_required_neuron, is_input_sensor\n)\n\n# Optional: Import sensor discovery for plugin sensors\ntry:\n from .designer_sensor_discovery import get_all_available_sensors, is_plugin_sensor\n _HAS_SENSOR_DISCOVERY = True\nexcept ImportError:\n _HAS_SENSOR_DISCOVERY = False\n def get_all_available_sensors():\n # Wrap raw (x,y) tuples from INPUT_SENSORS into proper info dicts\n return {\n name: {'description': name.replace('_', ' ').title(),\n 'is_binary': False, 'category': 'Built-in', 'plugin': None,\n 'default_connections': []}\n for name in INPUT_SENSORS\n }\n def is_plugin_sensor(name):\n return False\n\nclass AddNeuronDialog(QDialog):\n def __init__(self, design: BrainDesign, position=None, parent=None):\n super().__init__(parent)\n self.design = design\n self.position = position or (400, 200)\n self.result_neuron = None\n self.result_message = \"\"\n self.setWindowTitle(\"Add Neuron\")\n self.setMinimumWidth(400)\n self.setup_ui()\n \n def setup_ui(self):\n layout = QVBoxLayout(self)\n \n # 1. Selection Group\n type_group = QGroupBox(\"Select Neuron Type\")\n type_layout = QVBoxLayout(type_group)\n \n # Custom Neuron Button (The \"Magic\" one)\n custom_btn = QPushButton(\"✨ Custom / Plugin Neuron\")\n custom_btn.setToolTip(\"Create a neuron with a specific name to link with game plugins\")\n custom_btn.clicked.connect(lambda: self.select_type('custom'))\n type_layout.addWidget(custom_btn)\n \n # Sensor Button\n sensor_btn = QPushButton(\"📡 Input Sensor\")\n sensor_btn.clicked.connect(lambda: self.select_type('sensor'))\n type_layout.addWidget(sensor_btn)\n \n layout.addWidget(type_group)\n \n # 2. Sensor Selection Group (Hidden by default)\n self.sensor_group = QGroupBox(\"Select Sensor\")\n sensor_layout = QVBoxLayout(self.sensor_group)\n self.sensor_list = QListWidget()\n self.sensor_list.itemDoubleClicked.connect(self.accept_sensor)\n sensor_layout.addWidget(self.sensor_list)\n layout.addWidget(self.sensor_group)\n self.sensor_group.hide()\n \n # 3. Custom Neuron Entry Group (Hidden by default)\n self.custom_group = QGroupBox(\"Define Custom Neuron\")\n custom_layout = QFormLayout(self.custom_group)\n \n # Magic Link Instruction\n info_label = QLabel(\n \"To affect the squid, the Name must match a plugin ID. \"\n \"Example: Name it 'jet_boost' to activate a jetpack plugin.\"\n )\n info_label.setWordWrap(True)\n info_label.setStyleSheet(\"color: #666; margin-bottom: 5px;\")\n custom_layout.addRow(info_label)\n \n self.name_edit = QLineEdit()\n self.name_edit.setPlaceholderText(\"e.g. turbo_mode\")\n custom_layout.addRow(\"Plugin ID / Name:\", self.name_edit)\n \n add_custom_btn = QPushButton(\"Create Link\")\n add_custom_btn.setStyleSheet(\"font-weight: bold; background-color: #E0F7FA; color: #006064;\")\n add_custom_btn.clicked.connect(self.accept_custom)\n custom_layout.addRow(add_custom_btn)\n \n layout.addWidget(self.custom_group)\n self.custom_group.hide()\n \n def select_type(self, t):\n if t == 'sensor':\n self.sensor_group.show()\n self.custom_group.hide()\n self.populate_sensor_list()\n else:\n self.custom_group.show()\n self.sensor_group.hide()\n self.name_edit.setFocus()\n\n def populate_sensor_list(self):\n self.sensor_list.clear()\n existing = set(self.design.neurons.keys())\n \n # Get all available sensors (built-in + plugin)\n all_sensors = get_all_available_sensors()\n \n # Also ensure can_see_food is included\n if 'can_see_food' not in all_sensors and 'can_see_food' in REQUIRED_NEURONS:\n all_sensors['can_see_food'] = {\n 'description': REQUIRED_NEURONS['can_see_food'].get('description', ''),\n 'is_binary': True,\n 'plugin': None\n }\n \n # Filter to available sensors\n available = {k: v for k, v in all_sensors.items() if k not in existing}\n \n if not available:\n self.sensor_list.addItem(\"All sensors added\")\n return\n\n for name in sorted(available.keys()):\n info = available[name]\n display_name = name.replace('_', ' ').title()\n \n # Add plugin indicator\n if info.get('plugin'):\n display_name = f\"🔌 {display_name}\"\n \n item = QListWidgetItem(display_name)\n item.setData(Qt.UserRole, name)\n \n # Add tooltip\n tooltip = info.get('description', '')\n if info.get('plugin'):\n tooltip += f\"\\n[Plugin: {info['plugin']}]\"\n if tooltip:\n item.setToolTip(tooltip.strip())\n \n self.sensor_list.addItem(item)\n\n def accept_sensor(self):\n items = self.sensor_list.selectedItems()\n if not items: return\n name = items[0].data(Qt.UserRole)\n if not name: return \n \n success, msg = self.design.add_sensor(name)\n if success:\n self.result_message = msg\n self.accept()\n else: QMessageBox.warning(self, \"Error\", msg)\n\n def accept_custom(self):\n name = self.name_edit.text().strip().lower().replace(' ', '_')\n if not name: return\n if name in self.design.neurons:\n QMessageBox.warning(self, \"Error\", \"Exists\")\n return\n self.design.add_neuron(DesignerNeuron(name=name, neuron_type=NeuronType.HIDDEN, position=self.position))\n self.result_message = f\"Created {name}\"\n self.accept()\n\nclass NeuronPropertiesPanel(QWidget):\n neuronChanged = pyqtSignal(str)\n def __init__(self, design: BrainDesign, parent=None):\n super().__init__(parent)\n self.design = design\n self.current_neuron = None\n self.setup_ui()\n \n def setup_ui(self):\n layout = QVBoxLayout(self)\n self.header_label = QLabel(\"No neuron selected\")\n layout.addWidget(self.header_label)\n \n form = QFormLayout()\n self.name_edit = QLineEdit()\n self.name_edit.editingFinished.connect(self.on_name_changed)\n form.addRow(\"Name:\", self.name_edit)\n \n self.type_combo = QComboBox()\n # [UPDATED] Added CONNECTOR to valid types\n self.type_combo.addItems([\"CORE\", \"SENSOR\", \"INPUT\", \"OUTPUT\", \"HIDDEN\", \"CONNECTOR\"])\n self.type_combo.currentTextChanged.connect(self.on_type_changed)\n form.addRow(\"Type:\", self.type_combo)\n \n self.x_spin = QDoubleSpinBox()\n self.x_spin.setRange(-1000, 2000)\n self.x_spin.valueChanged.connect(self.on_pos_changed)\n form.addRow(\"X:\", self.x_spin)\n self.y_spin = QDoubleSpinBox()\n self.y_spin.setRange(-500, 1000)\n self.y_spin.valueChanged.connect(self.on_pos_changed)\n form.addRow(\"Y:\", self.y_spin)\n layout.addLayout(form)\n \n self.delete_btn = QPushButton(\"Delete Neuron\")\n self.delete_btn.clicked.connect(self.on_delete)\n layout.addWidget(self.delete_btn)\n layout.addStretch()\n self.setEnabled(False)\n\n def set_neuron(self, name):\n self.current_neuron = name\n if not name:\n self.setEnabled(False)\n self.header_label.setText(\"No Selection\")\n return\n \n self.setEnabled(True)\n neuron = self.design.get_neuron(name)\n self.header_label.setText(name)\n \n self.name_edit.blockSignals(True)\n self.type_combo.blockSignals(True)\n self.x_spin.blockSignals(True)\n self.y_spin.blockSignals(True)\n \n self.name_edit.setText(name)\n self.name_edit.setEnabled(not neuron.is_protected)\n self.type_combo.setCurrentText(neuron.neuron_type.name)\n self.type_combo.setEnabled(not neuron.is_protected and not neuron.is_sensor)\n self.x_spin.setValue(neuron.position[0])\n self.y_spin.setValue(neuron.position[1])\n self.delete_btn.setEnabled(not neuron.is_protected)\n \n self.name_edit.blockSignals(False)\n self.type_combo.blockSignals(False)\n self.x_spin.blockSignals(False)\n self.y_spin.blockSignals(False)\n \n def on_name_changed(self):\n if not self.current_neuron: return\n new_name = self.name_edit.text().strip()\n if new_name != self.current_neuron:\n if self.design.rename_neuron(self.current_neuron, new_name)[0]:\n self.current_neuron = new_name\n self.neuronChanged.emit(new_name)\n\n def on_type_changed(self, t):\n if self.current_neuron:\n self.design.get_neuron(self.current_neuron).neuron_type = NeuronType[t]\n self.neuronChanged.emit(self.current_neuron)\n\n def on_pos_changed(self):\n if self.current_neuron:\n self.design.get_neuron(self.current_neuron).position = (self.x_spin.value(), self.y_spin.value())\n self.neuronChanged.emit(self.current_neuron)\n\n def on_delete(self):\n if self.design.remove_neuron(self.current_neuron)[0]:\n self.current_neuron = None\n self.neuronChanged.emit(\"\")\n\nclass LayersPanel(QWidget):\n layersChanged = pyqtSignal()\n def __init__(self, design, parent=None):\n super().__init__(parent)\n self.design = design\n self.setup_ui()\n \n def setup_ui(self):\n l = QVBoxLayout(self)\n self.list = QListWidget()\n l.addWidget(self.list)\n btn = QPushButton(\"Add Layer\")\n btn.clicked.connect(self.add_layer)\n l.addWidget(btn)\n self.refresh()\n \n def refresh(self):\n self.list.clear()\n for layer in self.design.layers:\n self.list.addItem(f\"{layer.name} ({layer.layer_type.name})\")\n\n def add_layer(self):\n name, ok = QInputDialog.getText(self, \"New Layer\", \"Name:\")\n if ok and name:\n self.design.add_layer(DesignerLayer(name, NeuronType.HIDDEN, 200))\n self.refresh()\n self.layersChanged.emit()\n\nclass SensorsPanel(QWidget):\n \"\"\"\n Panel showing available input sensors.\n \n Supports both built-in sensors from INPUT_SENSORS and\n custom sensors registered by plugins via the PluginManager.\n \"\"\"\n sensorsChanged = pyqtSignal()\n \n def __init__(self, design, parent=None):\n super().__init__(parent)\n self.design = design\n self._scroll_widget = None # Store reference for dynamic updates\n self._scroll_layout = None\n self.setup_ui()\n \n def setup_ui(self):\n l = QVBoxLayout(self)\n \n # Header with refresh button for plugin sensors\n header = QHBoxLayout()\n header.addWidget(QLabel(\"Input Sensors:\"))\n header.addStretch()\n \n refresh_btn = QPushButton(\"🔄\")\n refresh_btn.setToolTip(\"Refresh sensor list (includes plugin-registered sensors)\")\n refresh_btn.setMaximumWidth(30)\n refresh_btn.clicked.connect(self.rebuild_sensor_list)\n header.addWidget(refresh_btn)\n l.addLayout(header)\n \n # Scrollable sensor list\n scroll = QScrollArea()\n self._scroll_widget = QWidget()\n self._scroll_layout = QVBoxLayout(self._scroll_widget)\n self.checks = {}\n \n # Build initial sensor list\n self._populate_sensors()\n \n scroll.setWidget(self._scroll_widget)\n scroll.setWidgetResizable(True)\n l.addWidget(scroll)\n self.refresh()\n \n def _populate_sensors(self):\n \"\"\"Populate the sensor checkboxes from all available sources.\"\"\"\n # Clear existing checkboxes\n self.checks.clear()\n while self._scroll_layout.count():\n item = self._scroll_layout.takeAt(0)\n if item.widget():\n item.widget().deleteLater()\n \n # Get all available sensors (built-in + plugin)\n all_sensors = get_all_available_sensors()\n \n # Group by category\n categories = {}\n for name, info in all_sensors.items():\n cat = info.get('category', 'other')\n if cat not in categories:\n categories[cat] = {}\n categories[cat][name] = info\n \n # Add sensors grouped by category\n for cat_name in sorted(categories.keys()):\n cat_sensors = categories[cat_name]\n \n # Add category label if there are multiple categories\n if len(categories) > 1:\n cat_label = QLabel(f\"── {cat_name.title()} ──\")\n cat_label.setStyleSheet(\"color: #888; font-size: 10px;\")\n self._scroll_layout.addWidget(cat_label)\n \n for name in sorted(cat_sensors.keys()):\n info = cat_sensors[name]\n \n # Create checkbox with plugin indicator\n display_name = name\n if info.get('plugin'):\n display_name = f\"🔌 {name}\" # Plugin indicator\n \n cb = QCheckBox(display_name)\n cb.setProperty('n', name)\n cb.stateChanged.connect(self.toggled)\n \n # Add tooltip with description\n tooltip = info.get('description', '')\n if info.get('plugin'):\n tooltip += f\"\\n[From plugin: {info['plugin']}]\"\n if info.get('is_binary'):\n tooltip += \"\\n[Binary: 0 or 100]\"\n if tooltip:\n cb.setToolTip(tooltip.strip())\n \n self.checks[name] = cb\n self._scroll_layout.addWidget(cb)\n \n # Add stretch at end\n self._scroll_layout.addStretch()\n \n def rebuild_sensor_list(self):\n \"\"\"Rebuild the sensor list to pick up newly registered plugin sensors.\"\"\"\n self._populate_sensors()\n self.refresh()\n \n def refresh(self):\n \"\"\"Update checkbox states based on current design.\"\"\"\n current = set(self.design.get_sensors_in_design())\n for name, cb in self.checks.items():\n cb.blockSignals(True)\n cb.setChecked(name in current)\n cb.blockSignals(False)\n\n def toggled(self, state):\n name = self.sender().property('n')\n if state: \n self.design.add_sensor(name)\n else: \n self.design.remove_neuron(name)\n self.sensorsChanged.emit()\n\nclass ConnectionsTable(QWidget):\n connectionChanged = pyqtSignal()\n def __init__(self, design, parent=None):\n super().__init__(parent)\n self.design = design\n l = QVBoxLayout(self)\n self.table = QTableWidget()\n self.table.setColumnCount(3)\n self.table.setHorizontalHeaderLabels([\"Source\", \"Target\", \"Weight\"])\n self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)\n l.addWidget(self.table)\n self.refresh()\n \n def refresh(self):\n self.table.setRowCount(len(self.design.connections))\n for i, c in enumerate(self.design.connections):\n self.table.setItem(i, 0, QTableWidgetItem(c.source))\n self.table.setItem(i, 1, QTableWidgetItem(c.target))\n self.table.setItem(i, 2, QTableWidgetItem(str(c.weight)))"
},
{
"path": "src/designer_sensor_discovery.py",
"content": "# designer_sensor_discovery.py\r\n\"\"\"\r\nUtility module for discovering available input sensors.\r\n\r\nThis module provides functions to merge built-in sensors from designer_constants\r\nwith plugin-registered custom sensors from the plugin manager.\r\n\"\"\"\r\n\r\nfrom typing import Dict, Any, Optional\r\n\r\n# Try to import designer constants\r\ntry:\r\n from .designer_constants import INPUT_SENSORS, REQUIRED_NEURONS, BINARY_NEURONS\r\nexcept ImportError:\r\n # Fallbacks if constants file is missing or structure is different\r\n INPUT_SENSORS = {}\r\n REQUIRED_NEURONS = {}\r\n BINARY_NEURONS = set()\r\n\r\n# Localization helper\r\ntry:\r\n from localization import tr\r\nexcept ImportError:\r\n def tr(key, **kwargs):\r\n return key\r\n\r\n\r\ndef get_plugin_manager() -> Optional[Any]:\r\n \"\"\"\r\n Try to get the PluginManager singleton instance.\r\n \r\n Returns:\r\n PluginManager instance or None if not available\r\n \"\"\"\r\n try:\r\n from plugin_manager import PluginManager\r\n pm = PluginManager()\r\n if hasattr(pm, '_initialized') and pm._initialized:\r\n return pm\r\n except ImportError:\r\n pass\r\n except Exception:\r\n pass\r\n return None\r\n\r\n\r\ndef get_builtin_sensors() -> Dict[str, Dict]:\r\n \"\"\"\r\n Get all built-in sensors from designer_constants.\r\n \r\n Returns:\r\n Dict mapping sensor names to their info dicts\r\n \"\"\"\r\n sensors = {}\r\n \r\n # Add INPUT_SENSORS\r\n # NOTE: In brain_constants, values are (x, y) tuples, not dicts.\r\n for name, info in INPUT_SENSORS.items():\r\n # Default values\r\n description = tr(\"desc_builtin_sensor\").format(name=name.replace('_', ' ').title())\r\n is_binary = name in BINARY_NEURONS\r\n category = tr(\"desc_builtin\")\r\n default_connections = []\r\n \r\n # Handle case where info is a dict (future compatibility) vs tuple (current)\r\n if isinstance(info, dict):\r\n description = info.get('description', description)\r\n is_binary = info.get('is_binary', is_binary)\r\n category = info.get('category', category)\r\n default_connections = info.get('default_connections', default_connections)\r\n \r\n sensors[name] = {\r\n 'description': description,\r\n 'is_binary': is_binary,\r\n 'category': category,\r\n 'plugin': None, # Built-in, not from a plugin\r\n 'default_connections': default_connections\r\n }\r\n \r\n # Add can_see_food from REQUIRED_NEURONS if not already present\r\n if 'can_see_food' not in sensors and 'can_see_food' in REQUIRED_NEURONS:\r\n # Check if REQUIRED_NEURONS uses dicts or tuples\r\n info = REQUIRED_NEURONS['can_see_food']\r\n \r\n description = tr(\"desc_vision_food\")\r\n default_connections = []\r\n \r\n if isinstance(info, dict):\r\n description = info.get('description', description)\r\n default_connections = info.get('default_connections', default_connections)\r\n\r\n sensors['can_see_food'] = {\r\n 'description': description,\r\n 'is_binary': True,\r\n 'category': tr(\"desc_vision\"),\r\n 'plugin': None,\r\n 'default_connections': default_connections\r\n }\r\n \r\n return sensors\r\n\r\n\r\ndef get_plugin_sensors() -> Dict[str, Dict]:\r\n \"\"\"\r\n Get all custom sensors registered by plugins.\r\n \r\n Returns:\r\n Dict mapping sensor names to their info dicts\r\n \"\"\"\r\n pm = get_plugin_manager()\r\n if not pm or not hasattr(pm, 'get_all_neuron_handler_info'):\r\n return {}\r\n \r\n sensors = {}\r\n try:\r\n for name, data in pm.get_all_neuron_handler_info().items():\r\n metadata = data.get('metadata', {})\r\n plugin_name = data.get(\"plugin\", \"unknown\")\r\n default_desc = tr(\"desc_custom_sensor\").format(plugin=plugin_name)\r\n \r\n sensors[name] = {\r\n 'description': metadata.get('description', default_desc),\r\n 'is_binary': metadata.get('is_binary', False),\r\n 'category': metadata.get('category', tr(\"desc_plugin\")),\r\n 'plugin': data.get('plugin'),\r\n 'default_connections': metadata.get('default_connections', [])\r\n }\r\n except Exception as e:\r\n print(f\"[Designer] Error getting plugin sensors: {e}\")\r\n return {}\r\n \r\n return sensors\r\n\r\n\r\ndef get_all_available_sensors() -> Dict[str, Dict]:\r\n \"\"\"\r\n Get all available sensors (built-in + plugin-registered).\r\n \r\n Returns:\r\n Dict mapping sensor names to their info dicts.\r\n Each info dict contains:\r\n - description: Human-readable description\r\n - is_binary: Whether the sensor outputs only 0 or 100\r\n - category: Category for grouping\r\n - plugin: Plugin name if custom, None if built-in\r\n - default_connections: Suggested default connections\r\n \"\"\"\r\n sensors = get_builtin_sensors()\r\n \r\n # Merge plugin sensors (plugin sensors can override built-ins)\r\n plugin_sensors = get_plugin_sensors()\r\n for name, info in plugin_sensors.items():\r\n if name in sensors:\r\n # Plugin is overriding a built-in sensor\r\n info['_overrides_builtin'] = True\r\n sensors[name] = info\r\n \r\n return sensors\r\n\r\n\r\ndef get_sensors_by_category() -> Dict[str, Dict[str, Dict]]:\r\n \"\"\"\r\n Get all sensors organized by category.\r\n \r\n Returns:\r\n Dict mapping category names to dicts of sensors in that category\r\n \"\"\"\r\n sensors = get_all_available_sensors()\r\n by_category = {}\r\n \r\n for name, info in sensors.items():\r\n category = info.get('category', tr(\"desc_other\"))\r\n if category not in by_category:\r\n by_category[category] = {}\r\n by_category[category][name] = info\r\n \r\n return by_category\r\n\r\n\r\ndef refresh_plugin_sensors():\r\n \"\"\"\r\n Force refresh of plugin sensors.\r\n \r\n Call this after plugins are loaded/enabled to update the available sensors.\r\n \"\"\"\r\n # Currently a no-op since we query the plugin manager dynamically,\r\n # but could be used for caching in the future\r\n pass\r\n\r\n\r\n# Convenience function for checking if a sensor is from a plugin\r\ndef is_plugin_sensor(sensor_name: str) -> bool:\r\n \"\"\"Check if a sensor is from a plugin rather than built-in.\"\"\"\r\n sensors = get_all_available_sensors()\r\n if sensor_name in sensors:\r\n return sensors[sensor_name].get('plugin') is not None\r\n return False"
},
{
"path": "src/designer_templates.py",
"content": "from .designer_core import BrainDesign, DesignerLayer, DesignerNeuron\r\nfrom .designer_constants import NeuronType, REQUIRED_NEURONS, CORE_NEURONS, INPUT_SENSORS, DEFAULT_LAYER_SPACING\r\nimport random\r\n\r\nclass TemplateManager:\r\n @staticmethod\r\n def get_templates() -> dict:\r\n return {\r\n 'core_only': {'name': '🟡 Required Only', 'description': '8 required neurons'},\r\n 'dosidicus_default': {'name': '🟡 Dosidicus Default', 'description': 'Standard layout'},\r\n 'full_sensors': {'name': '🟡 Full Sensor Suite', 'description': 'All sensors'},\r\n 'insomniac': {'name': '🔴 The Insomniac', 'description': 'Anxiety & Curiosity block sleep'},\r\n 'hyperactive': {'name': '🔴 The Hyperactive', 'description': 'Noise neurons overwhelm sleepiness'},\r\n 'hangry': {'name': '🔴 The Hangry', 'description': 'Hunger causes extreme rage'},\r\n 'depressive': {'name': '🔴 The Depressive', 'description': 'Resistant to happiness'},\r\n 'obsessive': {'name': '🔴 The Obsessive', 'description': 'Anxiety/Curiosity feedback loop'},\r\n }\r\n \r\n @staticmethod\r\n def create_template(key: str) -> BrainDesign:\r\n design = BrainDesign()\r\n \r\n # ==========================================\r\n # STANDARD TEMPLATES\r\n # ==========================================\r\n if key == 'core_only':\r\n design.layers = [DesignerLayer(\"Sensors\", NeuronType.INPUT, 100), DesignerLayer(\"Core\", NeuronType.HIDDEN, 250)]\r\n design.add_missing_required_neurons()\r\n \r\n elif key == 'full_sensors':\r\n design.layers = [DesignerLayer(\"Input\", NeuronType.INPUT, 50), DesignerLayer(\"Core\", NeuronType.HIDDEN, 200), DesignerLayer(\"Out\", NeuronType.OUTPUT, 350)]\r\n design.add_missing_required_neurons()\r\n design.add_all_sensors()\r\n\r\n # ==========================================\r\n # PATHOLOGICAL / SPECIFIC BEHAVIORS\r\n # ==========================================\r\n elif key == 'insomniac':\r\n # A brain where active states aggressively inhibit sleep\r\n design.layers = [DesignerLayer(\"Sensors\", NeuronType.INPUT, 150), DesignerLayer(\"Racing Mind\", NeuronType.HIDDEN, 200), DesignerLayer(\"State\", NeuronType.OUTPUT, 350)]\r\n design.add_missing_required_neurons()\r\n \r\n # The Insomniac Logic:\r\n # Any active emotion makes it impossible to sleep (Strong Inhibition)\r\n design.add_connection(\"anxiety\", \"sleepiness\", -0.95)\r\n design.add_connection(\"curiosity\", \"sleepiness\", -0.80)\r\n design.add_connection(\"hunger\", \"sleepiness\", -0.50)\r\n design.add_connection(\"can_see_food\", \"sleepiness\", -0.50)\r\n \r\n # Weak positive feedback means once awake, they stay awake\r\n design.add_connection(\"sleepiness\", \"anxiety\", 0.2) # Being tired makes them anxious\r\n\r\n elif key == 'hyperactive':\r\n # A brain with a \"Noise\" layer that floods the system\r\n design.layers = [\r\n DesignerLayer(\"Vision\", NeuronType.INPUT, 150), \r\n DesignerLayer(\"Core\", NeuronType.HIDDEN, 200), \r\n DesignerLayer(\"Noise\", NeuronType.HIDDEN, 300), # Extra space for noise neurons\r\n DesignerLayer(\"Output\", NeuronType.OUTPUT, 400)\r\n ]\r\n design.add_missing_required_neurons()\r\n\r\n # Create 12 \"Noise\" neurons that act as a distraction generator\r\n noise_neurons = [f\"noise_{i}\" for i in range(12)]\r\n for n in noise_neurons:\r\n design.add_neuron(n, \"Noise\")\r\n \r\n # The \"Overwhelm\" Logic:\r\n # These neurons excite sleepiness (crash) and curiosity (distraction)\r\n # Randomize weights slightly so they aren't identical\r\n w_sleep = random.uniform(0.6, 0.9)\r\n w_curiosity = random.uniform(0.5, 0.8)\r\n \r\n design.add_connection(n, \"sleepiness\", w_sleep) # Floods sleep buffer\r\n design.add_connection(n, \"curiosity\", w_curiosity) # Forces erratic attention\r\n \r\n # Connect noise to itself for chaotic sustainability\r\n if random.random() > 0.5:\r\n target = random.choice(noise_neurons)\r\n design.add_connection(n, target, 0.4)\r\n\r\n elif key == 'hangry':\r\n # Metabolic mood disorder\r\n design.layers = [DesignerLayer(\"Sensors\", NeuronType.INPUT, 100), DesignerLayer(\"Gut-Brain\", NeuronType.HIDDEN, 200)]\r\n design.add_missing_required_neurons()\r\n \r\n # Hunger overrides all positive emotions and triggers anxiety/stress\r\n design.add_connection(\"hunger\", \"happiness\", -1.0) # Cannot be happy if hungry\r\n design.add_connection(\"hunger\", \"satisfaction\", -1.0)\r\n design.add_connection(\"hunger\", \"anxiety\", 0.9) # Extreme stress when hungry\r\n design.add_connection(\"can_see_food\", \"anxiety\", 0.5) # Seeing food but not eating it is stressful\r\n\r\n elif key == 'depressive':\r\n # Anhedonia model: High resistance to positive weights\r\n design.layers = [DesignerLayer(\"Input\", NeuronType.INPUT, 150), DesignerLayer(\"Gray\", NeuronType.HIDDEN, 200)]\r\n design.add_missing_required_neurons()\r\n \r\n # Hard to get happy, easy to get sad\r\n design.add_connection(\"satisfaction\", \"happiness\", 0.1) # Drastically reduced reward\r\n design.add_connection(\"curiosity\", \"happiness\", 0.0) # No joy from exploration\r\n design.add_connection(\"anxiety\", \"happiness\", -0.8) # Anxiety kills happiness easily\r\n design.add_connection(\"sleepiness\", \"happiness\", -0.6)\r\n\r\n elif key == 'obsessive':\r\n # Feedback loop central\r\n design.layers = [DesignerLayer(\"Input\", NeuronType.INPUT, 150), DesignerLayer(\"Loop\", NeuronType.HIDDEN, 200)]\r\n design.add_missing_required_neurons()\r\n \r\n # Tight feedback loop between anxiety and curiosity (Worrying/Checking)\r\n design.add_connection(\"anxiety\", \"curiosity\", 0.7) # Worry makes you check things\r\n design.add_connection(\"curiosity\", \"anxiety\", 0.5) # Checking things makes you worry\r\n design.add_connection(\"sleepiness\", \"anxiety\", 0.4) # Being tired makes the loops worse\r\n\r\n else: # Default Dosidicus\r\n design.layers = [DesignerLayer(\"Vision\", NeuronType.INPUT, 200), DesignerLayer(\"Stats\", NeuronType.HIDDEN, 81), DesignerLayer(\"Emotions\", NeuronType.OUTPUT, 385)]\r\n design.add_missing_required_neurons()\r\n # Default connections\r\n design.add_connection(\"can_see_food\", \"hunger\", 0.3)\r\n design.add_connection(\"can_see_food\", \"happiness\", 0.2)\r\n design.add_connection(\"hunger\", \"satisfaction\", -0.5)\r\n \r\n\r\n return design"
},
{
"path": "src/designer_window.py",
"content": "\"\"\"\r\nBrain Designer Window - Main application window for designing custom neural networks.\r\n\r\nThis module provides a visual editor for creating and editing squid brain configurations\r\nincluding neurons, connections, layers, sensors, and output bindings.\r\n\"\"\"\r\n\r\nimport sys\r\nfrom PyQt5.QtWidgets import (\r\n QMainWindow, QWidget, QHBoxLayout, QVBoxLayout, QTabWidget, QStatusBar,\r\n QAction, QToolBar, QLabel, QComboBox, QPushButton, QMessageBox, QFileDialog,\r\n QDialog, QInputDialog, QFrame, QSizePolicy, QToolButton, QMenu, QSplitter\r\n)\r\nfrom PyQt5.QtGui import (\r\n QKeySequence, QIcon, QFont, QFontMetrics, QPainter, QColor, QPalette,\r\n QTextDocument, QAbstractTextDocumentLayout\r\n)\r\n# [FIX] Added QRectF to imports\r\nfrom PyQt5.QtCore import Qt, QTimer, QPropertyAnimation, QRect, QRectF, QSizeF, pyqtSignal\r\n\r\nfrom .designer_logging import get_logger, log_exceptions, safe_call, OperationLogger\r\nfrom .designer_core import BrainDesign\r\nfrom .designer_canvas import BrainCanvas\r\n\r\n# Import brain state bridge for game communication\r\ntry:\r\n from .brain_state_bridge import (\r\n is_game_running,\r\n import_brain_state_for_designer,\r\n convert_to_brain_design,\r\n export_design_to_game\r\n )\r\n _HAS_BRAIN_BRIDGE = True\r\nexcept ImportError:\r\n _HAS_BRAIN_BRIDGE = False\r\n print(\"[BrainDesigner] Warning: brain_state_bridge not found, live import disabled\")\r\nfrom .designer_panels import (\r\n LayersPanel, SensorsPanel, NeuronPropertiesPanel, ConnectionsTable, AddNeuronDialog\r\n)\r\nfrom .designer_templates import TemplateManager\r\nfrom .designer_dialogs import SparseNetworkDialog, ActivationEditorDialog\r\nfrom .designer_network_generator import SparseNetworkGenerator\r\n\r\n# Import the new outputs panel\r\ntry:\r\n from .designer_outputs_panel import NeuronOutputsPanel\r\n _HAS_OUTPUTS_PANEL = True\r\nexcept ImportError:\r\n _HAS_OUTPUTS_PANEL = False\r\n print(\"[BrainDesigner] Warning: designer_outputs_panel not found, outputs tab disabled\")\r\n\r\n\r\nclass ScrollingTicker(QWidget):\r\n \"\"\"A widget that smoothly scrolls rich text (HTML) horizontally.\"\"\"\r\n \r\n def __init__(self, text, parent=None):\r\n super().__init__(parent)\r\n self.text = text\r\n self.offset = 0\r\n \r\n # Prepare text document for HTML rendering\r\n self.doc = QTextDocument()\r\n self.doc.setDefaultFont(self.font())\r\n self.doc.setHtml(self.text)\r\n self.doc.setTextWidth(-1) # No wrap\r\n \r\n # Calculate dimensions\r\n self.text_width = self.doc.idealWidth()\r\n self.text_height = self.doc.size().height() # FIX: Call method with ()\r\n \r\n # Separator\r\n self.sep_doc = QTextDocument()\r\n self.sep_doc.setDefaultFont(self.font())\r\n self.sep_doc.setHtml(\" • \")\r\n self.sep_doc.setTextWidth(-1)\r\n self.sep_width = self.sep_doc.idealWidth()\r\n \r\n # Timer - don't start it yet\r\n self.timer = QTimer(self)\r\n self.timer.timeout.connect(self.scroll_text)\r\n self.timer.setInterval(30) # ~33fps\r\n \r\n # Style\r\n self.setStyleSheet(\"background-color: transparent;\")\r\n self.setFixedHeight(30)\r\n \r\n def showEvent(self, event):\r\n \"\"\"Start timer when widget becomes visible.\"\"\"\r\n super().showEvent(event)\r\n # Start timer on first show (prevents premature updates)\r\n if not self.timer.isActive():\r\n self.timer.start()\r\n \r\n def hideEvent(self, event):\r\n \"\"\"Stop timer when widget becomes hidden.\"\"\"\r\n super().hideEvent(event)\r\n self.timer.stop()\r\n \r\n def scroll_text(self):\r\n \"\"\"Update scroll offset and trigger repaint.\"\"\"\r\n self.offset -= 1\r\n if self.offset <= -(self.text_width + self.sep_width):\r\n self.offset = 0\r\n self.update()\r\n \r\n def paintEvent(self, event):\r\n \"\"\"Paint the scrolling text with proper painter lifecycle.\"\"\"\r\n painter = QPainter(self)\r\n \r\n # Ensure painter is valid before proceeding\r\n if not painter.isActive():\r\n return\r\n \r\n # Removed the try...finally block - Qt handles painter lifecycle automatically\r\n painter.setRenderHint(QPainter.Antialiasing)\r\n \r\n # Center vertically\r\n y_pos = (self.height() - self.text_height) / 2\r\n \r\n # Draw copies of the text until we fill the width\r\n current_x = self.offset\r\n while current_x < self.width():\r\n # Draw Main Text\r\n painter.save()\r\n painter.translate(current_x, y_pos)\r\n self.doc.drawContents(painter, QRectF(0, 0, self.text_width, self.text_height))\r\n painter.restore()\r\n \r\n current_x += self.text_width\r\n \r\n # Draw Separator\r\n painter.save()\r\n painter.translate(current_x, y_pos)\r\n self.sep_doc.drawContents(painter, QRectF(0, 0, self.sep_width, self.text_height))\r\n painter.restore()\r\n \r\n current_x += self.sep_width\r\n \r\n # REMOVED: No need for finally block or manual painter.end()\r\n\r\n\r\nclass BrainDesignerWindow(QMainWindow):\r\n \"\"\"Main window for the Brain Designer application.\"\"\"\r\n\r\n # Signal to notify parent when user wants to exit/return\r\n exitRequested = pyqtSignal()\r\n\r\n def __init__(self, parent=None, embedded_mode=False):\r\n super().__init__(parent)\r\n self.logger = get_logger(\"brain_designer.window\")\r\n self.logger.info(\"Initializing BrainDesignerWindow\")\r\n \r\n self.embedded_mode = embedded_mode\r\n\r\n try:\r\n self.design = BrainDesign()\r\n self.design.add_missing_required_neurons()\r\n\r\n self.setWindowTitle(\"Brain Designer - Dosidicus-2\")\r\n self.setMinimumSize(1280, 900)\r\n\r\n with OperationLogger(\"Setting up UI\", self.logger):\r\n self.setup_ui()\r\n\r\n with OperationLogger(\"Setting up menus\", self.logger):\r\n self.setup_menus()\r\n\r\n with OperationLogger(\"Setting up toolbar\", self.logger):\r\n self.setup_toolbar()\r\n\r\n # Only auto-generate if NOT embedded (embedded mode will load existing state)\r\n if not self.embedded_mode:\r\n with OperationLogger(\"Initializing brain network\", self.logger):\r\n self._imported_from_game = False\r\n if not self._try_import_from_game():\r\n # No game running, generate random network\r\n self.generate_initial_network()\r\n \r\n # Show import notification if applicable\r\n if self._imported_from_game:\r\n self._show_import_notification()\r\n\r\n # Force UI refresh\r\n self.refresh_all()\r\n self.update_status()\r\n self.logger.info(\"BrainDesignerWindow initialized successfully\")\r\n\r\n except Exception as e:\r\n self.logger.critical(f\"Failed to initialize window: {e}\", exc_info=True)\r\n raise\r\n\r\n # ==========================================================================\r\n # INITIALIZATION AND SETUP\r\n # ==========================================================================\r\n\r\n def setup_ui(self):\r\n \"\"\"Setup the main UI layout.\"\"\"\r\n # Main splitter layout\r\n self.splitter = QSplitter(Qt.Horizontal)\r\n self.setCentralWidget(self.splitter)\r\n\r\n # === LEFT/CENTER: CANVAS AREA ===\r\n canvas_wrapper = QWidget()\r\n canvas_wrapper.setMinimumWidth(500)\r\n \r\n canvas_container = QVBoxLayout(canvas_wrapper)\r\n canvas_container.setContentsMargins(0, 0, 0, 0)\r\n canvas_container.setSpacing(5)\r\n\r\n # Canvas toolbar\r\n canvas_toolbar = self.create_canvas_toolbar()\r\n canvas_container.addWidget(canvas_toolbar)\r\n\r\n # Main canvas\r\n self.canvas = BrainCanvas(self.design)\r\n self.canvas.neuronSelected.connect(self.on_neuron_selected)\r\n self.canvas.connectionCreated.connect(self.on_connection_created)\r\n self.canvas.connectionSelected.connect(self.on_connection_selected)\r\n self.canvas.weightChanged.connect(self.on_weight_changed)\r\n self.canvas.connectionDeleted.connect(self.on_connection_deleted)\r\n\r\n canvas_container.addWidget(self.canvas)\r\n\r\n # Canvas help bar\r\n help_bar = self.create_help_bar()\r\n canvas_container.addWidget(help_bar)\r\n\r\n self.splitter.addWidget(canvas_wrapper)\r\n\r\n # === RIGHT PANEL (Tabbed Panels) ===\r\n self.right_panel = QTabWidget()\r\n self.right_panel.setTabPosition(QTabWidget.West) # Vertical tabs on the left edge\r\n self.right_panel.setMinimumWidth(350)\r\n\r\n # 1. Layers Panel\r\n self.layers_panel = LayersPanel(self.design)\r\n self.layers_panel.layersChanged.connect(self.on_design_changed)\r\n self.right_panel.addTab(self.layers_panel, \"Layers\")\r\n\r\n # 2. Sensors Panel (Input neurons)\r\n self.sensors_panel = SensorsPanel(self.design)\r\n self.sensors_panel.sensorsChanged.connect(self.on_design_changed)\r\n self.right_panel.addTab(self.sensors_panel, \"Sensors\")\r\n\r\n # 3. Properties Panel\r\n self.props_panel = NeuronPropertiesPanel(self.design)\r\n self.props_panel.neuronChanged.connect(self.on_design_changed)\r\n self.right_panel.addTab(self.props_panel, \"Properties\")\r\n\r\n # 4. Connections Table\r\n self.connections_table = ConnectionsTable(self.design)\r\n self.right_panel.addTab(self.connections_table, \"Connections\")\r\n\r\n # 5. Outputs Panel (Actuator neurons) - NEW!\r\n if _HAS_OUTPUTS_PANEL:\r\n self.outputs_panel = NeuronOutputsPanel(self.design)\r\n self.outputs_panel.outputsChanged.connect(self.on_design_changed)\r\n self.right_panel.addTab(self.outputs_panel, \"Outputs\")\r\n else:\r\n self.outputs_panel = None\r\n\r\n self.splitter.addWidget(self.right_panel)\r\n \r\n # Set Sensors as the default tab (index 1)\r\n self.right_panel.setCurrentIndex(1)\r\n\r\n # Set initial splitter sizes (approx 70% canvas, 30% sidebar)\r\n self.splitter.setCollapsible(0, False)\r\n self.splitter.setCollapsible(1, False)\r\n \r\n self.splitter.setStretchFactor(0, 1)\r\n self.splitter.setStretchFactor(1, 0)\r\n \r\n self.splitter.setSizes([850, 400])\r\n\r\n # Status bar\r\n self.status_bar = QStatusBar()\r\n self.setStatusBar(self.status_bar)\r\n\r\n def create_canvas_toolbar(self) -> QFrame:\r\n \"\"\"Create the toolbar above the canvas.\"\"\"\r\n toolbar = QFrame()\r\n toolbar.setFrameStyle(QFrame.StyledPanel)\r\n toolbar.setMaximumHeight(45)\r\n layout = QHBoxLayout(toolbar)\r\n layout.setContentsMargins(8, 4, 8, 4)\r\n\r\n # Generate button (prominent)\r\n generate_btn = QPushButton(\"🎲 Generate\")\r\n generate_btn.setToolTip(\"Generate random connections between core neurons\")\r\n generate_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #2196F3;\r\n color: white;\r\n font-weight: bold;\r\n padding: 6px 16px;\r\n border-radius: 4px;\r\n }\r\n QPushButton:hover {\r\n background-color: #1976D2;\r\n }\r\n \"\"\")\r\n generate_btn.clicked.connect(self.show_sparse_network_dialog)\r\n layout.addWidget(generate_btn)\r\n\r\n # Quick generate menu\r\n quick_gen_btn = QToolButton()\r\n quick_gen_btn.setText(\"▼\")\r\n quick_gen_btn.setPopupMode(QToolButton.InstantPopup)\r\n quick_menu = QMenu(quick_gen_btn)\r\n\r\n generator = SparseNetworkGenerator()\r\n for key, info in generator.get_preset_styles().items():\r\n action = quick_menu.addAction(f\"{info['name']} - {info['description']}\")\r\n action.setData(key)\r\n action.triggered.connect(lambda checked, k=key: self.quick_generate(k))\r\n\r\n quick_gen_btn.setMenu(quick_menu)\r\n layout.addWidget(quick_gen_btn)\r\n \r\n # Quick dice button - instant random generation\r\n dice_btn = QPushButton(\"🎲\")\r\n dice_btn.setToolTip(\"Instantly shuffle positions and generate a chaotic network (no dialog)\")\r\n dice_btn.setFixedWidth(40)\r\n dice_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #FF9800;\r\n color: white;\r\n font-size: 18px;\r\n padding: 6px;\r\n border-radius: 4px;\r\n }\r\n QPushButton:hover {\r\n background-color: #F57C00;\r\n }\r\n \"\"\")\r\n dice_btn.clicked.connect(self.instant_random_generate)\r\n layout.addWidget(dice_btn)\r\n\r\n layout.addSpacing(20)\r\n\r\n # Divider\r\n divider = QFrame()\r\n divider.setFrameShape(QFrame.VLine)\r\n divider.setFrameShadow(QFrame.Sunken)\r\n layout.addWidget(divider)\r\n\r\n layout.addSpacing(10)\r\n\r\n # + Neuron button (colorful, prominent)\r\n add_neuron_btn = QPushButton(\"➕ Neuron\")\r\n add_neuron_btn.setToolTip(\"Add a new neuron (Shift+N)\")\r\n add_neuron_btn.setShortcut(\"Shift+N\")\r\n add_neuron_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #4CAF50;\r\n color: white;\r\n font-weight: bold;\r\n padding: 6px 14px;\r\n border-radius: 4px;\r\n }\r\n QPushButton:hover {\r\n background-color: #43A047;\r\n }\r\n \"\"\")\r\n add_neuron_btn.clicked.connect(self.show_add_neuron_dialog)\r\n layout.addWidget(add_neuron_btn)\r\n\r\n layout.addSpacing(10)\r\n\r\n # Auto-fix button\r\n fix_btn = QPushButton(\"🔧 Auto-Fix\")\r\n fix_btn.setToolTip(\"Automatically fix orphan neurons and connectivity issues\")\r\n fix_btn.clicked.connect(self.run_auto_fix)\r\n #layout.addWidget(fix_btn)\r\n\r\n # Validate button\r\n validate_btn = QPushButton(\"✓ Validate\")\r\n validate_btn.setToolTip(\"Check design for issues\")\r\n validate_btn.clicked.connect(self.check_status)\r\n #layout.addWidget(validate_btn)\r\n\r\n # Placeholder for sync button - will be added later if game is detected\r\n self._sync_btn_container = QFrame()\r\n self._sync_btn_layout = QHBoxLayout(self._sync_btn_container)\r\n self._sync_btn_layout.setContentsMargins(0, 0, 0, 0)\r\n self._sync_btn_container.hide() # Hidden by default\r\n layout.addWidget(self._sync_btn_container)\r\n \r\n # Add RETURN button if embedded\r\n if self.embedded_mode:\r\n layout.addSpacing(20)\r\n return_btn = QPushButton(\"💾 Save & Return to Game\")\r\n return_btn.setToolTip(\"Save changes and return to game view\")\r\n return_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #673AB7;\r\n color: white;\r\n font-weight: bold;\r\n padding: 6px 14px;\r\n border-radius: 4px;\r\n }\r\n QPushButton:hover {\r\n background-color: #5E35B1;\r\n }\r\n \"\"\")\r\n return_btn.clicked.connect(self.exitRequested.emit)\r\n layout.addWidget(return_btn)\r\n\r\n layout.addStretch()\r\n\r\n # Clear connections button\r\n clear_btn = QPushButton(\"🗑 Clear Connections\")\r\n clear_btn.setToolTip(\"Remove all connections (keeps neurons)\")\r\n clear_btn.setStyleSheet(\"color: #d32f2f;\")\r\n clear_btn.clicked.connect(self.clear_all_connections)\r\n layout.addWidget(clear_btn)\r\n\r\n return toolbar\r\n\r\n def create_help_bar(self) -> QFrame:\r\n \"\"\"Create the help bar below the canvas with scrolling ticker.\"\"\"\r\n help_bar = QFrame()\r\n help_bar.setFrameStyle(QFrame.StyledPanel)\r\n help_bar.setMaximumHeight(30)\r\n layout = QHBoxLayout(help_bar)\r\n layout.setContentsMargins(0, 0, 0, 0)\r\n\r\n # Create scrolling ticker with comprehensive shortcuts\r\n self.help_ticker = ScrollingTicker(\r\n \"💡 Left-Drag from neuron to create connection \"\r\n \" Ctrl+Drag neuron to move it \"\r\n \" Right-Drag to pan canvas \"\r\n \" Scroll Wheel to zoom (or adjust weight on connection) \"\r\n \" Double-Click connection to edit weight \"\r\n \" Click neuron/connection to select \"\r\n \" Del to delete selected \"\r\n \" Space to reverse connection direction \"\r\n \" +/- keys to adjust weight (Shift for larger steps) \"\r\n \" Page Up/Down to adjust weight (large steps) \"\r\n \" Shift+N to add neuron \"\r\n \" Ctrl+S to save \"\r\n \" Ctrl+O to open \"\r\n \" Ctrl+E to export \"\r\n \" Ctrl+N for new design \"\r\n \" Ctrl+G to generate network \"\r\n \"🎲 Dice button for instant chaotic shuffle & generation \"\r\n \"Outputs tab to bind neurons to squid behaviors \"\r\n )\r\n layout.addWidget(self.help_ticker)\r\n\r\n return help_bar\r\n\r\n def setup_menus(self):\r\n \"\"\"Setup the menu bar.\"\"\"\r\n # In embedded mode, menus might not show up if parent is not main window.\r\n # But for QMainWindow they usually work.\r\n menu = self.menuBar()\r\n\r\n # File menu\r\n file_menu = menu.addMenu(\"File\")\r\n \r\n if self.embedded_mode:\r\n return_action = QAction(\"Save & Return to Game\", self)\r\n return_action.setShortcut(\"Ctrl+Return\")\r\n return_action.triggered.connect(self.exitRequested.emit)\r\n file_menu.addAction(return_action)\r\n file_menu.addSeparator()\r\n\r\n new_action = QAction(\"New Design\", self)\r\n new_action.setShortcut(\"Ctrl+N\")\r\n new_action.triggered.connect(self.new_design)\r\n file_menu.addAction(new_action)\r\n\r\n file_menu.addSeparator()\r\n\r\n save_action = QAction(\"Save...\", self)\r\n save_action.setShortcut(\"Ctrl+S\")\r\n save_action.triggered.connect(self.save_design)\r\n #file_menu.addAction(save_action)\r\n\r\n export_action = QAction(\"Export for Dosidicus...\", self)\r\n export_action.setShortcut(\"Ctrl+E\")\r\n export_action.triggered.connect(self.export_design)\r\n file_menu.addAction(export_action)\r\n\r\n file_menu.addSeparator()\r\n\r\n open_action = QAction(\"Open...\", self)\r\n open_action.setShortcut(\"Ctrl+O\")\r\n open_action.triggered.connect(self.open_design)\r\n file_menu.addAction(open_action)\r\n\r\n # Edit menu\r\n edit_menu = menu.addMenu(\"Edit\")\r\n\r\n generate_action = QAction(\"Generate Network...\", self)\r\n generate_action.setShortcut(\"Ctrl+G\")\r\n generate_action.triggered.connect(self.show_sparse_network_dialog)\r\n edit_menu.addAction(generate_action)\r\n\r\n edit_menu.addSeparator()\r\n\r\n auto_fix = QAction(\"Auto-Fix Connectivity\", self)\r\n auto_fix.triggered.connect(self.run_auto_fix)\r\n edit_menu.addAction(auto_fix)\r\n\r\n validate_action = QAction(\"Validate Design\", self)\r\n validate_action.triggered.connect(self.check_status)\r\n #edit_menu.addAction(validate_action)\r\n\r\n edit_menu.addSeparator()\r\n\r\n clear_conn_action = QAction(\"Clear All\", self)\r\n clear_conn_action.triggered.connect(self.clear_all_connections)\r\n edit_menu.addAction(clear_conn_action)\r\n \r\n # Clear outputs action\r\n if _HAS_OUTPUTS_PANEL:\r\n clear_outputs_action = QAction(\"Clear all Bindings\", self)\r\n clear_outputs_action.triggered.connect(self.clear_all_outputs)\r\n edit_menu.addAction(clear_outputs_action)\r\n\r\n # Templates menu\r\n tpl_menu = menu.addMenu(\"Templates\")\r\n for key, info in TemplateManager.get_templates().items():\r\n a = QAction(info['name'], self)\r\n a.setData(key)\r\n a.triggered.connect(self.load_template)\r\n tpl_menu.addAction(a)\r\n\r\n # Network generation presets\r\n gen_menu = menu.addMenu(\"Generate\")\r\n\r\n gen_dialog_action = QAction(\"🎲 Generate...\", self)\r\n gen_dialog_action.setShortcut(\"Ctrl+G\")\r\n gen_dialog_action.triggered.connect(self.show_sparse_network_dialog)\r\n gen_menu.addAction(gen_dialog_action)\r\n\r\n gen_menu.addSeparator()\r\n\r\n generator = SparseNetworkGenerator()\r\n for key, info in generator.get_preset_styles().items():\r\n action = QAction(f\"{info['name']}\", self)\r\n action.setToolTip(info['description'])\r\n action.setData(key)\r\n action.triggered.connect(lambda checked, k=key: self.quick_generate(k))\r\n gen_menu.addAction(action)\r\n\r\n def setup_toolbar(self):\r\n \"\"\"Setup the main toolbar.\"\"\"\r\n toolbar = QToolBar(\"Main\")\r\n toolbar.setMovable(False)\r\n self.addToolBar(toolbar)\r\n\r\n # File actions\r\n toolbar.addAction(\"📂 Open\", self.open_design)\r\n toolbar.addAction(\"💾 Save\", self.save_design)\r\n\r\n toolbar.addSeparator()\r\n\r\n if _HAS_BRAIN_BRIDGE:\r\n push_action = QAction(\"🚀 Push to Game\", self)\r\n push_action.setToolTip(\"Export current design directly to the running Dosidicus game\")\r\n push_action.triggered.connect(self.push_to_game)\r\n toolbar.addAction(push_action)\r\n toolbar.addSeparator()\r\n\r\n # Template dropdown\r\n toolbar.addAction(\"📋 Templates\", self.show_template_menu)\r\n\r\n def push_to_game(self):\r\n \"\"\"Export current design, state, and bindings directly to the running game.\"\"\"\r\n if not _HAS_BRAIN_BRIDGE:\r\n return\r\n\r\n if not is_game_running():\r\n QMessageBox.warning(self, \"Game Not Found\", \r\n \"Dosidicus does not appear to be running.\\nStart the game to push designs.\")\r\n return\r\n\r\n try:\r\n # 1. Ensure bindings are up to date\r\n if self.outputs_panel:\r\n self.design.output_bindings = self.outputs_panel.export_bindings()\r\n\r\n # 2. Convert to the format the game expects\r\n data = self.design.to_dosidicus_format()\r\n \r\n # 3. Push via bridge\r\n if export_design_to_game(data):\r\n self.status_bar.showMessage(\"Design pushed to running game\", 3000)\r\n self.tamagotchi_logic.show_message(\"Custom Brain was pushed from Designer\")\r\n else:\r\n QMessageBox.warning(self, \"Export Failed\", \"Could not write bridge file.\")\r\n \r\n except Exception as e:\r\n self.logger.error(f\"Push to game failed: {e}\", exc_info=True)\r\n QMessageBox.critical(self, \"Error\", f\"Failed to push design:\\n{e}\")\r\n\r\n # ==========================================================================\r\n # DATA LOADING AND CONVERSION\r\n # ==========================================================================\r\n \r\n def load_from_brain_widget_state(self, state):\r\n \"\"\"\r\n Load design from a brain widget state dictionary.\r\n Used for in-process switching with robust fallback.\r\n \"\"\"\r\n try:\r\n imported_design = None\r\n \r\n # Attempt 1: Try using the bridge if available\r\n try:\r\n from .brain_state_bridge import convert_to_brain_design\r\n imported_design = convert_to_brain_design(state)\r\n except ImportError:\r\n # Bridge not found, proceed to fallback\r\n pass\r\n \r\n # Attempt 2: Direct conversion using DesignerCore (Fallback)\r\n if imported_design is None:\r\n # If bridge failed or returned None, use the core method directly\r\n # This ensures we don't need the bridge to be active/present\r\n from .designer_core import BrainDesign\r\n # Try dosidicus format first (likely coming from BrainWidget)\r\n imported_design = BrainDesign.from_dosidicus_format(state)\r\n \r\n if imported_design is None:\r\n self.logger.warning(\"Could not convert state to BrainDesign\")\r\n return False\r\n \r\n # Apply the design\r\n self.design = imported_design\r\n self.refresh_all()\r\n \r\n # Force canvas to center on the new nodes\r\n if hasattr(self, 'canvas'):\r\n self.canvas.center_on_neurons()\r\n \r\n self.logger.info(\r\n f\"Loaded design from memory: {len(self.design.neurons)} neurons\"\r\n )\r\n return True\r\n \r\n except Exception as e:\r\n self.logger.error(f\"Error loading from state: {e}\", exc_info=True)\r\n return False\r\n\r\n def get_current_design_state(self):\r\n \"\"\"\r\n Get the current design as a state dictionary compatible with BrainWidget.\r\n \"\"\"\r\n try:\r\n # Sync output bindings first\r\n if self.outputs_panel:\r\n self.design.output_bindings = self.outputs_panel.export_bindings()\r\n \r\n # Export to dosidicus format (compatible with loader)\r\n return self.design.to_dosidicus_format()\r\n except Exception as e:\r\n self.logger.error(f\"Error exporting state: {e}\", exc_info=True)\r\n return None\r\n\r\n # ==========================================================================\r\n # REFRESH AND STATUS\r\n # ==========================================================================\r\n\r\n def refresh_all(self):\r\n \"\"\"Refresh all panels with current design.\"\"\"\r\n self.canvas.design = self.design\r\n self.props_panel.design = self.design\r\n self.layers_panel.design = self.design\r\n self.sensors_panel.design = self.design\r\n self.connections_table.design = self.design\r\n \r\n # Refresh outputs panel and load bindings from design\r\n if self.outputs_panel:\r\n self.outputs_panel.design = self.design\r\n self.outputs_panel.load_bindings(self.design.output_bindings)\r\n \r\n self.on_design_changed()\r\n\r\n def update_status(self):\r\n \"\"\"Update the status bar.\"\"\"\r\n stats = self.design.get_stats()\r\n \r\n # Build status message\r\n status_parts = [\r\n f\"Neurons: {stats['total_neurons']}\",\r\n f\"Connections: {stats['connections']}\",\r\n f\"Required: {'✓' if stats['has_all_required'] else '✗'}\"\r\n ]\r\n \r\n # Add output bindings count if available\r\n if self.outputs_panel:\r\n binding_count = len(self.outputs_panel.bindings)\r\n if binding_count > 0:\r\n status_parts.append(f\"Outputs: {binding_count}\")\r\n \r\n self.status_bar.showMessage(\" | \".join(status_parts))\r\n\r\n # ==========================================================================\r\n # NETWORK GENERATION AND CLEARING\r\n # ==========================================================================\r\n\r\n def generate_initial_network(self):\r\n \"\"\"Generate a random network on startup without user interaction.\"\"\"\r\n import random\r\n try:\r\n generator = SparseNetworkGenerator()\r\n \r\n # 50% chance of minimalist configuration (sparse, no feedback)\r\n # This creates a variety of startup experiences for the user\r\n if random.random() < 0.5:\r\n density = 0.5\r\n include_feedback = False\r\n mode = \"minimalist\"\r\n else:\r\n density = 1.0\r\n include_feedback = True\r\n mode = \"balanced\"\r\n\r\n count, _ = generator.generate_for_design(\r\n self.design,\r\n clear_existing=True,\r\n density=density,\r\n include_feedback=include_feedback,\r\n silent=True\r\n )\r\n self.logger.debug(f\"Generated initial network ({mode}) with {count} connections\")\r\n except Exception as e:\r\n self.logger.warning(f\"Could not generate initial network: {e}\")\r\n\r\n def _try_import_from_game(self) -> bool:\r\n \"\"\"\r\n Attempt to import brain state from a running game instance.\r\n \r\n Returns:\r\n True if import was successful, False otherwise\r\n \"\"\"\r\n if not _HAS_BRAIN_BRIDGE:\r\n return False\r\n \r\n try:\r\n # Check if game is running\r\n if not is_game_running():\r\n self.logger.debug(\"No running game detected, will generate random network\")\r\n return False\r\n \r\n self.logger.info(\"Detected running game, attempting to import brain state...\")\r\n \r\n # Import the brain state\r\n live_state = import_brain_state_for_designer()\r\n if live_state is None:\r\n self.logger.warning(\"Could not import brain state from game\")\r\n return False\r\n \r\n # Convert to BrainDesign\r\n imported_design = convert_to_brain_design(live_state)\r\n if imported_design is None:\r\n self.logger.warning(\"Could not convert imported state to BrainDesign\")\r\n return False\r\n \r\n # Replace current design with imported one\r\n self.design = imported_design\r\n \r\n # Update canvas reference\r\n if hasattr(self, 'canvas'):\r\n self.canvas.design = self.design\r\n \r\n self._imported_from_game = True\r\n self.logger.info(\r\n f\"Successfully imported brain from game: \"\r\n f\"{len(self.design.neurons)} neurons, \"\r\n f\"{len(self.design.connections)} connections\"\r\n )\r\n return True\r\n \r\n except Exception as e:\r\n self.logger.error(f\"Error importing from game: {e}\", exc_info=True)\r\n return False\r\n\r\n def _show_import_notification(self):\r\n \"\"\"Show notification that brain was imported from running game.\"\"\"\r\n from PyQt5.QtWidgets import QMessageBox\r\n from PyQt5.QtCore import QTimer\r\n \r\n # Show the sync button now that we know game is running\r\n self._show_sync_button()\r\n \r\n # Create a non-modal notification\r\n msg = QMessageBox(self)\r\n msg.setIcon(QMessageBox.Information)\r\n msg.setWindowTitle(\"Live Brain Import\")\r\n msg.setText(\"🧠 Active brain imported from running game\")\r\n msg.setInformativeText(\r\n f\"The designer is now showing the exact neural network \"\r\n f\"from your running Dosidicus game.\\n\\n\"\r\n f\"• {len(self.design.neurons)} neurons\\n\"\r\n f\"• {len(self.design.connections)} connections\\n\\n\"\r\n f\"Changes made here will NOT affect the running game.\"\r\n )\r\n msg.setStandardButtons(QMessageBox.Ok)\r\n \r\n # Show and auto-close after 5 seconds\r\n msg.show()\r\n QTimer.singleShot(5000, msg.close)\r\n \r\n # Update window title to indicate imported state\r\n self.setWindowTitle(\"Brain Designer - Dosidicus-2 [Imported from Game]\")\r\n \r\n # Update status bar\r\n self.status_bar.showMessage(\r\n \"✨ Active brain imported from running game\", 10000\r\n )\r\n\r\n def _show_sync_button(self):\r\n \"\"\"Show the sync button when game connection is established.\"\"\"\r\n if not _HAS_BRAIN_BRIDGE:\r\n return\r\n \r\n # Clear any existing content\r\n while self._sync_btn_layout.count():\r\n item = self._sync_btn_layout.takeAt(0)\r\n if item.widget():\r\n item.widget().deleteLater()\r\n \r\n # Add divider\r\n divider = QFrame()\r\n divider.setFrameShape(QFrame.VLine)\r\n divider.setFrameShadow(QFrame.Sunken)\r\n self._sync_btn_layout.addWidget(divider)\r\n \r\n # Add sync button\r\n sync_btn = QPushButton(\"🔄 Sync from Game\")\r\n sync_btn.setToolTip(\"Refresh brain state from running Dosidicus game\")\r\n sync_btn.setStyleSheet(\"\"\"\r\n QPushButton {\r\n background-color: #9C27B0;\r\n color: white;\r\n font-weight: bold;\r\n padding: 6px 12px;\r\n border-radius: 4px;\r\n }\r\n QPushButton:hover {\r\n background-color: #7B1FA2;\r\n }\r\n \"\"\")\r\n sync_btn.clicked.connect(self.sync_from_running_game)\r\n self._sync_btn_layout.addWidget(sync_btn)\r\n \r\n # Show the container\r\n self._sync_btn_container.show()\r\n\r\n def sync_from_running_game(self):\r\n \"\"\"\r\n Manually sync brain state from running game.\r\n Called when user clicks the Sync from Game button.\r\n \"\"\"\r\n # Check if game is still running\r\n if not is_game_running():\r\n QMessageBox.information(\r\n self, \"Game Not Running\",\r\n \"The Dosidicus game is no longer running.\\n\\n\"\r\n \"Start the game again to sync.\"\r\n )\r\n # Hide the sync button since game is gone\r\n self._sync_btn_container.hide()\r\n self.setWindowTitle(\"Brain Designer - Dosidicus-2\")\r\n return\r\n \r\n # Confirm before replacing current design\r\n reply = QMessageBox.question(\r\n self, \"Sync from Game\",\r\n \"Replace current design with the latest brain state from the game?\",\r\n QMessageBox.Yes | QMessageBox.No,\r\n QMessageBox.No\r\n )\r\n \r\n if reply != QMessageBox.Yes:\r\n return\r\n \r\n # Try to import\r\n if self._try_import_from_game():\r\n self.refresh_all()\r\n self.status_bar.showMessage(\r\n f\"✨ Synced: {len(self.design.neurons)} neurons, \"\r\n f\"{len(self.design.connections)} connections\", 5000\r\n )\r\n else:\r\n QMessageBox.warning(\r\n self, \"Sync Failed\",\r\n \"Could not import brain state from game.\"\r\n )\r\n\r\n def show_sparse_network_dialog(self):\r\n \"\"\"Show the sparse network generation dialog.\"\"\"\r\n dialog = SparseNetworkDialog(self.design, self)\r\n if dialog.exec_() == QDialog.Accepted:\r\n self.on_design_changed()\r\n\r\n def quick_generate(self, style_key):\r\n \"\"\"Quickly generate a network using a preset style.\"\"\"\r\n try:\r\n generator = SparseNetworkGenerator()\r\n presets = generator.get_preset_styles()\r\n \r\n if style_key not in presets:\r\n return\r\n \r\n preset = presets[style_key]\r\n \r\n # Determine dynamic bounds from the canvas view if available\r\n bounds = (-450, -250, 650, 500)\r\n if hasattr(self, 'canvas') and self.canvas.viewport():\r\n try:\r\n view_rect = self.canvas.viewport().rect()\r\n scene_poly = self.canvas.mapToScene(view_rect)\r\n brect = scene_poly.boundingRect()\r\n bounds = (brect.left(), brect.top(), brect.right(), brect.bottom())\r\n except Exception:\r\n pass\r\n\r\n count, connections = generator.generate_for_design(\r\n self.design,\r\n clear_existing=True,\r\n density=preset.get('density', 1.0),\r\n include_feedback=preset.get('include_feedback', False),\r\n position_variance=preset.get('position_variance', 0.2),\r\n sensor_probability=preset.get('sensor_probability', 0.0),\r\n bounds=bounds\r\n )\r\n \r\n self.on_design_changed()\r\n self.status_bar.showMessage(\r\n f\"Generated {count} connections using '{preset['name']}' preset\", 3000\r\n )\r\n except Exception as e:\r\n self.logger.error(f\"Error in quick_generate: {e}\", exc_info=True)\r\n QMessageBox.warning(self, \"Error\", f\"Generation failed: {e}\")\r\n\r\n def instant_random_generate(self):\r\n \"\"\"Instantly generate a random network without any dialog, shuffling positions.\"\"\"\r\n import random\r\n \r\n try:\r\n generator = SparseNetworkGenerator()\r\n presets = generator.get_preset_styles()\r\n \r\n # Pick a random preset as a base\r\n style_key = random.choice(list(presets.keys()))\r\n preset = presets[style_key]\r\n \r\n # Randomize connection parameters\r\n density = random.uniform(0.7, 1.4)\r\n \r\n # !! CHAOS MODE !!\r\n # Use high variance to shuffle neurons around the visible canvas\r\n position_variance = random.uniform(0.6, 1.0) \r\n \r\n # Calculate dynamic bounds from the actual visible canvas area\r\n if hasattr(self, 'canvas') and self.canvas.viewport():\r\n try:\r\n view_rect = self.canvas.viewport().rect()\r\n scene_poly = self.canvas.mapToScene(view_rect)\r\n brect = scene_poly.boundingRect()\r\n bounds = (brect.left(), brect.top(), brect.right(), brect.bottom())\r\n except Exception:\r\n # Fallback if calculation fails\r\n bounds = (-450, -250, 650, 500)\r\n else:\r\n bounds = (-450, -250, 650, 500)\r\n \r\n count, _ = generator.generate_for_design(\r\n self.design,\r\n clear_existing=True,\r\n density=density,\r\n include_feedback=random.random() > 0.3,\r\n position_variance=position_variance,\r\n bounds=bounds,\r\n sensor_probability=0.2 # Add some random sensors for flavor\r\n )\r\n \r\n self.on_design_changed()\r\n \r\n # Ensure the canvas recenters on the new chaotic layout\r\n if self.canvas:\r\n self.canvas.center_on_neurons()\r\n \r\n self.status_bar.showMessage(\r\n f\"🎲 Chaos! Shuffled positions & made {count} connections ({preset['name']} style)\", 3000\r\n )\r\n except Exception as e:\r\n self.logger.error(f\"Error in instant_random_generate: {e}\", exc_info=True)\r\n\r\n def clear_all_connections(self):\r\n \"\"\"Clear all connections from the design.\"\"\"\r\n reply = QMessageBox.question(\r\n self, \"Clear Connections\",\r\n f\"Remove all {len(self.design.connections)} connections?\\n\\n\"\r\n \"Neurons will be kept.\",\r\n QMessageBox.Yes | QMessageBox.No\r\n )\r\n\r\n if reply == QMessageBox.Yes:\r\n count = len(self.design.connections)\r\n self.design.connections.clear()\r\n self.on_design_changed()\r\n self.status_bar.showMessage(f\"Cleared {count} connections\", 3000)\r\n\r\n def clear_all_outputs(self):\r\n \"\"\"Clear all output bindings from the design.\"\"\"\r\n if not self.outputs_panel:\r\n return\r\n \r\n if not self.outputs_panel.bindings:\r\n QMessageBox.information(self, \"Clear Outputs\", \"No output bindings to clear.\")\r\n return\r\n \r\n reply = QMessageBox.question(\r\n self, \"Clear Output Bindings\",\r\n f\"Remove all {len(self.outputs_panel.bindings)} output bindings?\",\r\n QMessageBox.Yes | QMessageBox.No\r\n )\r\n \r\n if reply == QMessageBox.Yes:\r\n count = len(self.outputs_panel.bindings)\r\n self.outputs_panel.bindings.clear()\r\n self.outputs_panel.refresh()\r\n self.design.output_bindings = []\r\n self.on_design_changed()\r\n self.status_bar.showMessage(f\"Cleared {count} output bindings\", 3000)\r\n\r\n # ==========================================================================\r\n # EVENT HANDLERS / CALLBACKS\r\n # ==========================================================================\r\n\r\n def on_design_changed(self):\r\n \"\"\"Called when the design is modified.\"\"\"\r\n try:\r\n self.canvas.rebuild()\r\n self.connections_table.refresh()\r\n self.sensors_panel.refresh()\r\n self.layers_panel.refresh()\r\n \r\n # Refresh outputs panel\r\n if self.outputs_panel:\r\n self.outputs_panel.refresh()\r\n \r\n self.update_status()\r\n except Exception as e:\r\n self.logger.error(f\"Error updating design view: {e}\", exc_info=True)\r\n\r\n def on_neuron_selected(self, name):\r\n \"\"\"Called when a neuron is selected on the canvas.\"\"\"\r\n self.props_panel.set_neuron(name)\r\n # Switch to properties tab if a neuron is selected\r\n if name:\r\n self.right_panel.setCurrentWidget(self.props_panel)\r\n\r\n def show_add_neuron_dialog(self, x=None, y=None):\r\n \"\"\"Show dialog to add a new neuron.\"\"\"\r\n pos = (x, y) if x is not None else None\r\n dlg = AddNeuronDialog(self.design, pos, self)\r\n if dlg.exec_() == QDialog.Accepted:\r\n self.on_design_changed()\r\n\r\n def on_connection_created(self, source, target):\r\n \"\"\"Called when a new connection is created via drag.\"\"\"\r\n weight, ok = QInputDialog.getDouble(\r\n self, \"Connection Weight\",\r\n f\"Set weight for {source} → {target}:\",\r\n 0.5, -1.0, 1.0, 2\r\n )\r\n if ok:\r\n conn = self.design.get_connection(source, target)\r\n if conn:\r\n conn.weight = weight\r\n self.on_design_changed()\r\n else:\r\n # Cancel: remove the connection\r\n self.design.remove_connection(source, target)\r\n self.on_design_changed()\r\n\r\n def on_connection_selected(self, source, target):\r\n \"\"\"Called when a connection is selected.\"\"\"\r\n conn = self.design.get_connection(source, target)\r\n if conn:\r\n self.status_bar.showMessage(\r\n f\"Selected: {source} → {target} (weight: {conn.weight:+.3f})\"\r\n )\r\n\r\n def on_weight_changed(self, source, target, new_weight):\r\n \"\"\"Called when a connection weight is changed.\"\"\"\r\n self.connections_table.refresh()\r\n self.status_bar.showMessage(\r\n f\"Weight updated: {source} → {target} = {new_weight:+.3f}\", 2000\r\n )\r\n\r\n def on_connection_deleted(self, source, target):\r\n \"\"\"Called when a connection is deleted.\"\"\"\r\n self.on_design_changed()\r\n self.status_bar.showMessage(f\"Deleted connection: {source} → {target}\", 2000)\r\n\r\n # ==========================================================================\r\n # FILE AND UTILITY OPERATIONS\r\n # ==========================================================================\r\n\r\n def new_design(self):\r\n \"\"\"Create a new empty design.\"\"\"\r\n reply = QMessageBox.question(\r\n self, \"New Design\",\r\n \"Start a new design? Unsaved changes will be lost.\",\r\n QMessageBox.Yes | QMessageBox.No\r\n )\r\n if reply == QMessageBox.Yes:\r\n self.design = BrainDesign()\r\n self.design.add_missing_required_neurons()\r\n self.refresh_all()\r\n\r\n def run_auto_fix(self):\r\n \"\"\"Run auto-fix on the design.\"\"\"\r\n count, actions = self.design.auto_fix_connectivity()\r\n if count > 0:\r\n self.on_design_changed()\r\n # [FIX] Force immediate repaint so changes are visible behind the message box\r\n if self.canvas:\r\n self.canvas.viewport().repaint()\r\n \r\n QMessageBox.information(\r\n self, \"Auto-Fix\",\r\n f\"Created {count} connections:\\n\\n\" + \"\\n\".join(actions[:10])\r\n )\r\n else:\r\n QMessageBox.information(self, \"Auto-Fix\", \"No issues found.\")\r\n\r\n def save_design(self):\r\n \"\"\"Save the design to file.\"\"\"\r\n try:\r\n # Sync output bindings from panel to design BEFORE saving\r\n if self.outputs_panel:\r\n self.design.output_bindings = self.outputs_panel.export_bindings()\r\n \r\n path, _ = QFileDialog.getSaveFileName(\r\n self, \"Save Design\", \"brain.json\", \"JSON (*.json)\"\r\n )\r\n if path:\r\n self.logger.info(f\"Saving design to: {path}\")\r\n success, msg = self.design.save(path)\r\n if success:\r\n self.logger.info(f\"Design saved successfully: {msg}\")\r\n \r\n # Add output binding info to message\r\n if self.outputs_panel and self.outputs_panel.bindings:\r\n msg += f\"\\n({len(self.outputs_panel.bindings)} output bindings included)\"\r\n \r\n QMessageBox.information(self, \"Saved\", msg)\r\n else:\r\n self.logger.warning(f\"Save failed: {msg}\")\r\n QMessageBox.warning(self, \"Error\", msg)\r\n except Exception as e:\r\n self.logger.error(f\"Error saving design: {e}\", exc_info=True)\r\n QMessageBox.warning(self, \"Error\", f\"Failed to save design:\\n\\n{e}\")\r\n\r\n def export_design(self):\r\n \"\"\"Export in Dosidicus format.\"\"\"\r\n try:\r\n # Sync output bindings from panel to design BEFORE exporting\r\n if self.outputs_panel:\r\n self.design.output_bindings = self.outputs_panel.export_bindings()\r\n \r\n path, _ = QFileDialog.getSaveFileName(\r\n self, \"Export\", \"dosidicus_brain.json\", \"JSON (*.json)\"\r\n )\r\n if path:\r\n self.logger.info(f\"Exporting design to: {path}\")\r\n success, msg = self.design.export_dosidicus(path)\r\n if success:\r\n self.logger.info(f\"Design exported successfully\")\r\n \r\n # Add output binding info to message\r\n if self.outputs_panel and self.outputs_panel.bindings:\r\n msg += f\"\\n({len(self.outputs_panel.bindings)} output bindings included)\"\r\n \r\n QMessageBox.information(self, \"Exported\", msg)\r\n else:\r\n self.logger.warning(f\"Export failed: {msg}\")\r\n QMessageBox.warning(self, \"Error\", msg)\r\n except Exception as e:\r\n self.logger.error(f\"Error exporting design: {e}\", exc_info=True)\r\n QMessageBox.warning(self, \"Error\", f\"Failed to export design:\\n\\n{e}\")\r\n\r\n def open_design(self):\r\n \"\"\"Open a design file.\"\"\"\r\n try:\r\n path, _ = QFileDialog.getOpenFileName(\r\n self, \"Open Design\", \"\", \"JSON (*.json)\"\r\n )\r\n if path:\r\n self.logger.info(f\"Opening design from: {path}\")\r\n self.design = BrainDesign.load(path)\r\n self.logger.info(\r\n f\"Design loaded: {len(self.design.neurons)} neurons, \"\r\n f\"{len(self.design.connections)} connections\"\r\n )\r\n \r\n # Load output bindings into the panel\r\n if self.outputs_panel:\r\n self.outputs_panel.load_bindings(self.design.output_bindings)\r\n if self.design.output_bindings:\r\n self.logger.info(f\"Loaded {len(self.design.output_bindings)} output bindings\")\r\n \r\n self.refresh_all()\r\n except Exception as e:\r\n self.logger.error(f\"Error opening design: {e}\", exc_info=True)\r\n QMessageBox.warning(self, \"Error\", f\"Could not load design:\\n\\n{e}\")\r\n\r\n def show_template_menu(self):\r\n \"\"\"Show templates as a popup.\"\"\"\r\n templates = TemplateManager.get_templates()\r\n items = [f\"{info['name']} - {info['description']}\" for info in templates.values()]\r\n keys = list(templates.keys())\r\n\r\n item, ok = QInputDialog.getItem(\r\n self, \"Load Template\", \"Select a template:\", items, 0, False\r\n )\r\n if ok and item:\r\n idx = items.index(item)\r\n key = keys[idx]\r\n if QMessageBox.question(\r\n self, \"Load Template\", \"Replace current design?\",\r\n QMessageBox.Yes | QMessageBox.No\r\n ) == QMessageBox.Yes:\r\n self.design = TemplateManager.create_template(key)\r\n self.refresh_all()\r\n\r\n def load_template(self):\r\n \"\"\"Load a template from menu action.\"\"\"\r\n key = self.sender().data()\r\n if QMessageBox.question(\r\n self, \"Load Template\", \"Replace current design?\",\r\n QMessageBox.Yes | QMessageBox.No\r\n ) == QMessageBox.Yes:\r\n self.design = TemplateManager.create_template(key)\r\n self.refresh_all()\r\n\r\n def check_status(self):\r\n \"\"\"Validate and show design status.\"\"\"\r\n self.on_design_changed()\r\n stats = self.design.get_stats()\r\n _, issues, _ = self.design.validate(auto_fix=False)\r\n\r\n msg = (\r\n f\"Neurons: {stats['total_neurons']}\\n\"\r\n f\" • Required: {stats['required_neurons']}\\n\"\r\n f\" • Sensors: {stats['sensor_neurons']}\\n\"\r\n f\" • Custom: {stats['custom_neurons']}\\n\\n\"\r\n f\"Connections: {stats['connections']}\\n\"\r\n f\"Layers: {stats['layers']}\\n\"\r\n )\r\n \r\n # Add output binding info\r\n if self.outputs_panel:\r\n binding_count = len(self.outputs_panel.bindings)\r\n enabled_count = sum(1 for b in self.outputs_panel.bindings if b.enabled)\r\n msg += f\"Output Bindings: {binding_count} ({enabled_count} enabled)\\n\"\r\n \r\n # Validate bindings\r\n binding_warnings = self.outputs_panel.validate_bindings()\r\n if binding_warnings:\r\n issues.extend(binding_warnings)\r\n\r\n if issues:\r\n msg += \"\\n⚠️ ISSUES:\\n\" + \"\\n\".join(f\" • {i}\" for i in issues)\r\n else:\r\n msg += \"\\n✅ Status: OK\"\r\n\r\n QMessageBox.information(self, \"Design Status\", msg)\r\n\r\n\r\n# =============================================================================\r\n# MAIN ENTRY POINT\r\n# =============================================================================\r\n\r\ndef main():\r\n \"\"\"Main entry point for the Brain Designer application.\"\"\"\r\n from PyQt5.QtWidgets import QApplication\r\n \r\n app = QApplication(sys.argv)\r\n app.setApplicationName(\"Brain Designer (Beta)\")\r\n app.setOrganizationName(\"Dosidicus\")\r\n \r\n window = BrainDesignerWindow()\r\n window.show()\r\n \r\n sys.exit(app.exec_())\r\n\r\n\r\nif __name__ == \"__main__\":\r\n main()"
},
{
"path": "src/display_scaling.py",
"content": "\r\nclass DisplayScaling:\r\n DESIGN_WIDTH = 2880\r\n DESIGN_HEIGHT = 1920\r\n _scale_factor = 1.0\r\n \r\n # Default scale factor (1.0 means no scaling)\r\n _scale_factor = 1.0\r\n \r\n @classmethod\r\n def initialize(cls, current_width, current_height):\r\n width_ratio = current_width / cls.DESIGN_WIDTH\r\n height_ratio = current_height / cls.DESIGN_HEIGHT\r\n base_scale_factor = min(width_ratio, height_ratio)\r\n \r\n if current_width <= 1920 and current_height <= 1080:\r\n cls._scale_factor = base_scale_factor * 0.85\r\n print(f\"1080p display detected: applying 85% scaling (factor={cls._scale_factor:.2f})\")\r\n else:\r\n cls._scale_factor = base_scale_factor\r\n print(f\"High resolution display ({current_width}x{current_height}): standard scaling (factor={cls._scale_factor:.2f})\")\r\n \r\n @classmethod\r\n def scale(cls, value):\r\n return int(value * cls._scale_factor)\r\n \r\n @classmethod\r\n def font_size(cls, size):\r\n scaled = cls.scale(size)\r\n return max(10, scaled)\r\n \r\n @classmethod\r\n def get_scale_factor(cls):\r\n return cls._scale_factor\r\n \r\n @classmethod\r\n def scale_css(cls, css_string):\r\n import re\r\n pattern = r'font-size:\\s*(\\d+)px'\r\n def replace_size(match):\r\n original_size = int(match.group(1))\r\n scaled_size = cls.font_size(original_size)\r\n return f'font-size: {scaled_size}px'\r\n return re.sub(pattern, replace_size, css_string)\r\n"
},
{
"path": "src/hidden_imports.txt",
"content": "plugins.achievements.display_scaling\r\nplugins.achievements.achievements_data\r\nuuid\r\nbrain_designer\r\ndesigner_window\r\ndesigner_core\r\ndesigner_constants\r\ndesigner_logging\r\ndesigner_dialogs\r\nbrain_state_bridge"
},
{
"path": "src/image_cache.py",
"content": "from PyQt5 import QtGui\r\n\r\nclass ImageCache:\r\n \"\"\"Global image cache to prevent duplicate loading\"\"\"\r\n _cache = {}\r\n \r\n @classmethod\r\n def get_pixmap(cls, path):\r\n \"\"\"Get a pixmap from cache or load it\"\"\"\r\n if path not in cls._cache:\r\n pixmap = QtGui.QPixmap(path)\r\n cls._cache[path] = pixmap\r\n return cls._cache[path]\r\n \r\n @classmethod\r\n def clear(cls):\r\n \"\"\"Clear cache to free memory\"\"\"\r\n cls._cache.clear()"
},
{
"path": "src/interactions.py",
"content": "\r\n# ROCK INTERACTIONS\r\n\r\nimport math\r\nimport time\r\nimport random\r\nimport os\r\nfrom PyQt5 import QtCore, QtWidgets, QtGui\r\n\r\nclass RockInteractionManager:\r\n def __init__(self, squid, logic, scene, message_callback, config_manager):\r\n self.squid = squid\r\n self.logic = logic\r\n self.scene = scene\r\n self.show_message = message_callback\r\n self.config_manager = config_manager\r\n self.rock_config = config_manager.get_rock_config()\r\n\r\n # Rock interaction state\r\n self.target_rock = None\r\n self.rock_test_phase = 0 # 0=approach, 1=carry, 2=throw\r\n self.rock_carry_time = 0\r\n self.rock_carry_duration = 0\r\n \r\n # Initialize timers\r\n self.rock_test_timer = QtCore.QTimer()\r\n self.throw_animation_timer = QtCore.QTimer()\r\n \r\n # Connect timers\r\n self.rock_test_timer.timeout.connect(self.update_rock_test)\r\n self.throw_animation_timer.timeout.connect(self.update_throw_animation)\r\n \r\n # Initialize throw velocity variables\r\n self.throw_velocity_x = 0\r\n self.throw_velocity_y = 0\r\n\r\n # Add multiplayer support\r\n self.multiplayer_plugin = None\r\n self.setup_multiplayer_integration()\r\n\r\n def setup_multiplayer_integration(self):\r\n \"\"\"Set up hooks for multiplayer integration\"\"\"\r\n if not hasattr(self.logic, 'plugin_manager'):\r\n return False\r\n \r\n # Get multiplayer plugin\r\n multiplayer_plugin = None\r\n for plugin_name, plugin_data in self.logic.plugin_manager.plugins.items():\r\n if plugin_name == \"multiplayer_plugin\":\r\n # Get the actual plugin instance\r\n multiplayer_plugin = plugin_data.get('instance')\r\n break\r\n \r\n if multiplayer_plugin:\r\n # Store reference\r\n self.multiplayer_plugin = multiplayer_plugin\r\n \r\n print(\"[RockInteraction] Successfully integrated with multiplayer plugin\")\r\n return True\r\n \r\n return False\r\n\r\n def is_valid_rock(self, item):\r\n \"\"\"Check if item is a valid rock\"\"\"\r\n if not isinstance(item, QtWidgets.QGraphicsPixmapItem):\r\n return False\r\n return (hasattr(item, 'category') and item.category == 'rock') or \\\r\n (hasattr(item, 'filename') and 'rock' in item.filename.lower())\r\n\r\n def can_pick_up_rock(self, rock):\r\n \"\"\"Check if squid can pick up this rock\"\"\"\r\n if not self.is_valid_rock(rock):\r\n return False\r\n if hasattr(rock, 'is_being_carried') and rock.is_being_carried:\r\n return False\r\n # Check if rock is in cooldown after being thrown\r\n if hasattr(rock, 'throw_cooldown_until'):\r\n if time.time() < rock.throw_cooldown_until:\r\n return False\r\n return True\r\n\r\n def attach_rock_to_squid(self, rock):\r\n \"\"\"Visually attach rock to squid at tentacle position\"\"\"\r\n rock.setParentItem(self.squid.squid_item)\r\n \r\n # Use config values for hold duration\r\n config = self.rock_config\r\n self.squid.rock_hold_duration = random.uniform(\r\n config['min_carry_duration'],\r\n config['max_carry_duration']\r\n )\r\n self.squid.rock_hold_start_time = time.time()\r\n self.squid.rock_decision_made = False\r\n \r\n offset = -50 # Both vertical and horizontal offset\r\n \r\n # Calculate position based on squid direction\r\n if self.squid.squid_direction == \"right\":\r\n # Position rock near right tentacles\r\n rock.setPos(self.squid.squid_width - 40 + offset, \r\n self.squid.squid_height - 30 + offset)\r\n elif self.squid.squid_direction == \"left\":\r\n # Position rock near left tentacles\r\n rock.setPos(10 + offset, \r\n self.squid.squid_height - 30 + offset)\r\n elif self.squid.squid_direction == \"up\":\r\n # Position rock near upper tentacles\r\n rock.setPos(self.squid.squid_width//2 - 15 + offset, \r\n self.squid.squid_height - 40 + offset)\r\n else: # down/default\r\n rock.setPos(self.squid.squid_width//2 - 15 + offset, \r\n self.squid.squid_height - 20 + offset)\r\n \r\n rock.is_being_carried = True\r\n self.squid.is_carrying_rock = True\r\n self.squid.carried_rock = rock\r\n rock.setZValue(self.squid.squid_item.zValue() + 1)\r\n \r\n # Scale rock to appropriate size\r\n rock.setScale(1.0)\r\n \r\n # Update squid status\r\n self.squid.status = \"carrying rock\"\r\n \r\n return True\r\n \r\n def check_rock_hold_time(self):\r\n \"\"\"Check if holding time elapsed and make decision\"\"\"\r\n if not hasattr(self.squid, 'carrying_rock') or not self.squid.carrying_rock or not hasattr(self.squid, 'rock_decision_made') or self.squid.rock_decision_made:\r\n return\r\n \r\n current_time = time.time()\r\n if current_time - self.squid.rock_hold_start_time >= self.squid.rock_hold_duration:\r\n self.squid.rock_decision_made = True\r\n self.decide_rock_action()\r\n\r\n def decide_rock_action(self):\r\n \"\"\"Randomly decide to throw or drop the rock\"\"\"\r\n if random.random() < 0.7: # 70% chance to throw\r\n direction = \"right\" if random.random() < 0.5 else \"left\"\r\n self.throw_rock(direction)\r\n if self.show_message:\r\n self.show_message(\"Squid threw the rock!\")\r\n else: # 30% chance to drop\r\n self.drop_rock()\r\n if self.show_message:\r\n self.show_message(\"Squid dropped the rock\")\r\n\r\n def drop_rock(self):\r\n \"\"\"Gently place the rock below the squid\"\"\"\r\n if not hasattr(self.squid, 'carrying_rock') or not self.squid.carrying_rock or not hasattr(self.squid, 'carried_rock') or not self.squid.carried_rock:\r\n return\r\n \r\n rock = self.squid.carried_rock\r\n rock.setParentItem(None)\r\n rock.setPos(\r\n self.squid.squid_x + self.squid.squid_width//2 - rock.boundingRect().width()//2,\r\n self.squid.squid_y + self.squid.squid_height + 10\r\n )\r\n self.squid.is_carrying_rock = False\r\n self.squid.carried_rock = None\r\n\r\n def start_rock_test(self, rock=None):\r\n \"\"\"Start test with guaranteed clean state and random carry duration\"\"\"\r\n self.cleanup() # Reset everything first\r\n \r\n if rock is None:\r\n # Filter rocks that are valid, visible, and not on cooldown\r\n rocks = [item for item in self.scene.items() \r\n if self.is_valid_rock(item) and item.isVisible() and self.can_pick_up_rock(item)]\r\n if not rocks:\r\n if self.show_message:\r\n self.show_message(\"No available rocks!\")\r\n return False\r\n rock = min(rocks, key=lambda r: math.hypot(\r\n r.sceneBoundingRect().center().x() - self.squid.squid_x,\r\n r.sceneBoundingRect().center().y() - self.squid.squid_y\r\n ))\r\n elif not self.can_pick_up_rock(rock):\r\n if self.show_message:\r\n self.show_message(\"Rock is on cooldown!\")\r\n return False\r\n \r\n self.target_rock = rock\r\n self.rock_test_phase = 0\r\n # Use the config values for duration\r\n self.rock_carry_duration = random.uniform(\r\n self.rock_config['min_carry_duration'],\r\n self.rock_config['max_carry_duration']\r\n )\r\n self.rock_carry_time = 0 # Reset carry timer\r\n self.rock_test_timer.start(100) # 100ms updates\r\n return True\r\n\r\n def highlight_rock(self, rock):\r\n \"\"\"Visual feedback for selected rock\"\"\"\r\n highlight = QtWidgets.QGraphicsOpacityEffect()\r\n highlight.setOpacity(0.3) # Initial opacity\r\n rock.setGraphicsEffect(highlight)\r\n \r\n # Animate highlight\r\n self.animate_highlight(highlight)\r\n\r\n def animate_highlight(self, highlight_effect):\r\n \"\"\"Pulse animation for rock highlight\"\"\"\r\n self.highlight_animation = QtCore.QPropertyAnimation(highlight_effect, b\"opacity\")\r\n self.highlight_animation.setDuration(1000)\r\n self.highlight_animation.setStartValue(0.3)\r\n self.highlight_animation.setEndValue(0.8)\r\n self.highlight_animation.setLoopCount(3)\r\n self.highlight_animation.start()\r\n\r\n def throw_rock(self, direction=\"right\"):\r\n \"\"\"Initiates a rock throw with positive memory formation\"\"\"\r\n # Prevent multiple throws\r\n if self.throw_animation_timer.isActive():\r\n return False\r\n \r\n if not hasattr(self.squid, 'carried_rock') or not self.squid.carried_rock:\r\n return False\r\n \r\n config = self.rock_config\r\n rock = self.squid.carried_rock\r\n \r\n # Set squid status to throwing rock with more detail\r\n if hasattr(self.squid, 'status'):\r\n if random.random() < 0.3:\r\n self.squid.status = \"throwing rock\"\r\n else:\r\n self.squid.status = \"playing with rock\"\r\n \r\n # Detach from squid and reset parent to scene\r\n rock.setParentItem(None)\r\n \r\n # Calculate throw vectors\r\n throw_power = 12 # Increased from 8\r\n angle = math.radians(30 if direction == \"right\" else 150)\r\n self.throw_velocity_x = throw_power * math.cos(angle)\r\n self.throw_velocity_y = -throw_power * math.sin(angle) # Negative for upward\r\n \r\n # Set position to squid's center in scene coordinates\r\n squid_rect = self.squid.squid_item.sceneBoundingRect()\r\n rock_rect = rock.boundingRect()\r\n rock.setPos(\r\n squid_rect.center().x() - rock_rect.width()/2,\r\n squid_rect.center().y() - rock_rect.height()/2\r\n )\r\n \r\n rock.setVisible(True)\r\n \r\n # Apply stat changes\r\n self.squid.happiness = min(100, self.squid.happiness + config['happiness_boost'])\r\n self.squid.satisfaction = min(100, self.squid.satisfaction + config['satisfaction_boost'])\r\n self.squid.anxiety = max(0, self.squid.anxiety - config['anxiety_reduction'])\r\n self.logic.statistics_window.award(50)\r\n \r\n # Simplified positive memory\r\n rock_filename = getattr(rock, 'filename', '') or ''\r\n is_urchin = 'rock03' in rock_filename.lower()\r\n memory_details = {\r\n \"activity\": \"urchin_throwing\" if is_urchin else \"rock_throwing\",\r\n \"item\": rock_filename,\r\n \"effects\": {\r\n \"happiness\": config['happiness_boost'],\r\n \"satisfaction\": config['satisfaction_boost'],\r\n \"anxiety\": -config['anxiety_reduction']\r\n },\r\n \"description\": \"Had fun throwing an urchin!\" if is_urchin else \"Had fun throwing a rock!\",\r\n \"is_positive\": True\r\n }\r\n\r\n # Update rocks thrown counter\r\n if hasattr(self.squid, 'statistics'):\r\n self.squid.statistics.total_rocks_thrown += 1\r\n\r\n # Update statistics tab and achievements plugin\r\n if hasattr(self.logic, 'track_rock_thrown'):\r\n self.logic.track_rock_thrown()\r\n \r\n # Add with importance (2) and positive formatting\r\n self.squid.memory_manager.add_short_term_memory(\r\n 'play',\r\n memory_details[\"activity\"],\r\n memory_details,\r\n importance=2\r\n )\r\n \r\n # Broadcast to network if multiplayer plugin is available\r\n if hasattr(self, 'multiplayer_plugin') and self.multiplayer_plugin:\r\n try:\r\n self.multiplayer_plugin.throw_rock_network(rock, direction)\r\n except Exception as e:\r\n print(f\"[RockInteraction] Error broadcasting rock throw: {e}\")\r\n \r\n self.throw_animation_timer.start(50)\r\n return True\r\n\r\n\r\n def update_rock_test(self):\r\n \"\"\"Handle the rock test sequence (approach, carry)\"\"\"\r\n if not self.target_rock:\r\n self.cleanup()\r\n return\r\n \r\n if self.rock_test_phase == 0: # Approach phase\r\n rock_center = self.target_rock.sceneBoundingRect().center()\r\n squid_center = self.squid.squid_item.sceneBoundingRect().center()\r\n distance = math.hypot(rock_center.x()-squid_center.x(),\r\n rock_center.y()-squid_center.y())\r\n\r\n if distance < 50: # Close enough to pick up\r\n if self.attach_rock_to_squid(self.target_rock):\r\n self.rock_test_phase = 1 # Move to carry phase\r\n else:\r\n self.cleanup()\r\n else:\r\n self.squid.move_toward_position(rock_center)\r\n \r\n elif self.rock_test_phase == 1: # Carry phase\r\n # Update the carry time\r\n self.rock_carry_time += 0.1 # Since timer fires every 100ms\r\n \r\n # Check if carry duration has elapsed\r\n if self.rock_carry_time >= self.rock_carry_duration:\r\n # Time to make a decision\r\n if random.random() < 0.7: # 70% chance to throw\r\n direction = \"right\" if random.random() < 0.5 else \"left\"\r\n self.throw_rock(direction)\r\n if self.show_message:\r\n self.show_message(\"Squid threw the rock!\")\r\n else: # 30% chance to drop\r\n self.drop_rock()\r\n if self.show_message:\r\n self.show_message(\"Squid dropped the rock\")\r\n \r\n # End the test\r\n self.cleanup()\r\n\r\n def update_throw_animation(self):\r\n \"\"\"Handles the physics update for thrown rocks\"\"\"\r\n if not hasattr(self, 'squid') or not self.squid.carried_rock:\r\n self.throw_animation_timer.stop()\r\n self.cleanup_after_throw()\r\n return\r\n\r\n rock = self.squid.carried_rock\r\n new_x = rock.x() + self.throw_velocity_x\r\n new_y = rock.y() + self.throw_velocity_y\r\n\r\n # Apply gravity (reduced from 0.5 to 0.3 for slower descent)\r\n self.throw_velocity_y += 0.3\r\n\r\n # Apply friction to the horizontal velocity\r\n friction_coefficient = 0.98\r\n self.throw_velocity_x *= friction_coefficient\r\n\r\n # Boundary checks\r\n scene_rect = self.scene.sceneRect()\r\n rock_rect = rock.boundingRect()\r\n\r\n # Left/right boundaries with reduced bounce\r\n if new_x < scene_rect.left():\r\n new_x = scene_rect.left()\r\n self.throw_velocity_x *= -0.2\r\n elif new_x > scene_rect.right() - rock_rect.width():\r\n new_x = scene_rect.right() - rock_rect.width()\r\n self.throw_velocity_x *= -0.2\r\n\r\n # Top boundary - small bounce\r\n if new_y < scene_rect.top():\r\n new_y = scene_rect.top()\r\n self.throw_velocity_y *= -0.2\r\n # Bottom boundary - stop immediately (no sliding)\r\n elif new_y > scene_rect.bottom() - rock_rect.height() - 50:\r\n new_y = scene_rect.bottom() - rock_rect.height() - 50\r\n # Stop all momentum when hitting the bottom\r\n self.throw_velocity_x = 0\r\n self.throw_velocity_y = 0\r\n rock.setPos(new_x, new_y)\r\n self.throw_animation_timer.stop()\r\n self.cleanup_after_throw()\r\n return\r\n\r\n rock.setPos(new_x, new_y)\r\n\r\n # Stop the animation if the rock has slowed down enough\r\n if abs(self.throw_velocity_x) < 0.1 and abs(self.throw_velocity_y) < 0.1:\r\n self.throw_animation_timer.stop()\r\n self.cleanup_after_throw()\r\n\r\n def cleanup(self):\r\n \"\"\"Reset all rock interaction state\"\"\"\r\n self.rock_test_timer.stop()\r\n self.throw_animation_timer.stop()\r\n \r\n self.target_rock = None\r\n self.rock_test_phase = 0\r\n self.rock_carry_time = 0\r\n self.rock_carry_duration = 0\r\n \r\n if hasattr(self.squid, 'is_carrying_rock') and self.squid.is_carrying_rock:\r\n self.squid.is_carrying_rock = False\r\n self.squid.carried_rock = None\r\n\r\n def cleanup_after_throw(self):\r\n if hasattr(self.squid, 'carried_rock') and self.squid.carried_rock:\r\n rock = self.squid.carried_rock\r\n # Set cooldown on the rock so it can't be picked up immediately\r\n cooldown = self.rock_config.get('cooldown_after_throw', 10.0)\r\n rock.throw_cooldown_until = time.time() + cooldown\r\n # Make sure to reset all rock-related states\r\n rock.is_being_carried = False\r\n self.squid.carried_rock = None\r\n \r\n # Reset squid states\r\n self.squid.is_carrying_rock = False\r\n \r\n # Set status based on current stats\r\n if self.squid.happiness > 80:\r\n self.squid.status = \"playful\"\r\n elif self.squid.anxiety > 60:\r\n self.squid.status = \"anxious\"\r\n elif self.squid.curiosity > 60:\r\n self.squid.status = \"curious\"\r\n else:\r\n self.squid.status = \"exploring surroundings\"\r\n \r\n self.throw_velocity_x = 0\r\n self.throw_velocity_y = 0\r\n self.cleanup()\r\n\r\n\r\n def setup_timers(self, interval=100):\r\n \"\"\"Configure timer intervals\"\"\"\r\n self.rock_test_timer.setInterval(interval)\r\n self.throw_animation_timer.setInterval(50)\r\n\r\n # === MULTIPLAYER EXTENSIONS ===\r\n\r\n def handle_remote_rock_throw(self, source_node_id, rock_data):\r\n \"\"\"Handle a rock throw from a remote squid\"\"\"\r\n try:\r\n # Extract rock data\r\n rock_filename = rock_data.get('rock_filename')\r\n direction = rock_data.get('direction')\r\n initial_pos = rock_data.get('initial_pos')\r\n \r\n # Skip if missing required data\r\n if not all([rock_filename, direction, initial_pos]):\r\n print(f\"Incomplete remote rock throw data: {rock_data}\")\r\n return\r\n \r\n # Ensure initial_pos is a dict\r\n if not isinstance(initial_pos, dict):\r\n initial_pos = {'x': initial_pos[0], 'y': initial_pos[1]} if isinstance(initial_pos, (list, tuple)) else {}\r\n \r\n # Find existing rock or create new one\r\n rock = self._find_or_create_remote_rock(rock_filename, initial_pos)\r\n \r\n if rock:\r\n # Mark as a remote rock\r\n rock.is_remote = True\r\n \r\n # Simulate the throw\r\n self._simulate_remote_rock_throw(rock, direction)\r\n \r\n # Check if our squid is in the path of the thrown rock\r\n self._check_rock_collision_path(rock, direction, source_node_id)\r\n \r\n # Show message\r\n if self.show_message:\r\n self.show_message(f\"Remote squid ({source_node_id[-4:]}) threw a rock {direction}!\")\r\n \r\n except Exception as e:\r\n print(f\"Error handling remote rock throw: {e}\")\r\n import traceback\r\n traceback.print_exc()\r\n \r\n def _find_or_create_remote_rock(self, filename, pos):\r\n \"\"\"Find an existing rock or create a new one for remote throws\"\"\"\r\n # Get position values\r\n pos_x = pos.get('x', 0)\r\n pos_y = pos.get('y', 0)\r\n \r\n # Look for existing rocks with same filename near position\r\n for item in self.scene.items():\r\n if (hasattr(item, 'filename') and item.filename == filename and\r\n abs(item.pos().x() - pos_x) < 50 and\r\n abs(item.pos().y() - pos_y) < 50):\r\n return item\r\n \r\n # Create new rock if not found\r\n try:\r\n # Check if file exists or if filename is None\r\n if filename is None or not os.path.exists(filename):\r\n # Try to find a default rock\r\n default_rocks = [\r\n \"images/decoration/rock01.png\",\r\n \"images/decoration/rock02.png\",\r\n \"images/rock.png\"\r\n ]\r\n \r\n # Use first valid file\r\n for rock_file in default_rocks:\r\n if os.path.exists(rock_file):\r\n filename = rock_file\r\n break\r\n else:\r\n print(f\"Could not find a valid rock image file\")\r\n return None\r\n \r\n rock_pixmap = QtGui.QPixmap(filename)\r\n \r\n # Create ResizablePixmapItem if available\r\n ResizablePixmapItem = None\r\n if hasattr(self.logic, 'user_interface') and hasattr(self.logic.user_interface, 'ResizablePixmapItem'):\r\n ResizablePixmapItem = self.logic.user_interface.ResizablePixmapItem\r\n \r\n if ResizablePixmapItem:\r\n rock = ResizablePixmapItem(rock_pixmap, filename)\r\n else:\r\n rock = QtWidgets.QGraphicsPixmapItem(rock_pixmap)\r\n rock.filename = filename\r\n \r\n rock.setPos(pos_x, pos_y)\r\n rock.setOpacity(0.7) # Make it semi-transparent\r\n rock.can_be_picked_up = True\r\n self.scene.addItem(rock)\r\n \r\n # Mark as remote rock\r\n rock.is_remote = True\r\n \r\n # Apply red tint to show it's from another instance\r\n # Check if multiplayer plugin is available\r\n if hasattr(self.logic, 'multiplayer_plugin') and self.logic.multiplayer_plugin:\r\n self.logic.multiplayer_plugin.apply_foreign_object_tint(rock)\r\n else:\r\n # Apply tint directly if plugin reference isn't available\r\n color_effect = QtWidgets.QGraphicsColorizeEffect()\r\n color_effect.setColor(QtGui.QColor(255, 100, 100))\r\n color_effect.setStrength(0.25)\r\n rock.setGraphicsEffect(color_effect)\r\n rock.is_foreign = True\r\n \r\n return rock\r\n except Exception as e:\r\n print(f\"Error creating remote rock: {e}\")\r\n return None\r\n \r\n def _simulate_remote_rock_throw(self, rock, direction):\r\n \"\"\"Simulate a remote rock throw with simplified physics\"\"\"\r\n # Create timer for animation\r\n throw_timer = QtCore.QTimer()\r\n throw_counter = [0] # Use list for mutable counter\r\n \r\n # Initial velocity based on direction\r\n velocity_x = 12 * (1 if direction == \"right\" else -1)\r\n velocity_y = -10 # Initial upward\r\n \r\n def update_position():\r\n nonlocal velocity_x, velocity_y\r\n \r\n # Update position\r\n current_pos = rock.pos()\r\n new_x = current_pos.x() + velocity_x\r\n new_y = current_pos.y() + velocity_y\r\n \r\n # Apply gravity\r\n velocity_y += 0.4\r\n \r\n # Check boundaries\r\n scene_rect = self.scene.sceneRect()\r\n rock_rect = rock.boundingRect()\r\n \r\n # Left/right boundaries\r\n if new_x < scene_rect.left():\r\n new_x = scene_rect.left()\r\n velocity_x *= -0.5\r\n elif new_x > scene_rect.right() - rock_rect.width():\r\n new_x = scene_rect.right() - rock_rect.width()\r\n velocity_x *= -0.5\r\n \r\n # Top/bottom boundaries\r\n if new_y < scene_rect.top():\r\n new_y = scene_rect.top()\r\n velocity_y *= -0.5\r\n elif new_y > scene_rect.bottom() - rock_rect.height():\r\n new_y = scene_rect.bottom() - rock_rect.height()\r\n throw_timer.stop()\r\n return\r\n \r\n # Update position\r\n rock.setPos(new_x, new_y)\r\n \r\n # Stop after some time\r\n throw_counter[0] += 1\r\n if throw_counter[0] > 100: # Stop after 100 updates\r\n throw_timer.stop()\r\n \r\n # Start animation\r\n throw_timer.timeout.connect(update_position)\r\n throw_timer.start(50) # 50ms intervals\r\n \r\n def _check_rock_collision_path(self, rock, direction, source_node_id):\r\n \"\"\"Check if our squid is in the path of a thrown rock\"\"\"\r\n # Skip if squid isn't initialized\r\n if not self.squid:\r\n return\r\n \r\n # Get rock and squid positions\r\n rock_pos = rock.pos()\r\n squid_rect = self.squid.squid_item.sceneBoundingRect()\r\n squid_center = squid_rect.center()\r\n \r\n # Calculate relative positions\r\n dx = squid_center.x() - rock_pos.x()\r\n dy = squid_center.y() - rock_pos.y()\r\n distance = math.sqrt(dx*dx + dy*dy)\r\n \r\n # Check if squid is in the direction of throw\r\n in_path = (direction == \"right\" and dx > 0) or (direction == \"left\" and dx < 0)\r\n \r\n # If squid is close enough and in the throw path, react\r\n if distance < 200 and in_path:\r\n if hasattr(self.squid, 'react_to_rock_throw'):\r\n # Use the specialized reaction method\r\n self.squid.react_to_rock_throw(source_node_id, True)\r\n elif hasattr(self.logic, 'startle_squid'):\r\n # Fallback to generic startle\r\n self.logic.startle_squid(source=\"incoming_rock\")\r\n \r\n # Add memory\r\n if hasattr(self.squid, 'memory_manager'):\r\n self.squid.memory_manager.add_short_term_memory(\r\n 'observation', 'rock_thrown',\r\n f\"Startled by rock thrown by remote squid ({source_node_id[-4:]})\"\r\n )\r\n\r\n\r\n\r\n"
},
{
"path": "src/interactions2.py",
"content": "# POOP INTERACTIONS\r\n\r\nimport math\r\nimport time\r\nimport random\r\nimport os\r\nfrom PyQt5 import QtCore, QtWidgets, QtGui\r\n\r\nclass PoopInteractionManager:\r\n def __init__(self, squid, logic, scene, message_callback, config_manager):\r\n self.squid = squid\r\n self.logic = logic\r\n self.scene = scene\r\n self.show_message = message_callback\r\n self.config_manager = config_manager\r\n self.poop_config = config_manager.get_poop_config()\r\n\r\n # Poop interaction state\r\n self.target_poop = None\r\n self.poop_test_phase = 0 # 0=approach, 1=carry, 2=throw\r\n self.poop_carry_time = 0\r\n self.poop_carry_duration = 0\r\n \r\n # Initialize timers\r\n self.poop_test_timer = QtCore.QTimer()\r\n self.throw_animation_timer = QtCore.QTimer()\r\n \r\n # Connect timers\r\n self.poop_test_timer.timeout.connect(self.update_poop_test)\r\n self.throw_animation_timer.timeout.connect(self.update_throw_animation)\r\n \r\n # Initialize throw velocity variables\r\n self.throw_velocity_x = 0\r\n self.throw_velocity_y = 0\r\n\r\n # Add multiplayer support\r\n self.multiplayer_plugin = None\r\n self.setup_multiplayer_integration()\r\n\r\n def setup_multiplayer_integration(self):\r\n \"\"\"Set up hooks for multiplayer integration\"\"\"\r\n if not hasattr(self.logic, 'plugin_manager'):\r\n return False\r\n \r\n # Get multiplayer plugin\r\n multiplayer_plugin = None\r\n for plugin_name, plugin_data in self.logic.plugin_manager.plugins.items():\r\n if plugin_name == \"multiplayer_plugin\":\r\n # Get the actual plugin instance\r\n multiplayer_plugin = plugin_data.get('instance')\r\n break\r\n \r\n if multiplayer_plugin:\r\n # Store reference\r\n self.multiplayer_plugin = multiplayer_plugin\r\n \r\n print(\"[PoopInteraction] Successfully integrated with multiplayer plugin\")\r\n return True\r\n \r\n return False\r\n\r\n def is_valid_poop(self, item):\r\n \"\"\"Check if item is a valid poop\"\"\"\r\n if not isinstance(item, QtWidgets.QGraphicsPixmapItem):\r\n return False\r\n return (hasattr(item, 'category') and item.category == 'poop') or \\\r\n (hasattr(item, 'filename') and 'poop' in item.filename.lower())\r\n\r\n def can_pick_up_poop(self, poop):\r\n \"\"\"Check if squid can pick up this poop\"\"\"\r\n if not self.is_valid_poop(poop):\r\n return False\r\n if hasattr(poop, 'is_being_carried') and poop.is_being_carried:\r\n return False\r\n \r\n # Check if poop is in cooldown after being thrown\r\n if hasattr(poop, 'throw_cooldown_until'):\r\n if time.time() < poop.throw_cooldown_until:\r\n return False \r\n return True\r\n\r\n def attach_poop_to_squid(self, poop):\r\n \"\"\"Visually attach poop to squid at tentacle position\"\"\"\r\n poop.setParentItem(self.squid.squid_item)\r\n \r\n # Set random hold duration between 3-9 seconds\r\n self.squid.poop_hold_duration = random.uniform(3.0, 9.0)\r\n self.squid.poop_hold_start_time = time.time()\r\n self.squid.poop_decision_made = False\r\n \r\n offset = -50 # Both vertical and horizontal offset\r\n \r\n # Calculate position based on squid direction\r\n if self.squid.squid_direction == \"right\":\r\n # Position poop near right tentacles\r\n poop.setPos(self.squid.squid_width - 40 + offset, \r\n self.squid.squid_height - 30 + offset)\r\n elif self.squid.squid_direction == \"left\":\r\n # Position poop near left tentacles\r\n poop.setPos(10 + offset, \r\n self.squid.squid_height - 30 + offset)\r\n elif self.squid.squid_direction == \"up\":\r\n # Position poop near upper tentacles\r\n poop.setPos(self.squid.squid_width//2 - 15 + offset, \r\n self.squid.squid_height - 40 + offset)\r\n else: # down/default\r\n poop.setPos(self.squid.squid_width//2 - 15 + offset, \r\n self.squid.squid_height - 20 + offset)\r\n \r\n poop.is_being_carried = True\r\n self.squid.is_carrying_poop = True\r\n self.squid.carried_poop = poop\r\n poop.setZValue(self.squid.squid_item.zValue() + 1)\r\n \r\n # Scale poop to appropriate size\r\n poop.setScale(1.0)\r\n \r\n return True\r\n \r\n def check_poop_hold_time(self):\r\n \"\"\"Check if holding time elapsed and make decision\"\"\"\r\n if not hasattr(self.squid, 'carrying_poop') or not self.squid.carrying_poop or not hasattr(self.squid, 'poop_decision_made') or self.squid.poop_decision_made:\r\n return\r\n \r\n current_time = time.time()\r\n if current_time - self.squid.poop_hold_start_time >= self.squid.poop_hold_duration:\r\n self.squid.poop_decision_made = True\r\n self.decide_poop_action()\r\n\r\n def decide_poop_action(self):\r\n \"\"\"Randomly decide to throw or drop the poop\"\"\"\r\n if random.random() < 0.7: # 70% chance to throw\r\n direction = \"right\" if random.random() < 0.5 else \"left\"\r\n self.throw_poop(direction)\r\n if self.show_message:\r\n self.show_message(\"Squid threw the poop!\")\r\n else: # 30% chance to drop\r\n self.drop_poop()\r\n if self.show_message:\r\n self.show_message(\"Squid dropped the poop\")\r\n\r\n def drop_poop(self):\r\n \"\"\"Gently place the poop below the squid\"\"\"\r\n if not hasattr(self.squid, 'carrying_poop') or not self.squid.carrying_poop or not hasattr(self.squid, 'carried_poop') or not self.squid.carried_poop:\r\n return\r\n \r\n poop = self.squid.carried_poop\r\n poop.setParentItem(None)\r\n poop.setPos(\r\n self.squid.squid_x + self.squid.squid_width//2 - poop.boundingRect().width()//2,\r\n self.squid.squid_y + self.squid.squid_height + 10\r\n )\r\n self.squid.is_carrying_poop = False\r\n self.squid.carried_poop = None\r\n\r\n def start_poop_test(self, poop=None):\r\n \"\"\"Start test with guaranteed clean state and random carry duration\"\"\"\r\n self.cleanup() # Reset everything first\r\n \r\n if poop is None:\r\n poops = [item for item in self.scene.items() \r\n if self.is_valid_poop(item) and item.isVisible()]\r\n if not poops:\r\n if self.show_message:\r\n self.show_message(\"No available poops!\")\r\n return False\r\n poop = min(poops, key=lambda p: math.hypot(\r\n p.sceneBoundingRect().center().x() - self.squid.squid_x,\r\n p.sceneBoundingRect().center().y() - self.squid.squid_y\r\n ))\r\n \r\n self.target_poop = poop\r\n self.poop_test_phase = 0\r\n # Use the config values for duration\r\n self.poop_carry_duration = random.uniform(\r\n self.poop_config['min_carry_duration'],\r\n self.poop_config['max_carry_duration']\r\n )\r\n self.poop_carry_time = 0 # Reset carry timer\r\n self.poop_test_timer.start(100) # 100ms updates\r\n return True\r\n\r\n def throw_poop(self, direction=\"right\"):\r\n \"\"\"Initiates a poop throw with memory formation\"\"\"\r\n # Prevent multiple throws\r\n if self.throw_animation_timer.isActive():\r\n return False\r\n \r\n if not hasattr(self.squid, 'carried_poop') or not self.squid.carried_poop:\r\n return False\r\n \r\n config = self.poop_config\r\n poop = self.squid.carried_poop\r\n \r\n # Set squid status\r\n if hasattr(self.squid, 'status'):\r\n self.squid.status = \"throwing poop\"\r\n \r\n # Detach from squid and reset parent to scene\r\n poop.setParentItem(None)\r\n \r\n # Calculate throw vectors\r\n throw_power = 12\r\n angle = math.radians(30 if direction == \"right\" else 150)\r\n self.throw_velocity_x = throw_power * math.cos(angle)\r\n self.throw_velocity_y = -throw_power * math.sin(angle) # Negative for upward\r\n \r\n # Set position to squid's center in scene coordinates\r\n squid_rect = self.squid.squid_item.sceneBoundingRect()\r\n poop_rect = poop.boundingRect()\r\n poop.setPos(\r\n squid_rect.center().x() - poop_rect.width()/2,\r\n squid_rect.center().y() - poop_rect.height()/2\r\n )\r\n \r\n poop.setVisible(True)\r\n \r\n # Apply stat changes\r\n self.squid.happiness = min(100, self.squid.happiness - 5)\r\n self.squid.satisfaction = min(100, self.squid.satisfaction - 3)\r\n self.squid.anxiety = min(100, self.squid.anxiety + 10)\r\n self.logic.statistics_window.award(-75)\r\n \r\n # Simplified negative memory\r\n memory_details = {\r\n \"activity\": \"poop_throwing\",\r\n \"item\": getattr(poop, 'filename', '') or '',\r\n \"effects\": {\r\n \"happiness\": -5,\r\n \"satisfaction\": -3,\r\n \"anxiety\": 10\r\n },\r\n \"description\": \"Threw a poop around!\",\r\n \"is_positive\": False\r\n }\r\n\r\n # Update poops thrown counter\r\n if hasattr(self.squid, 'statistics'):\r\n self.squid.statistics.total_poops_thrown += 1\r\n \r\n # Add with moderate importance\r\n self.squid.memory_manager.add_short_term_memory(\r\n 'play',\r\n 'poop_throwing',\r\n memory_details,\r\n importance=5\r\n )\r\n \r\n # Broadcast to network if multiplayer plugin is available\r\n if hasattr(self, 'multiplayer_plugin') and self.multiplayer_plugin:\r\n try:\r\n self.multiplayer_plugin.throw_poop_network(poop, direction)\r\n except Exception as e:\r\n print(f\"[PoopInteraction] Error broadcasting poop throw: {e}\")\r\n \r\n self.throw_animation_timer.start(50)\r\n return True\r\n\r\n def update_poop_test(self):\r\n \"\"\"Handle the poop test sequence (approach, carry)\"\"\"\r\n if not self.target_poop:\r\n self.cleanup()\r\n return\r\n \r\n # Let the Squid class handle the timing and decision making\r\n if self.poop_test_phase == 0: # Approach phase\r\n poop_center = self.target_poop.sceneBoundingRect().center()\r\n squid_center = self.squid.squid_item.sceneBoundingRect().center()\r\n distance = math.hypot(poop_center.x()-squid_center.x(),\r\n poop_center.y()-squid_center.y())\r\n\r\n if distance < 50: # Close enough to pick up\r\n if self.attach_poop_to_squid(self.target_poop):\r\n self.poop_test_phase = 1 # Move to carry phase\r\n else:\r\n self.cleanup()\r\n else:\r\n self.squid.move_toward_position(poop_center)\r\n\r\n def update_throw_animation(self):\r\n \"\"\"Handles the physics update for thrown poops\"\"\"\r\n if not hasattr(self.squid, 'carried_poop') or not self.squid.carried_poop:\r\n self.throw_animation_timer.stop()\r\n self.cleanup_after_throw()\r\n return\r\n \r\n poop = self.squid.carried_poop\r\n new_x = poop.x() + self.throw_velocity_x\r\n new_y = poop.y() + self.throw_velocity_y\r\n \r\n # Apply gravity\r\n self.throw_velocity_y += 0.3\r\n \r\n # Boundary checks\r\n scene_rect = self.scene.sceneRect()\r\n poop_rect = poop.boundingRect()\r\n \r\n # Left/right boundaries with reduced bounce\r\n if new_x < scene_rect.left():\r\n new_x = scene_rect.left()\r\n self.throw_velocity_x *= -0.5\r\n elif new_x > scene_rect.right() - poop_rect.width():\r\n new_x = scene_rect.right() - poop_rect.width()\r\n self.throw_velocity_x *= -0.5\r\n \r\n # Top/bottom boundaries\r\n if new_y < scene_rect.top():\r\n new_y = scene_rect.top()\r\n self.throw_velocity_y *= -0.5\r\n elif new_y > scene_rect.bottom() - poop_rect.height():\r\n new_y = scene_rect.bottom() - poop_rect.height()\r\n self.throw_animation_timer.stop()\r\n self.cleanup_after_throw()\r\n return # Stop updates when hitting bottom\r\n \r\n poop.setPos(new_x, new_y)\r\n\r\n def cleanup(self):\r\n \"\"\"Reset all poop interaction state\"\"\"\r\n self.poop_test_timer.stop()\r\n self.throw_animation_timer.stop()\r\n \r\n self.target_poop = None\r\n self.poop_test_phase = 0\r\n self.poop_carry_time = 0\r\n self.poop_carry_duration = 0\r\n \r\n if hasattr(self.squid, 'is_carrying_poop') and self.squid.is_carrying_poop:\r\n self.squid.is_carrying_poop = False\r\n self.squid.carried_poop = None\r\n\r\n def cleanup_after_throw(self):\r\n if hasattr(self.squid, 'carried_poop') and self.squid.carried_poop:\r\n poop = self.squid.carried_poop\r\n \r\n # --- ADDED COOLDOWN APPLICATION ---\r\n # Set cooldown on the poop so it can't be picked up immediately\r\n cooldown = self.poop_config.get('cooldown_after_throw', 10.0)\r\n poop.throw_cooldown_until = time.time() + cooldown\r\n # ----------------------------------\r\n\r\n # Make sure to reset all poop-related states\r\n poop.is_being_carried = False\r\n self.squid.carried_poop = None\r\n \r\n # Reset squid states\r\n self.squid.is_carrying_poop = False\r\n \r\n # Reset status to default if it was set to \"throwing_poop\"\r\n if hasattr(self.squid, 'status') and self.squid.status == \"throwing_poop\":\r\n self.squid.status = \"roaming\"\r\n \r\n self.throw_velocity_x = 0\r\n self.throw_velocity_y = 0\r\n self.cleanup()\r\n\r\n def setup_timers(self, interval=100):\r\n \"\"\"Configure timer intervals\"\"\"\r\n self.poop_test_timer.setInterval(interval)\r\n self.throw_animation_timer.setInterval(50)\r\n\r\n\r\n\r\n"
},
{
"path": "src/laboratory.py",
"content": "# 2.4.5.1 | rev3_dec25\r\n# --------------------------------------------------------------\r\n# NEURON LABORATORY\r\n# --------------------------------------------------------------\r\n\r\nfrom PyQt5.QtCore import Qt, QTimer, pyqtSignal\r\nfrom PyQt5 import QtCore\r\nfrom PyQt5.QtGui import (\r\n QFont, QPixmap, QColor, QPainter, QBrush, QPen, QDoubleValidator\r\n)\r\nfrom PyQt5.QtWidgets import (\r\n QApplication, QCheckBox, QComboBox, QDialog, QFormLayout, QFrame,\r\n QGridLayout, QGroupBox, QHBoxLayout, QLabel, QLineEdit, QProgressBar,\r\n QPushButton, QScrollArea, QSlider, QSpinBox, QTabWidget, QTextEdit,\r\n QVBoxLayout, QWidget, QMessageBox, QTableWidget, QTableWidgetItem,\r\n QHeaderView, QSplitter, QToolButton\r\n)\r\n\r\nimport json, math, time, random, datetime as dt\r\nfrom .localisation import loc # Import localisation\r\n\r\n# ------------------------------------------------------------------\r\n# Helper: coloured connection badge\r\n# ------------------------------------------------------------------\r\ndef badge(text, color=\"#333\", bg=\"#eee\"):\r\n return f\"\"\"{text}\"\"\"\r\n\r\n\r\n# ------------------------------------------------------------------\r\n# Main Laboratory Dialog\r\n# ------------------------------------------------------------------\r\nclass NeuronLaboratory(QDialog):\r\n def __init__(self, brain_widget, parent=None):\r\n super().__init__(parent)\r\n self.bw = brain_widget\r\n self.setWindowTitle(loc(\"lab_title\", \"🧠 Neuron Laboratory\"))\r\n self.resize(900, 750)\r\n self.setWindowFlag(Qt.WindowMinMaxButtonsHint)\r\n\r\n # ---- top toolbar ----\r\n bar = QHBoxLayout()\r\n self.live_check = QCheckBox(loc(\"lab_live_refresh\", \"Live refresh\"))\r\n self.live_check.setChecked(True)\r\n self.live_check.toggled.connect(self._toggle_live)\r\n bar.addWidget(self.live_check)\r\n\r\n bar.addStretch()\r\n self.lock_check = QCheckBox(loc(\"lab_unlock_editing\", \"🔓 Unlock editing\"))\r\n self.lock_check.toggled.connect(self._unlock_editing)\r\n bar.addWidget(self.lock_check)\r\n\r\n # ---- main notebook ----\r\n self.tabs = QTabWidget()\r\n \r\n # --- Apply Card-Based Styling ---\r\n self.tabs.setStyleSheet(\"\"\"\r\n QTabWidget::pane {\r\n border: 2px solid #e1e5eb;\r\n border-radius: 12px;\r\n background-color: #f8f9fa;\r\n }\r\n QTabBar::tab {\r\n background: #f8f9fa;\r\n border: 1px solid #e1e5eb;\r\n padding: 10px 20px;\r\n margin-right: 5px;\r\n border-top-left-radius: 8px;\r\n border-top-right-radius: 8px;\r\n font-size: 14px;\r\n color: #2c3e50;\r\n }\r\n QTabBar::tab:selected {\r\n background: #ffffff;\r\n border-bottom: none;\r\n font-weight: 600;\r\n }\r\n /* Style all QGroupBoxes to appear as modern cards */\r\n QGroupBox { \r\n background-color: #ffffff;\r\n border: 1px solid #dee2e6;\r\n border-radius: 10px;\r\n padding-top: 20px; \r\n margin-top: 10px; \r\n }\r\n QGroupBox::title {\r\n subcontrol-origin: margin;\r\n subcontrol-position: top left;\r\n padding: 0 3px;\r\n left: 10px;\r\n color: #1976d2; /* Use a primary color for card titles */\r\n font-weight: bold;\r\n font-size: 12pt;\r\n }\r\n \"\"\")\r\n # ------------------------------------------------------------------\r\n \r\n # Initialize forced values and timer for absolute override\r\n self.forced_neurons = {} # Dictionary to store forced values: name -> value\r\n self._force_timer = QTimer(self)\r\n self._force_timer.timeout.connect(self._apply_forced_values)\r\n self._force_timer.start(100) # Check 10 times per second for smooth override\r\n \r\n self._build_overview_tab()\r\n self._build_inspector_tab()\r\n self._build_edit_tab()\r\n\r\n # ---- footer ----\r\n self.status_lbl = QLabel(loc(\"lab_status_ready\", \"Ready\"))\r\n self.status_lbl.setStyleSheet(\"color:#888;font-size:9pt;\")\r\n\r\n lay = QVBoxLayout(self)\r\n lay.addLayout(bar)\r\n lay.addWidget(self.tabs)\r\n lay.addWidget(self.status_lbl)\r\n\r\n # ---- refresh timer ----\r\n self.timer = QTimer(self)\r\n self.timer.timeout.connect(self._refresh)\r\n self.timer.start(1000) # 1 Hz\r\n\r\n self._refresh() # first paint\r\n\r\n # ---- per-neuron manual lock table ----\r\n self.locked_neurons = {} # name -> {locked: bool, slider, spin, button}\r\n\r\n # ================================================================\r\n # Construction helpers\r\n # ================================================================\r\n def _build_overview_tab(self):\r\n self.ov_scroll = QScrollArea()\r\n self.ov_widget = QWidget()\r\n self.ov_grid = QGridLayout(self.ov_widget)\r\n self.ov_scroll.setWidget(self.ov_widget)\r\n self.ov_scroll.setWidgetResizable(True)\r\n self.tabs.addTab(self.ov_scroll, loc(\"lab_tab_overview\", \"📊 Live Overview\"))\r\n\r\n def _build_inspector_tab(self):\r\n w = QWidget()\r\n lay = QVBoxLayout(w)\r\n self.pick_neuron = QComboBox()\r\n self.pick_neuron.currentTextChanged.connect(self._inspect_neuron)\r\n lay.addWidget(QLabel(loc(\"lab_pick_neuron\", \"Pick a neuron to inspect:\")))\r\n self.pick_neuron.setStyleSheet(\"\"\"\r\n QComboBox { font-size: 18px; min-height: 36px; padding: 4px; }\r\n \"\"\")\r\n lay.addWidget(self.pick_neuron)\r\n self.inspector_scroll = QScrollArea()\r\n self.inspector_cards = QWidget()\r\n self.inspector_lay = QVBoxLayout(self.inspector_cards)\r\n self.inspector_scroll.setWidget(self.inspector_cards)\r\n self.inspector_scroll.setWidgetResizable(True)\r\n lay.addWidget(self.inspector_scroll, 1)\r\n self.tabs.addTab(w, loc(\"lab_tab_inspector\", \"🔍 Deep Inspector\"))\r\n\r\n def _build_edit_tab(self):\r\n w = QWidget()\r\n lay = QVBoxLayout(w)\r\n warn = QLabel(loc(\"lab_edit_locked_msg\", \"⚠️ Editing is locked – check 'Unlock editing' in the toolbar.\"))\r\n warn.setStyleSheet(\"color:#d9534f;font-weight:bold;\")\r\n lay.addWidget(warn)\r\n self.edit_warn = warn\r\n self.edit_scroll = QScrollArea()\r\n self.edit_cards = QWidget()\r\n self.edit_lay = QVBoxLayout(self.edit_cards)\r\n self.edit_scroll.setWidget(self.edit_cards)\r\n self.edit_scroll.setWidgetResizable(True)\r\n lay.addWidget(self.edit_scroll, 1)\r\n self.tabs.addTab(w, loc(\"lab_tab_edit\", \"🔧 Edit Sandbox\"))\r\n\r\n # ================================================================\r\n # Live refresh\r\n # ================================================================\r\n def _refresh(self):\r\n if not self.live_check.isChecked():\r\n return\r\n current = self.pick_neuron.currentText()\r\n self.pick_neuron.clear()\r\n \r\n # Translate neuron names if needed, or use raw keys? \r\n # Usually keys are used internally, but displayed names might be localized.\r\n # For this tool, we usually show keys, but let's stick to keys for consistency with other tools.\r\n self.pick_neuron.addItems(sorted(self.bw.neuron_positions.keys()))\r\n \r\n idx = self.pick_neuron.findText(current)\r\n if idx >= 0:\r\n self.pick_neuron.setCurrentIndex(idx)\r\n self._paint_overview()\r\n self._inspect_neuron(self.pick_neuron.currentText())\r\n self._paint_edit()\r\n\r\n def select_neuron_by_name(self, neuron_name: str):\r\n \"\"\"\r\n Selects the specified neuron in the pick_neuron dropdown\r\n and refreshes the Inspector tab content.\r\n \"\"\"\r\n if not hasattr(self, 'pick_neuron'):\r\n return\r\n \r\n # 1. Select the neuron in the dropdown\r\n idx = self.pick_neuron.findText(neuron_name)\r\n if idx >= 0:\r\n self.pick_neuron.blockSignals(True)\r\n self.pick_neuron.setCurrentIndex(idx)\r\n self.pick_neuron.blockSignals(False)\r\n \r\n # 2. Force the inspection of the newly selected neuron\r\n self._inspect_neuron(neuron_name)\r\n \r\n # 3. Switch to the \"Deep Inspector\" tab\r\n self.tabs.setCurrentIndex(1)\r\n \r\n # 4. Update the view to reflect the change\r\n self.update()\r\n\r\n # ================================================================\r\n # Overview / Inspector / Edit\r\n # ================================================================\r\n def _paint_overview(self):\r\n while self.ov_grid.count():\r\n item = self.ov_grid.takeAt(0)\r\n if item and item.widget():\r\n item.widget().deleteLater()\r\n nd = getattr(self.bw, 'neurogenesis_data', {})\r\n cfg = getattr(self.bw, 'neurogenesis_config', {})\r\n \r\n # Card 1: Counters\r\n card1 = QGroupBox(loc(\"lab_ov_counters\", \"Counter progress\"))\r\n g1 = QGridLayout(card1)\r\n # We localize the counter labels here using existing keys or raw if simple\r\n metrics = [(loc(\"novelty\", \"Novelty\"), nd.get('novelty_counter', 0), cfg.get('novelty_threshold', 3)),\r\n (loc(\"stress\", \"Stress\"), nd.get('stress_counter', 0), cfg.get('stress_threshold', .7)),\r\n (loc(\"reward\", \"Reward\"), nd.get('reward_counter', 0), cfg.get('reward_threshold', .6))]\r\n for row, (name, cur, thr) in enumerate(metrics):\r\n pct = min(100, (cur / thr) * 100) if thr else 0\r\n bar = self._progress_bar(pct)\r\n g1.addWidget(QLabel(f\"{name} {cur:.2f}/{thr}\"), row, 0)\r\n g1.addWidget(bar, row, 1)\r\n self.ov_grid.addWidget(card1, 0, 0)\r\n \r\n # Card 2: Newest neurons\r\n card2 = QGroupBox(loc(\"lab_ov_newest\", \"Newest neurogenesis neurons\"))\r\n v2 = QVBoxLayout(card2)\r\n details = nd.get('new_neurons_details', {})\r\n for name, info in sorted(details.items(), key=lambda x: x[1].get('created_at', 0), reverse=True)[:5]:\r\n age = int(time.time() - info.get('created_at', 0))\r\n ago_text = loc(\"lab_ago\", \"{seconds}s ago\", seconds=age)\r\n v2.addWidget(QLabel(f\"{name} – {info.get('trigger_type','?')} – {ago_text}\"))\r\n if not details:\r\n v2.addWidget(QLabel(loc(\"lab_none_yet\", \"None yet\")))\r\n self.ov_grid.addWidget(card2, 0, 1)\r\n \r\n # Card 3: Limits\r\n card3 = QGroupBox(loc(\"lab_ov_limits\", \"Limits & pruning\"))\r\n v3 = QVBoxLayout(card3)\r\n current = len(self.bw.neuron_positions) - len(self.bw.excluded_neurons)\r\n max_n = cfg.get('max_neurons', 32)\r\n v3.addWidget(self._progress_widget(loc(\"neurons\", \"Neurons\"), current, max_n))\r\n pruning_text = loc(\"lab_pruning_enabled\", \"Pruning enabled:\")\r\n v3.addWidget(QLabel(f\"{pruning_text} {self.bw.pruning_enabled}\"))\r\n self.ov_grid.addWidget(card3, 1, 0)\r\n \r\n # Card 4: Quick Actions\r\n card4 = QGroupBox(loc(\"lab_ov_actions\", \"Quick actions\"))\r\n h = QHBoxLayout(card4)\r\n btn = QPushButton(loc(\"lab_force_hebbian\", \"Force Hebbian cycle\"))\r\n btn.clicked.connect(self.bw.perform_hebbian_learning)\r\n h.addWidget(btn)\r\n self.ov_grid.addWidget(card4, 1, 1)\r\n self.ov_grid.setRowStretch(2, 1)\r\n\r\n def _inspect_neuron(self, name):\r\n if not name:\r\n return\r\n while self.inspector_lay.count():\r\n item = self.inspector_lay.takeAt(0)\r\n if item and item.widget():\r\n item.widget().deleteLater()\r\n nd = getattr(self.bw, 'neurogenesis_data', {})\r\n details = nd.get('new_neurons_details', {}).get(name)\r\n\r\n # Card: Connector Special Details (If applicable)\r\n if details and details.get('trigger_type') == 'connector':\r\n card_special = QGroupBox(loc(\"lab_connector_title\", \"Network Bridge Protocol\"))\r\n v_special = QVBoxLayout(card_special)\r\n \r\n info_text = (\r\n \"Status:Active Bridge \"\r\n \"This neuron was synthesized to rescue an isolated node.
\"\r\n \"Wiring Topology: \"\r\n \"• Primary: Connection to the Orphan \"\r\n \"• Anchor: Connection to Closest Neighbor \"\r\n \"• Diversity: Random connection to Network\"\r\n )\r\n lbl_special = QLabel(info_text)\r\n lbl_special.setTextFormat(QtCore.Qt.RichText)\r\n v_special.addWidget(lbl_special)\r\n self.inspector_lay.addWidget(card_special)\r\n\r\n # Card: Connections\r\n card2 = QGroupBox(loc(\"lab_connections_title\", \"Connections (excitatory vs inhibitory)\"))\r\n v2 = QVBoxLayout(card2)\r\n \r\n h_partner = loc(\"lab_header_partner\", \"Partner\")\r\n h_weight = loc(\"lab_header_weight\", \"Weight\")\r\n h_type = loc(\"lab_header_type\", \"Type\")\r\n h_inf = loc(\"lab_header_inf\", \"Influence\")\r\n \r\n html = \"
\"\r\n html += f\"
{h_partner}
{h_weight}
{h_type}
{h_inf}
\"\r\n \r\n t_exc = loc(\"lab_type_excitatory\", \"Excitatory\")\r\n t_inh = loc(\"lab_type_inhibitory\", \"Inhibitory\")\r\n \r\n for (src, dst), w in self.bw.weights.items():\r\n if src == name:\r\n typ = t_exc if w > 0 else t_inh\r\n col = \"#d4ffd4\" if w > 0 else \"#ffd4d4\"\r\n html += f\"
\"\r\n html += f\"
{dst}
{w:+.3f}
{badge(typ,'#000',col)}
\"\r\n html += f\"
{self._influence_badge(w)}
\"\r\n for (src, dst), w in self.bw.weights.items():\r\n if dst == name:\r\n typ = t_exc if w > 0 else t_inh\r\n col = \"#d4ffd4\" if w > 0 else \"#ffd4d4\"\r\n html += f\"
![\"AI\"](\"https://img.shields.io/badge/AI-Neural_Network-9C27B0?style=flat&logo=mindmeister&logoColor=white\"){kind=icon}
\n ![\"GPL-2.0\"](\"https://img.shields.io/badge/License-GPL_v2-blue.svg?style=flat\"){kind=icon}
\n ![\"Translations\"](\"https://img.shields.io/badge/Translations-7-228B22?style=flat&logo=google-translate&logoColor=white&labelColor=333333\"){kind=icon}
\n ![\"Buy](\"https://img.shields.io/badge/Buy_Me_A_Coffee-FFDD00?style=flat&logo=buy-me-a-coffee&logoColor=black\"){kind=icon}
\n![\"Buy](\"https://cdn.buymeacoffee.com/buttons/default-orange.png\")
"
},
{
"path": "Docs/getting-started/Example-Squids.md",
"content": "```\nThe example_squids folder contains saved brains that have already accumulated some experiences:\n```\n-------------------------\n\n\n### [b071f720_593e_471f_8412_8ee84172a1b0.zip](https://github.com/ViciousSquid/Dosidicus/blob/2.6.0.0_latest_release/example_squids/b071f720_593e_471f_8412_8ee84172a1b0.zip) \n\n#### Squid name: Miroslav | Age: 5 | Number of neurons: 12\n\n* Young squid with default brain type (7 core neurons)\n* ${\\color{red}stress}$ neurons have developed in response to being extremely hungry in the past\n* ${\\color{yellow}novelty}$ neurons have developed - positive experiences related to investigation/exploration\n* many connections (111!) - strong brain, highly responsive, quick to learn (high plasticity)\n* `novelty_object_investigation` has extremely high multiplier of 14 suggesting episodes of manic excitement\n\n\n![](\"images/string.png\"\n)
\n 
\"\n f\"{formatted_memory}\"\n f\"