Feed aggregator

⚠️ PREREQUISITE: NodeCanvas by ParadoxNotion (sold separately) This asset generates NodeCanvas Behavior Trees and will not function without NodeCanvas installed. 

 KEY FEATURES 

- Natural Language Input — Describe behaviors in plain English 

- NodeCanvas Integration — Creates native NodeCanvas BT assets 

- Local AI Processing — Uses Ollama for offline, private inference 

- No Recurring Costs — One-time purchase, no API fees 

- Fast Generation — 3-20 seconds depending on complexity 

- Automatic Blackboard Setup — Generates variables with correct types 

- Production-Ready Output — Generates Selectors, Sequences, Decorators, Actions  

SUPPORTED NODECANVAS NODES 

- Composites: Selector, Sequencer, Parallel 

- Actions: MoveTo, Wait, RotateTowards, and custom actions 

- Decorators: Loop, Cooldown, Timeout, Conditional 

- Blackboard Variables: Bool, Float, Vector3, GameObject, etc.  

REQUIREMENTS 

- NodeCanvas 3.x+ (REQUIRED - not included) 

- Unity 2022.3 LTS or Unity 6+ 

- Ollama (free from ollama.ai) 

- GPU: 4GB+ available VRAM (or CPU with 16GB RAM) 

- Editor only: Windows, macOS, Linux  

WHAT'S INCLUDED

 - BehaviorForge Editor Window 

- Complete C# source code 

- Documentation & quick start guide - Sample behavior descriptions 

- Discord community access

𝗥𝗘𝗤𝗨𝗜𝗥𝗘𝗦 𝗡𝗢𝗗𝗘𝗖𝗔𝗡𝗩𝗔𝗦

BehaviorForge generates assets for NodeCanvas by ParadoxNotion. You must own NodeCanvas (sold separately) to use this tool. → Get NodeCanvas: https://assetstore.unity.com/packages/tools/visual-scripting/nodecanvas-14914

KEY FEATURES

- Natural Language Input — Describe behaviors in plain English

- Complete Asset Generation — Creates Behavior Tree + Blackboard assets

- Local AI Processing — Uses Ollama for offline, private inference

- No Recurring Costs — One-time purchase, no API fees or subscriptions

- Production-Ready Output — Generates Selectors, Sequences, Decorators, Tasks, Services

- Fast Generation — 3-20 seconds depending on complexity

- Multiple Model Support — Works with 3B models (most GPUs) or 7B (high-end GPUs)

- Automatic Blackboard Setup — Generates keys with correct types (Bool, Vector, Object, etc.)

- JSON Intermediate Format — Debug, inspect, or manually edit before asset creation

- Editor Window Integration — Clean UI inside Unity Editor

SUPPORTED NODES

- Composites: Selector, Sequence, Parallel

- Tasks: MoveTo, Wait, RotateToFace, MakeNoise, PlaySound

- Decorators: Loop, Cooldown, TimeLimit, Blackboard Conditions

- Services: DefaultFocus, custom service support

TESTED BEHAVIORS

✓ Patrol between waypoints

✓ Chase player when seen

✓ Investigate noises and return

✓ Flee when health low

✓ Collect items and return to base

✓ Follow leader, assist in combat

✓ Random wander with cooldowns

✓ Multi-phase boss behaviors

✓ Stealth detection states

✓ Squad coordination

REQUIREMENTS

- Unity 2022.3 LTS or newer (Unity 6 supported)

- Ollama (free download from ollama.ai)

- GPU: 4GB+ available VRAM recommended

- Disk: 2-5GB for AI model

- Platforms: Windows, macOS, Linux (Editor only)

⚠️ IMPORTANT: This asset requires NodeCanvas by ParadoxNotion. BehaviorForge will not function without it. Please ensure you own NodeCanvas before purchasing.

WHAT'S INCLUDED

- BehaviorForge Editor Window

- Complete C# source code

- Documentation & quick start guide

- Sample behavior descriptions

- Discord community access: https://discord.gg/nJqDGWmw

Number of VFX Graphs: 40 

Number of VFX Prefabs: 40 

Number of Materials: 20 

Number of Shadergraphs: 6

💻 Supported Development Platforms

💻 Windows: (Yes) | 🍎 Mac: (Yes)

🕹️PLAYABLE DEMO MAP / 📖DOCS

🔥 Unity Fire VFX – The Best In The Asset Store!

Built for high-end Unity projects, this AAA-quality Fire VFX Pack delivers realistic flames, embers, sparks, smoke, and dynamic lighting that hold up in close-ups, cinematics, and real-time gameplay. Its fully modular system lets you easily create anything from small ambient fires to massive wildfires and destruction scenes with natural, non-repetitive results. Perfect for realistic, fantasy, and action-driven environments.

🔥Features🔥

• 🔥 Highly realistic fire visuals suitable for AAA games

Physically believable flame motion, embers, sparks, smoke, and light response designed to hold up in closeups, cinematics, and gameplay. Works for grounded realism, dark fantasy, and high intensity scenes.

• 🔥 Fully modular large scale fire system

Large fires are built from modular fire elements that can be mixed, duplicated, and layered to create massive wildfires, burning fields, ruins, or destruction scenes. Build organic, non repetitive fire layouts instead of relying on a single effect.

• 🔥 Exposed VFX parameters for deep customization

All fire systems include user friendly parameters such as fire scale, velocity, ember spawn rate, glow strength, light radius, light intensity, refraction strength, and more. Quickly tune effects without touching VFX graphs.

• 🔥 Wind influence system ready for weather integration

Fire reacts to multi directional wind via exposed VFX parameters. Flames bend naturally based on wind strength and direction and can be plugged directly into dynamic weather systems.

• 🔥 Multiple fire intensity levels per effect

Many effects include built in low, medium, and high intensity variants. Reuse the same fire type for smoldering ruins, active fires, or full infernos.

• 🔥 Wide variety of fire types included

Includes large scale ground fires and wildfires, campfires, torches, torch clusters, fire braziers, fireplaces, candles, and fire bursts including character engulf effects.

• 🔥 Magical fire variants with full color control

Includes magical torch fire with adjustable color and scale plus preset magical variants such as green wildfire, arcane flame, and shadow style flames for fantasy and RPG projects.

• 🔥 Texture based fire spawning for symbols and shapes

Drive ground fires using any 2D texture or alpha map. Create flaming symbols, magic circles, pentagrams, ritual patterns, or custom shapes simply by swapping a texture.

• 🔥 Vertex painted fire and material overlays

Use vertex painting to place fire particles and fire material overlays exactly where needed on meshes such as barrels, props, walls, or debris for precise artistic control.

• 🔥 Seamless environment integration

Fire effects sit naturally on terrain, rocks, architecture, props, and characters, ensuring grounded placement with no floating or disconnected visuals.

• 🔥 Dynamic fire lighting built in

Fire emits dynamic light that scales with intensity, adding realistic illumination to caves, ruins, interiors, and nighttime scenes without extra setup.

• 🔥 Performance conscious VFX setups

Designed to scale from small ambient fires to massive scenes by adjusting parameters and intensity levels while keeping performance under control.

• 🔥 Ready to use presets plus modular building blocks

Includes polished drop in presets for common use cases along with modular components for artists who want full control and custom fire assemblies.

DISCLAIMERS

*Scene on the renders is for demonstration purposes only!

*Supports HDRP and URP.

*Built-In Render Pipeline is not supported.

SaveSmart Easy is a schema-first save system for Unity.

Define your save data in the editor, generate typed C# accessors, and save game data without string keys, boilerplate, or manual serialization. SaveSmart Easy includes a built-in Save File Editor (Play Mode Supported) that lets you inspect and modify save data directly as raw JSON.

Designed for indie, VR, and mobile games that need a clean, reliable local save solution.

Documentation

🟩 What is SaveSmart Easy?

// Loads from memory

using SaveSmartEasy;

int coins = SaveSmart.SaveData.Coins;

Color themeColor = SaveSmart.SaveData.ThemeColor;

int[] levelScores = SaveSmart.SaveData.LevelScores;

List<int> scoreList = SaveSmart.SaveData.ScoreList;

// Saves to disk immediately

using SaveSmartEasy;

SaveSmart.SaveData.Coins += 100;

SaveSmart.SaveData.ThemeColor = Color.red;

SaveSmart.SaveData.LevelScores = new int[] { 10, 20, 30 };

SaveSmart.SaveData.ScoreList.Add(100);

That’s it. Typed, cached, and automatically stored as JSON.

// Key-based get/set also works

string username = SaveSmart.GetString("Username");

SaveSmart Easy is a lightweight, schema-first save manager for Unity.

Instead of scattering string keys across your codebase, you define your save schema once in an editor tool. SaveSmart Easy then generates typed C# accessors, so you can read and write save data using normal properties with full IntelliSense support.

No manual serialization. No typo-prone keys. No fragile glue code.

🟩 Core Design Philosophy

Schema first, code second

• Define all save fields in one place.
• Generate strongly typed accessors automatically.
• Use simple property assignments to save data.
• Keep gameplay code clean and safe from string-based errors.

This approach scales better than PlayerPrefs and stays far simpler than full custom serialization systems.

🟩 Key Features

🟥 Schema-First Workflow

• Centralized Definition: Define all save fields in a dedicated editor window to keep your data organized.
• Robust Editor Tools: The schema editor supports full Undo/Redo, reordering, and field comments for a developer-friendly experience.
• Automatic Code Generation: Generate typed C# accessors instantly, eliminating boilerplate and manual serialization.

🟥 Type Safety & IntelliSense

• No More Typos: Replace fragile string keys like PlayerPrefs.SetInt("HihgScore") with strongly-typed properties.
• Full Autocomplete: Access your data via SaveSmart.SaveData.YourVariableName with full IntelliSense support and compile-time safety.
• Hybrid API: While property-based access is recommended, traditional key-based APIs (e.g., GetInt, SetString) remain available for dynamic use cases.

🟥 Designed for Performance and Simplicity

• In-Memory Caching: Save data is loaded once and cached per slot, ensuring subsequent reads are instant and never block your gameplay.
• Immediate Persistence: Each write updates both the memory cache and the disk automatically, ensuring data safety without requiring manual save calls.
• Optimized for Indie & VR: Designed specifically to provide a clean, reliable, and lightweight storage solution for mobile and VR platforms.

🟥 Flexible Storage & Security

• Multiple Save Slots: Easily manage multiple saves (e.g., save1.json, save2.json) with simple APIs to switch or clear slots.
• Readable JSON: Files are stored as standard JSON under Application.persistentDataPath for easy debugging and inspection.
• Optional Encryption: Includes built-in AES-based encryption to deter casual save editing and protect player progress. This is intended as basic protection, not security-grade encryption.
• Cloud Ready: Use built-in APIs to read or write Raw JSON, making it simple to sync local data with backends or cloud providers.

🟩 In-Editor Save File Editor (Play Mode Supported)

This tool works even while the game is running (Play Mode), making it ideal for rapid testing and debugging without restarting the game.

• Quickly switch between existing save slots (SaveData1.json, SaveData2.json, etc.).Save Slot Selection
  
• Re-read the file from disk to reflect changes written by the game at runtime.Reload From Disk
  
• JSON is automatically formatted and ordered based on your schema for readability.Direct JSON Editing
  Edit save values directly in a text editor.
  
• The running game sees the updated values instantly.Safe Save & Hot Reload
  JSON is validated before saving.
  Changes are written to disk and the in-memory cache is updated immediately.
  
• Open the save folder directly in the system file manager for inspection or backup.Reveal in File Explorer
  

Typical Use Cases

• Test different save states during gameplay (e.g. set CurrentStage = 5).
• Debug progression, unlocks, or checkpoints without replaying content.
• Inspect or repair corrupted or partial save files.
• Verify cloud sync or encryption behavior by inspecting decrypted JSON.

🟩 Supported Data Types

• Primitive Types: Int, Long, Float, Double, Bool, String.
• Unity Types: Vector2, Vector3, Color, Color32, Quaternion, Rect.
• Standard Types: DateTime.
• Array Variants: Supports all types above (e.g., IntArray, Vector3Array, Color32Array, etc.).
• List Variants: Produces List<T> properties for all types above (e.g., IntList, QuaternionList, DateTimeList, etc.).
• Custom Objects: For complex data structures, use a String field to store JSON strings via JsonUtility or other JSON libraries.

🟩 Typical Use Cases

Well suited for:

• Game settings
• Player progress and checkpoints
• Unlocks and achievements
• Single-player or local save systems
• Indie, VR, and mobile games

Not intended for:

• Massive live-service architectures
• Per-frame telemetry logging
• Server-authoritative MMO save pipelines

🟩 Performance Notes

• Reads are served from memory after the first load.
• Each write persists immediately to disk.
• Avoid writing every frame or inside tight loops.

This design favors data safety and simplicity over ultra-high-frequency write scenarios.

🟩 Why Resources?

The schema config asset is saved and loaded from a Resources folder by design, ensuring predictable availability across all platforms.

• Used only for loading the schema
• Loaded once and cached
• No Addressables required
• No runtime asset modification

The config is a ScriptableObject, stored as a .asset file and persisted with your project.

🟩 Unity Version

• Unity 2020.3 or later (LTS recommended)

LayoutGuides Easy is a Unity Editor-only tool that brings the familiar alignment experience from Canva, Figma, and Photoshop into the Unity Editor.

Up to 10× faster layout iteration for common alignment tasks.

It adds layout guides and smart snapping for both UI and 3D objects, helping designers align elements faster and more accurately.

The tool is performance-optimized and only adjusts object positions. It automatically disables itself in Play mode, ensuring zero runtime impact on your game.

Documentation

Key Features

Editor-Only & Performance-Optimized

Runs entirely in Edit mode and automatically disables itself in Play mode, ensuring zero runtime impact.
Only object positions are adjusted. Rotation, scale, and all other properties remain untouched.

Zero Setup Required

Simply add the LayoutGuidesEasy component to a parent object and it works instantly with all child elements.
No additional setup, no components required on children. Smart guides, snapping, and alignment are available immediately.

Manual Guides

Create and drag layout guides for X, Y, and Z axes in both UI and 3D scenes.
Guides can be locked to prevent accidental movement and customized with different colors and line styles.
In 3D mode, guides appear as semi-transparent planes and can be hidden until snapping occurs.

Center Snap Between Guides
When two manual guides exist on the same axis, objects can snap precisely to the center between them.
Supports X, Y, and Z axes, with simultaneous multi-axis center snapping (for example, X and Y at the same time).

Visual Snap Feedback

Provides clear visual feedback with an outline glow when an object is within snapping range.
This makes snapping behavior predictable and easy to understand while positioning objects.

Smart Guides

Smart guides appear automatically while dragging objects.

• UI elements: 9-point alignment (left, center, right, top, middle, bottom)
• 3D objects: Border-to-border snapping on all axes

Guides are displayed only between the objects being aligned, keeping the Scene view clean.

Equal Spacing

Detects evenly spaced groups of three or more objects and displays spacing indicators.
Helps maintain consistent spacing across all axes during layout adjustments.

Distance Display

Displays real-time distance values between objects when their bounds overlap on one axis.
Inspired by distance indicators in tools like Canva and Figma.
Text and background colors are fully customizable.

Multi-Mode Support

Fully supports:

• Canvas render modes: Screen Space Overlay, Screen Space Camera, World Space
• Standard 3D objects using Renderer or Collider bounds

Why LayoutGuides Easy?

Unity’s built-in tools are powerful but can be slow for precise layout work.

LayoutGuides Easy focuses on clear visual feedback, fast iteration, and designer-friendly workflows, making object alignment feel natural and intuitive.

Perfect for:

• UI menus, HUDs, and responsive layouts
• Level blockouts and prop placement
• Designers and solo developers who want faster iteration

A must-have editor tool for UI and level designers who want fast, precise alignment in Unity.

Not a Runtime Layout System.

LayoutGuides Easy focuses exclusively on Edit Mode alignment workflow with smart guides and visual snapping inspired by Canva, Figma, and Photoshop.

Requirements

• Unity 2020.3 or later
• Editor-only tool (no impact on builds)

ButtonAnimator Easy: Elegant, Precise, and High-Performance uGUI Animations

"Drag, Drop, Done." UI animation shouldn't be complicated.

ButtonAnimator Easy is a powerful, lightweight animation system designed specifically for Unity uGUI. By moving away from complex Animator Controllers and State Machines, we provide an intuitive Preset-first system that lets you breathe life into your UI in seconds.

Documentation

Why Choose ButtonAnimator Easy?

• The Ultimate VR Companion: Uses Base Scale Caching to keep a stable scale reference for UI interaction, significantly reducing Raycast instability issues in World Space Canvases commonly caused by scale animations in VR.
• LayoutGroup Compatible: Automatically generates a __BAE_Anim Wrapper to handle position animations flawlessly without breaking Horizontal, Vertical, or Grid Layout systems.
• Performance Optimized: Designed for VR high-frame rates (90/120 FPS), the Update loop performs only a minimal boolean check, ensuring near-zero CPU overhead.
• Advanced Color Control: Automatically detects and animates multiple components simultaneously, including the Button Background, Icon, and TextMeshPro labels.
• Flexible Override Logic: The Local Override system allows you to maintain global visual consistency via Presets while fine-tuning specific parameters for individual buttons.
• Built-in Spatial Audio: Trigger 3D spatial sound effects at the button’s exact world position without the need to manually manage AudioSource components.

Core Features

Animation System:

• No coding required - Everything can be done in the Unity Inspector
• Preset-first design - Use high-quality ScriptableObject presets or create your own
• Local Override system - Override specific animation parameters without breaking preset updates
• Three animation states - Hover, Click, and Disabled animations
• DOTween-powered - Fast and efficient animations using DOTween

Audio System:

• Built-in audio support - Play sound effects on Hover and Click events
• Preset audio settings - Configure audio clips and volumes in presets
• Per-button audio override - Override audio settings for individual buttons
• No AudioSource required - Uses AudioSource.PlayClipAtPoint for simple setup
• VR spatial audio positioning - Sounds play at the button's world position, providing accurate 3D spatial audio localization for VR applications

Preset System:

• Many presets included - Organized by physical properties: Scale, Position, Rotation, Color & Alpha, Compound & Special, Punch, and Shake
• Easy preset switching - Change presets without losing local overrides
• Re-Apply functionality - Reset to preset values with one click

Editor Integration:

• Custom Inspector - Beautiful, intuitive UI with status indicators
• Preview system - Test Hover, Click, and Disabled animations without entering Play Mode
• Override toggle - Easy switching between Preset and Local Override modes
• DOTween dependency checker - Automatic detection and setup guidance

Runtime Features:

• Automatic interactable handling - Disabled animations trigger automatically when Button.interactable = false
• LayoutGroup compatible - Base scale caching prevents layout issues
• CanvasGroup support - Automatically adds CanvasGroup when alpha animations are needed, prioritizes CanvasGroup.alpha over Graphic.color.a
• Button transition management - Automatically sets Button.transition to None to prevent conflicts
• Multi-touch safe - Independent Tween IDs per state prevent conflicts
• TimeScale independent - Animations work correctly in pause menus
• Debug mode - Optional detailed debug logging for troubleshooting

Design Philosophy

ButtonAnimator Easy is built on three core principles that guide every design decision:

• Preset-first - Design animations once, reuse everywhere. Instead of customizing each button individually, create presets that can be shared across multiple buttons, ensuring visual consistency and rapid iteration.
• Inspector-driven - No Animator Controllers, no state machines, no code. Everything is configured directly in the Unity Inspector, making UI animations accessible to designers and developers alike without the complexity of traditional animation systems.
• Safe-by-default - Animations never break your UI layout or interfere with game time. Base scale caching prevents LayoutGroup issues, and TimeScale-independent animations ensure buttons work correctly even in pause menus.

When to Use / When Not to Use

Good For

• uGUI Button - Designed specifically for Unity's legacy UI system (uGUI)
• Mobile, PC, and VR UI - Works across all platforms that support uGUI
• World Space Canvas - Fully compatible with World Space Canvas for VR applications. Base Scale Caching ensures precise Raycast detection even during scale animations, solving a common issue where other uGUI plugins cause Raycast to break when button scale changes. All animations (Scale, Position, Rotation, Color, Alpha) function correctly regardless of Canvas Render Mode.
• Projects requiring quick consistent animation styles - Preset system enables rapid UI animation setup with consistent visual language

Not Suitable For

• UI Toolkit (UIElements) - ButtonAnimator Easy is built for GameObject-based uGUI, not the newer UI Toolkit system
• UI deeply bound to Animator Controller - If your UI animations are already tightly integrated with Unity's Animator system, this tool may conflict or be redundant

Features:

• Editor-Only Tool: Zero runtime overhead in your final build.
• Code Architecture: Fully namespaced (SOEvolver) and uses Assembly Definitions (.asmdef) to separate Editor logic from Runtime data.
• Migration Runner: Handles sequential chaining (e.g., automatically running V0→V1, then V1→V2).
• Backup System: Stores backups in the project's Library/ folder to avoid cluttering version control, with options to restore specific batches.

Requirements:

• Unity Version: 2022.3 (LTS) or higher recommended.
• Compatibility: Works with standard ScriptableObjects, Addressables, and Asset Bundles.
• Scripting: Requires .NET Standard 2.0 or 2.1 API Compatibility Level.

Files:

• Includes full C# source code (No DLLs).
• Includes Documentation in Notion.

Never lose data when refactoring ScriptableObjects again.

Unity's serialization is powerful but unforgiving. If you delete a field from your script before migrating the data, that data is lost forever. If you work on a team, changing shared data structures often leads to merge conflicts.

SO Evolver solves these problems by adding explicit version control and a safe migration framework to your ScriptableObjects.

KEY FEATURES

• Explicit Versioning: Assets track their own schema version (V0 → V1 → V2).
• Safety First: Automatic timestamped backups are created before every migration.
• Dry Runs: Preview exactly what will change in a log report before modifying files.
• One-Click Restore: Undo mistakes instantly from the dashboard using the backup history.
• Audit Logs: Keeps a complete history of all migrations in your project logs.
• Team-Friendly: Uses a linear versioning model to prevent merge conflicts.
• Batch Operations: Migrate hundreds of assets in a single click.

THE WORKFLOW

1. Inherit: Change your class to inherit from VersionedScriptableObject.
2. Modify: Add new fields to your script (keeping the old ones temporarily).
3. Migrate: Write a simple C# migration script to map old data to new data.
4. Execute: Use the SO Evolver Window to Dry Run and apply changes to all assets.
5. Clean: Safely delete the old fields from your script.

PACKAGE INCLUDES

• Migration Dashboard (Editor Window)
• Core Base Classes (VersionedScriptableObject, SOMigration)
• Automatic Backup & Restore Systems
• Comprehensive Documentation (Quickstart, Safe Workflow, API Reference)
• 10+ Real-world Migration Examples

If you find this tool useful, please leave a review! It helps me add new features.

⭐ KEY FEATURES

Key Features (FR)

• Génération automatique de structures adaptées (Débutant → Avancé)
• Scanner intelligent : dossiers manquants, vides, inconnus
• Protection avancée contre les suppressions accidentelles
• Suppression sécurisée avec double confirmation
• Presets personnalisables et exportables
• Interface claire, thème clair/sombre
• Compatible avec tous les pipelines Unity
• Aucun package externe requis ✨

Key Features (EN)

• Automatic structure generation (Beginner → Advanced)
• Smart scanner: missing, empty, unknown folders
• Advanced protection against accidental deletion
• Safe deletion with double confirmation
• Customizable and exportable presets
• Clean UI with light/dark theme
• Compatible with all Unity pipelines
• No external dependencies ✨

⭐ REQUIREMENTS (FR/EN)

Requirements (FR)

• Unity 2021.3 ou version supérieure
• Compatible Windows, macOS et Linux
• Fonctionne avec tous les Render Pipelines (Built‑in, URP, HDRP)
• Aucun package additionnel nécessaire

Requirements (EN)

• Unity 2021.3 or higher
• Compatible with Windows, macOS and Linux
• Works with all Render Pipelines (Built‑in, URP, HDRP)
• No additional packages required

-----------------------------------------------------------

⭐ CATEGORY & INTENDED USERS (FR/EN)

Pour qui ? (FR)

Conçu pour les débutants qui veulent un projet propre dès le départ, et pour les développeurs professionnels cherchant un workflow rapide, fiable et organisé.

Who is it for? (EN)

Designed for beginners who want a clean project from day one, and professional developers who need a fast, reliable and organized workflow.

⭐ P.S.A Project Structure Assistant

Description :

Project Structure Assistant PRO , est un outil conçu pour offrir une organisation claire, professionnelle et évolutive à vos projets Unity. Il génère automatiquement des structures adaptées à votre niveau, analyse votre projet grâce à un scanner intelligent, protège vos dossiers sensibles et vous permet de créer vos propres presets. Interface soignée, thème clair/sombre, workflow simplifié et projet toujours propre. Un assistant pensé pour les développeurs exigeants. ✨

Description :

Project Structure Assistant PRO , is designed to bring clean, professional and scalable organization to your Unity projects. It automatically generates structures based on your level, scans your project with a smart analyzer, protects sensitive folders and lets you create custom presets. Polished interface, light/dark theme, streamlined workflow and consistently clean project structure. A tool built for developers who want efficiency and clarity. ✨

- Editor only - zero runtime overhead

- Full source code included

- No dependencies

- Works with all render pipelines

- Instant setup - no configuration required

- Settings persist across sessions

Hierarchy Enhancer Pro transforms your Unity Hierarchy window into a powerful, organized workspace.

Why Hierarchy Enhancer Pro?

Large projects become messy fast. Finding objects in a sea of gray text wastes time. Hierarchy Enhancer Pro brings color, structure, and clarity to your workflow.

Visual Organization:

- Separators - Create visual dividers with "---" prefix

- Headers - Colored section titles with "#" prefix

- Color Rules - Auto-color objects by tag, layer, name, or component

- Alternating Rows - Easier to scan long lists

Information at a Glance:

- Component Icons - See attached components instantly

- Active Indicator - Spot inactive objects immediately

- Static Indicator - Identify static objects for optimization

- Tree Lines - Visual parent-child connections

Fully Customizable:

- Every color adjustable

- Enable/disable any feature

- Custom prefixes for separators and headers

- Unlimited color rules

Zero Setup Required:

- Import and it works immediately

- No configuration needed

- Settings window for customization

Color Rules Support:

- Tag matching (Player, Enemy, etc.)

- Layer matching (UI, Water, etc.)

- Name contains text

- Name starts with text

- Has specific component

Perfect For:

- Large projects with many objects

- Team collaboration

- Level designers

- Anyone who values organization

Requirements:

- Unity 2021.3 or newer

- Editor only (no runtime impact)

It is not necessary to import the demo from this bundle. It is a modified version of sample

scene from Mossy Cedrus Forest to merge all packages in a single level.

Join SeedMesh Discord Server!

This product may not be used in datasets for, in the development of, or as inputs to generative AI programs.

All these products have a value of $160, get a discount of -$20 for buying all thogether.

The assets are high quality with 4K textures (the resolution can be adjusted by the developer manually) and optimized with many LODs, this way the assets are usable for a wide range of projects, from optimized games to high fidelity visualizations.

Check the complete details visiting the page of each package.

List of Assets:

• Mossy Cedrus Forest
• Forest Oak Trees
• Realistic Mushrooms Scans
• Forest Moss Scan
• Wild Ivy

Purchasing this bundle will unlock access to the products listed above from the Unity asset store.

• Render Pipeline: Universal Render Pipeline (URP)
• Models:  
• - Custom-made, stylized assets  
• - Optimized for real-time use  
• LOD Groups:  
• - Included only for the tree asset  
• Textures:  
• - Base Color  
• - Normal Map  
• - Optimized texture sizes  
• Materials:  
• - Simple URP-compatible materials  
• - Easy to customize  
• Animations:  
• Tree and foliage includes wind animation using vertex movement
• Includes a particle system for falling leaves, ready to use
• Aquatic plants are static by design
• Wind animation was intentionally not applied, as it does not make sense for water vegetation
• Water-based animation was left for users who want to customize it for their own systems
• Effects:  
• - Lightweight particle system for falling leaves  
• Prefabs:  
• - Ready-to-use prefabs with scale set to (1,1,1)  
• Scale:  
• - Assets are created using real-world scale reference  
• - Scene scale can be adjusted freely without affecting prefabs  
• Compatibility:  
• - Unity version: 6.1  
• - Render Pipeline: URP only  
• Intended use:  
• - Stylized games  
• - Prototypes  
• - Real-time environments

The Stylized_Tree_and_Foliage_Bog is a stylized environment asset pack designed for real-time projects in Unity (URP).

This package includes optimized tree and foliage assets built with performance in mind, featuring tree LOD levels to ensure smooth rendering across different distances and hardware targets.

The assets include simple wind animation for foliage movement and a lightweight particle system for falling leaves, adding subtle life to the environment while keeping performance costs low. All materials are simple and optimized, focused on base color, making them easy to integrate, customize, and extend inside your own projects.. Prefabs are ready to use — just drag and drop into your scene.

This pack is ideal for stylized games, prototypes, and real-time environments where visual clarity and performance are essential.

Need a fast and simple way to add volume and depth to your textures? Normal Map Generator Pro is a powerful, optimized tool that leverages advanced algorithms (Sobel Operator, SDF, Gaussian Blur) to create detailed Normal Maps with zero hassle.

Perfect for both rapid prototyping and final production workflows.

💡 Key Features:

• Instant Generation: Create Normal Maps with a single click.
• Real-Time Preview: See results immediately as you tweak parameters.
• Full Control: Fine-tune Strength, Sharpness, Depth, Blur, and Micro-Details.
• Batch Processing: Process hundreds of textures or entire folders simultaneously.
• Preset System: Save and load your favorite settings (e.g., "Hard Surface", "Organic", "Soft Cloth").
• Edge-Aware Smoothing: Smart smoothing system that preserves important details while eliminating noise.
• Invert Y Support: Easily switch between OpenGL and DirectX formats.

🛠️ Technical Workflow:

The system uses a 4-stage processing pipeline to ensure maximum quality:

1. Preprocessing: Image cleanup and Edge Detection.
2. Distance Field (SDF): Accurate volume and shape calculation.
3. Height Map Generation: Height map creation with intelligent blurring.
4. Sobel Conversion: Final vector Normal Map generation.

Compatibility:

Fully optimized for Unity 6 and Unity 2022 LTS.

Compatibility with versions older than Unity 2021.3 may be limited

- Full source code included

- No dependencies

- Works with Built-in, URP, HDRP

- Supports all platforms: Windows, Mac, Linux, Android, iOS, WebGL

- Namespace: SaveSystemPro

- Well-commented code

Save System Pro is a powerful yet easy-to-use save system for Unity games.

Why Save System Pro?

Stop struggling with PlayerPrefs or writing your own serialization code. Save System Pro handles everything with a simple two-line API.

Core Features:

- Simple API - SaveManager.Set() and SaveManager.Get()

- Multiple Save Slots - unlimited slots with easy switching

- AES-256 Encryption - protect saves from tampering

- GZip Compression - smaller file sizes

- Auto-Save - configurable intervals and triggers

- Automatic Backups - never lose player progress

- Cross-Platform - works on all Unity platforms

Editor Tools:

- Save Manager Window - view, load, and delete saves

- Settings Asset - configure everything without code

- One-click setup - ready to use in minutes

Saveable Component:

- Add to any GameObject

- Automatically saves position, rotation, scale

- Saves active state

- Zero code required

Events System:

- OnBeforeSave / OnAfterSave

- OnBeforeLoad / OnAfterLoad

- OnSaveDeleted

Perfect For:

- RPGs and adventure games

- Puzzle games with progress

- Simulation and strategy games

- Any game that needs to save data

Requirements:

- Unity 2021.3 or newer

- All render pipelines supported

- All platforms supported

What's Included:

- Full C# source code

- Complete documentation

- Ready-to-use examples

Requirements

• Extenject Dependency Injection IOC
• DOTween (HOTween v2)

Supported platforms

- Android

- iOS

Third-Party Notices

Asset uses ------ under a ----- license; see Third-Party Notices.txt file in package for details.

A complete cryptogram template for Unity. Create an engaging experience with word puzzles and riddles built on scalable and clean architecture patterns!

This flexible, ready-to-use foundation can be easily adapted to any game theme or visual style - perfect for quick prototyping or polished puzzle releases.

📚 HELPFUL LINKS:

📄 DOCUMENTATION | 🌐 WEBSITE | 💬 DISCORD | 🎥 YOUTUBE

🔧 FEATURES OF CRYPTOGRAM:

📝 Text Editor & Parser

Prepare levels directly in the editor, adding words, phrases, and clues with ease.

The flexible parsing system allows you to structure levels in any format - from short quotes to full logical riddles.

🎚️ Encryption Difficulty Configuration

Adjust the encryption logic to define how challenging your puzzles are.

Control parameters like the number of hidden letters, symbol replacement patterns, and the depth of the cipher logic.

Fine-tune the cryptogram rules to create a unique gameplay balance for your project.

🎮 Premade Levels & Full Flexibility

Test the system with ready-to-play demo levels or create your own custom puzzles.

You have full control over structure, text length, and logic - design levels exactly the way you want.

💡 Smooth Animations & Player Feedback

Unlock animations, success effects, and error feedback make gameplay more dynamic and satisfying.

Add your own animations or visual effects to fit your project’s style.

📄 Data Persistence

Player progress is saved automatically and restored after restarting the game, ensuring a seamless experience.

🎨 Scalable & Customizable UI / UX

Interface scales perfectly across mobile devices and tablets.

Easily adjust colors, fonts, icons, and layouts to match your game’s theme.

Clear and intuitive UX tested in released projects.

🧩 Modular Architecture

Built with clean, extendable code structure.

Easily integrate with your existing systems, add new modes, UI elements, or extra logic without breaking the core functionality.

🎯 Where This Asset Fits Best

KMA Cryptogram Word Game is designed for cryptogram-based projects where the core value comes from flexible content creation (editor + parser), tunable cipher difficulty, and a clean, mobile-first UX.

It works especially well for the following puzzle formats:

• Short quotes and aphorisms built around fast “decode the message” play sessions.Quote Cryptograms
  

• Multi-line riddles where clues are embedded directly into the encrypted text and the solution is revealed through decoding.Riddle Cryptograms
  

• Structured chapters that gradually increase cipher depth, hidden letters, and symbol replacement patterns.Progressive Decoding Levels
  

• Curated categories such as Movies, History, Motivation, Science, Memes with easy reskinning and content swapping.Themed Puzzle Packs
  

• Rotating puzzles with consistent difficulty rules and saved progress to support long-term retention loops.Daily / Weekly Challenges
  

• Each solved cryptogram unlocks the next line or scene, creating a simple narrative entirely through text.Story-in-Quotes (Light Narrative)
  

• Practice-focused levels where the goal is mastering specific encryption rules, symbol mappings, and decoding patterns.Logic-First Cipher Training
  

Cryptogram Puzzle is designed to fit naturally into word-based puzzle projects and works smoothly alongside commonly used Unity tools for localization, UI feedback, saving, animation, and clean editor workflows.

Possible Integrations:

• I2 Localization
• DOTween (HOTween v2)
• Easy Save - Save & Data Serializer
• DOTween Pro
• Feel by More Mountains
• Playmaker
• Text Animator for Unity
• Rewired
• Master Audio 2024
• LeanTween
• Behavior Designer
• Shapes
• Odin Inspector and Serializer
• Modern UI Pack

Tired of constantly switching between your level scenes and launch scene?

QuickLaunch Easy fixes that. It’s a simple tool that lets you start playing from any scene you’re working on, and when you’re done, it takes you right back to where you were.

As a Unity developer, nothing kills the flow like the tedious cycle of manually switching back and forth between "Level" scenes and your "Initialization/Launch" scene. 

QuickLaunch Easy is a lightweight workflow power-tool designed to eliminate that friction. Now, no matter which level you’re currently editing, you can jump straight into the game with a single click and automatically return to where you left off.

Features

• Play from anywhere: No more hunting for your launch scene. Just hit the shortcut and you're playing, even if you're deep in some level scene.
• Auto-return: When you stop playing, it brings you back to the exact scene you were editing. Your workflow stays intact.
• One shortcut for everything: Ctrl/Cmd + G starts the game. To stop, you can either press the same shortcut again or use Unity's built-in Play button—whichever you prefer.
• Easy setup: Just drag your launch scene into the settings window. That's it.
• Scene tracking: Uses Unity's GUID system, so it finds your launch scene even if you move or rename it.
• Clean Boot: Temporarily manages "Enter Play Mode Options" to ensure all Awake and Start logic in your initialization scene runs perfectly every time. Always forces "Reload Domain and Scene" (Full Reload) during QuickLaunch to ensure a clean state. Your original settings are automatically restored when you stop playing.

How to Use

1. Installation: Import the QuickLaunchEasy package into your Unity project.
2. Setup: Open Tools > QuickLaunch Easy > Settings, then drag your launch scene (like Launch.unity) into the Launch Scene field.
3. Usage: Press Ctrl/Cmd + G to start playing. To stop the game, you can press the same shortcut again or use Unity's built-in Play button—your choice. You can also use Tools > QuickLaunch Easy > QuickLaunch from the menu.
4. Customizing the Hotkey: You can change the shortcut using Unity's built-in Shortcuts Manager. Go to Edit > Shortcuts (Win) or Unity > Shortcuts (Mac), then search for "QuickLaunch" and assign your preferred key combination.

Why did I create this?

As a developer, I’ve been through this tedious process countless times. Having to manually switch to the launch scene to test a feature, and then manually switch back to the level I was just editing, was incredibly frustrating!

I decided to create this tool so that no one has to endure that annoyance anymore. By eliminating these repetitive steps, we can keep our focus where it belongs—on building great games. QuickLaunch Easy is here to accelerate your development process and keep you in the "flow" state.

Enjoy it!

If you find this tool useful, please check out my other assets.

• SteamManager: init/run callbacks/shutdown with ready checks.
• Achievements: SteamAchievements.Unlock, queued popups, dynamic achievement UI.
• Stats: int/float get/set/add, reset/flush; dynamic inspector-driven stats UI; auto-built rows.
• Leaderboards: find/create, upload (KeepBest), top entries; UI with avatars.
• Lobbies: create/find/join/leave, member list, chat, ready/state flags, scene selection, host checks.
• Cloud Save: save/load/delete string/JSON via Steam Remote Storage.
• Profile/Avatar & Rich Presence wrappers.
• SteamCMD Uploader: editor window + settings, app/depot/branch config, VDF generation, run_app_build.
• UI supports TextMeshPro and legacy UI Text; demo scenes included.
• Requirements: Steamworks.NET installed, Steam client running, valid Steam AppID; no Steam SDK binaries included. If using URP, note tested Unity/URP versions.

Steamworks Essentials is a plug-and-play toolkit for integrating Steamworks.NET into Unity. It ships with customizable UI, prefabs, and demo scenes covering:

• Achievements with queued popups and a dynamic achievement UI.
• Stats (int/float) with dynamic inspector-driven panels and ready-made stats UI.
• Leaderboards (find/create, upload, top entries) with avatars and scrollable UI.
• Lobbies (create/find/join/leave), member list with chat, ready/state flags, scene selection, and host checks.
• Cloud saves (string/JSON), rich presence, profile/avatar loading.
• SteamCMD uploader window for branch/build uploads.
• UI supports both TextMeshPro and legacy UI Text; scenes show practical wiring.

Requirements: Steamworks.NET installed, Steam client running, valid Steam AppID; Steam SDK binaries are not included. Spacewar (480) is for testing only. If using URP, note the tested pipeline/version.

Number of textures : Ao maps for materials

Texture dimensions : 2048x2048

Number of materials: 9

Polygon count : 70K

Number of meshes/prefabs: 4

LOD information : No LODs

Shader: Standard/Lit

Best Racing Games => Click to See

This is a sport car for your mobile or other platform games with next-gen quality

Car has 70K triangles to have maximum quality on the all platforms

You can optimized up to 10k by using the Blender decimate function

Also you can bake into 3k using bake to low poly solution

Best Racing Games => Click to See

Number of textures : Ao maps for materials

Texture dimensions : 2048x2048

Number of materials: 9

Polygon count : 70K

Number of meshes/prefabs: 4

LOD information : No LODs

Shader: Standard/Lit

Best Racing Games => Click to See

This is a sport car for your mobile or other platform games with next-gen quality

Car has 70K triangles to have maximum quality on the all platforms

You can optimized up to 10k by using the Blender decimate function

Also you can bake into 3k using bake to low poly solution

Best Racing Games => Click to See

Project Styler PRO

Visual organization for Project & Hierarchy

Project Styler PRO is a Unity Editor tool that helps you keep your projects clean, readable, and easy to navigate.

It allows you to visually organize folders in the Project window and GameObjects in the Hierarchy using colors, text styling, and icons — all without writing a single line of code.

Perfect for small prototypes and large production projects alike.

Key Features

Project Window Styling

• Customize folder background color
• Change text color
• Assign custom icons to folders
• Apply styles instantly or via detailed rules
• Supports exact folder paths or folder name matching

Hierarchy Styling

• Style GameObjects with background and text colors
• Automatically apply styles using name-based rules
• Gameplay logicIdeal for grouping systems like:
  UI
  Lighting
  Enemies
  Environment
  

Quick Style Palette

• Alt + Click on folders or GameObjects to open a quick style palette
• Option (⌥) + Click on macOS
• Choose from predefined colors or create custom styles instantly

Style Manager

• Central place to manage all styles
• Enable or disable styles at any time
• Edit existing styles
• Control style priority
• Separate tabs for Project and Hierarchy styles

Settings

• Enable or disable the entire system
• Toggle Project window styling independently
• Toggle Hierarchy styling independently
• (Settings are stored per editor instance)Reset settings to defaults
  

Why Use Project Styler PRO?

• Improve project readability at a glance
• Navigate large projects faster
• Reduce time spent searching for assets and objects
• Keep consistent visual structure across your project
• No scripts, no setup, no runtime impact

This tool works entirely inside the Unity Editor and does not affect your build.

How It Works

1. Import the asset
2. Hold Alt and click on a folder or GameObject
3. Choose a style
4. Enjoy a cleaner, more organized project

_____________________________________

What’s included in Project Styler Lite

• Folder colors in Project (background & text)
• Hierarchy object colors
• Instant styling via Alt + Click
• Style rules: Exact Path, Folder Name, Name Contains
• Style priority system
• Centralized Style Manager
• One-click enable / disable

What you get with Project Styler Pro

Everything in Lite, plus:

• Custom folder icons (Texture2D)
• Ignore Case matching
• Separate toggles for Project and Hierarchy styling
• Reset to Defaults
• Access to the Style Database (advanced control)
• Extended settings for full styling control

Project Styler Lite is a lightweight Unity editor tool that helps you visually organize your project faster and more clearly.

It lets you style folders in the Project window and GameObjects in the Hierarchy using colors — directly inside the editor, without writing any code.

Project Styler Lite focuses on simplicity, speed, and performance.

Ideal for developers who want cleaner projects without complex configuration.

Key Features

• Color styling for folders in the Project window
• Color styling for GameObjects in the Hierarchy
• Fast workflow using Alt / Option + Click
• Folder background and text color customization
• Hierarchy background and text color customization
• Component Type NameMultiple matching modes:
  Name Contains
  Exact Name
  Tag
  Layer
  
• Centralized Style Manager for all styles
• Automatic fade effect for better readability
• Minimal settings with a single enable/disable toggle

How It Works

• (Option + Click on macOS)Hold Alt and click on a folder or GameObject
  
• Choose a color from the quick palette
• Or open Custom to define matching rules and priority
• Styles are applied instantly and update automatically

Style Manager

The Style Manager lets you:

• View all created styles
• Enable or disable individual styles
• Edit colors and matching rules
• Adjust priorities
• Switch between Project and Hierarchy styles

_____________________________________

What’s included in Project Styler Lite

• Folder colors in Project (background & text)
• Hierarchy object colors
• Instant styling via Alt + Click
• Style rules: Exact Path, Folder Name, Name Contains
• Style priority system
• Centralized Style Manager
• One-click enable / disable

What you get with Project Styler Pro

Everything in Lite, plus:

• Custom folder icons (Texture2D)
• Ignore Case matching
• Separate toggles for Project and Hierarchy styling
• Reset to Defaults
• Access to the Style Database (advanced control)
• Extended settings for full styling control

Check out our BESTSELLER upgrade: [Quirky Series Ultimate Pack]

Website : https://omabuarts.com

Quirky Series - Animals Mega Pack Vol.1

Quirky Series - Animals Mega Pack Vol.2

Quirky Series - Animals Mega Pack Vol.3

Quirky Series - Animals Mega Pack Vol.4

Features

✅ One (1) animal

✅ Tiny 8x8 px texture [diffuse map only]

✅ Rigged/Skeleton

✅ 19 animations

✅ 26 blendshapes/shapekeys for facial expression

✅ 4 LOD [between 300-9,000 tris]

✅ Mobile, AR/VR ready

✅ Sample URP Shader included

❌ Vertex color

❌ Clean (non-overlapping) UV map

Animations

Attack | Bounce | Clicked | Death

Eat | Fear | Fly | Hit

Idle_A | Idle_B | Idle_C

Jump | Roll | Run | Sit

Spin/Splash | Swim | Walk

Blendshapes/Shapekeys:

eyes.blink | eyes.happy | eyes.sad | eyes.sad

eyes.annoyed | eyes.squint | eyes.shrink | eyes.dead

eyes.lookOut | eyes.lookIn | eyes.lookUp | eyes.lookDown

eyes.excited-1 | eyes.excited-2 | eyes.rabid

eyes.spin-1 | eyes.spin-2 | eyes.spin-3

eyes.cry-1 | eyes.cry-2 | eyes.trauma

teardrop-1.L | teardrop-2.L | teardrop-1.R | teardrop-2.R

sweat-1.L | sweat-2.L | sweat-1.R | sweat-2.R

Email : omabuarts@gmail.com

Website : https://omabuarts.com

Twitter : @omabuarts