Asset Store newest packages

• HDRP, Standard & URP support.

• 1 Shader for all VFX Assets

💥 Toon Hits & Projectiles 💥

Add impact and personality to your game with Toon Hits & Projectiles, a VFX pack packed with stylized hits and dynamic projectiles in a bold cartoon style.

From snappy hit sparks to exaggerated impact bursts and a wide range of projectile types, the effects are designed to feel responsive, readable, and satisfying in motion. Whether you're building fast-paced combat, arcade shooters, or ability-driven systems, this pack helps every action land with clarity and style.

Crafted with strong silhouettes and timing in mind, the effects cut through visual noise while keeping a playful, high-energy aesthetic. Easy to integrate and highly versatile, you can mix and match elements to create everything from subtle hits to over-the-top cartoon chaos.

Optimized for mobile, console, and PC, with support for Built-in, URP, and HDRP.

💥 Key Features 💥

• Minimal set-up to get it working on your own mesh
• 1 Shader for all particles
• Includes overview scene and usage examples
• Compatible with Built-in, URP, and HDRP
• Drag and Drop

Technical details

• Polygon Count: 48,297 Triangles.
• Vertex Count: 52,302 Vertices.
• Number of Meshes: 1 Prefab (71 organized sub-objects).
• Rigging: Yes (Antennas only).
• Animations: No.
• Number of Textures: 7 Sets.
• Texture Dimensions: 1024 x 1024 pixels (Optimized).
• UV Mapping: Yes (Non-overlapping).
• LOD Information: LOD 0 only.
• Materials: HDRP Lit (PBR).
• Pipeline Compatibility: Native HDRP. Fully compatible and convertible to URP and Built-in Render Pipeline. * Render Pipeline Conversion: Materials can be easily upgraded to any pipeline using Unity's built-in Render Pipeline Converter (Edit > Render Pipeline > Upgrade Materials).
• Supported Unity Versions: 2021.3+ and Unity 6.

MODERN SELF-PROPELLED HOWITZER: Performance-optimized 3D model of a Modern 155mm Artillery Unit, specifically designed for large-scale military simulations and tactical games where engine overhead is a priority. This asset balances visual accuracy with a mid-poly count, making it ideal for use as a functional vehicle or high-quality background asset.

The model features 48,297 triangles, prioritizing real-time efficiency. It is designed to look great in action while maintaining high frame rates, avoiding the heavy performance cost of extreme-fidelity geometry.

⚠️ HIGH-END CINEMATIC WARNING (HDRP Path Tracing)While the model is optimized for performance, this package includes a showcase setup to push Unity’s HDRP visual limits:

• Cinematic Ready: Configuration for High-End PCs using Path Tracing to enhance lighting and materials.
• Scene Demo: Standard HDRP settings for stable performance across most hardware.

Key Features:

• Optimized Geometry: A strategic triangle count of 48k ensures the model remains lightweight for complex scenes with multiple units.
• Efficient Textures: 1024x1024 texture sets designed to minimize VRAM usage while maintaining a clean, professional appearance.
• Modular Hierarchy: Organized into 71 sub-objects (wheels, turret, barrel, hatches) for easy scripting of mechanical parts.
• Rigged Antennas: Basic bone hierarchy included for secondary motion (wind/physics).
• Authentic Matte Finish: Battle-hardened look suitable for modern combat environments.

Compatibility:

• Native Pipeline: HDRP (High Definition Render Pipeline).
• Easy Conversion: Materials can be upgraded to URP or Built-in via Unity’s Render Pipeline Converter.
• Platforms: PC, Console, and high-end Mobile projects.

Note: This package includes the exterior model only. Due to its optimized nature, it does not include interior cabins, high-density LODs, or pre-made animations.

• Prefab Browser — dual-mode (Browser & Picker), full-text search, tag filtering, source/collection filter, multi-select with shift-click & rubber-band marquee, drag-to-scene support
• Collection Panels — floating, resizable, pinnable panels per collection; color-coded headers; drop zones; per-panel search
• Advanced Asset Previewer — animated previews, particle system support, zoom, metadata overlay, configurable background color
• Profile Manager — save/load/switch named profiles, each with independent collections and asset assignments
• Scene Asset Browser — asset filtering, thumbnail preloading, play-mode & domain-reload safe lifecycle
• Settings Window — categorized settings UI (Appearance, Icons, Indicators, Hover Popup) backed by a ScriptableObject with full Undo support
• Context Menu Extensions — all features accessible via Tools/Prefabulous menu with keyboard shortcuts (e.g. Ctrl+Shift+P)

Prefabulous supercharges your Unity Editor workflow by giving you full control over how you browse and manage your project's prefabs and assets.

Organize assets into named collections displayed as floating, resizable panels — pin them, color-code them, and arrange them however suits your workflow. A dedicated Prefab Browser lets you search, filter by tags, and batch-select assets with shift-click and marquee selection, then drag them straight into the scene.

The built-in Advanced Asset Preview system renders live, animated previews including particle systems, complete with zoom controls and metadata display. A Profile Manager lets you save and switch between entirely separate collection setups — ideal for switching between project phases or team members sharing the same machine.

The package is fully customizable through a clean Settings Window covering appearance, icons, indicators, and hover popups. Every major feature is accessible via keyboard shortcuts and a polished Tools menu.

Suitable for any genre or project type — from small indie games to large multi-scene productions.

• Sub-second Code Refreshes: Instantly patch changes to any method body, logic condition, math equation, or local variable without triggering a Domain Reload.
• Zero Heavy Dependencies: Runs entirely natively. It does not use heavy third-party modding frameworks (like HarmonyLib) or compile massive hidden proxy DLLs.
• Selective Play Mode Preservation: A built-in workflow that allows you to permanently save specific Hierarchy tweaks made during Play Mode, while safely letting the rest of the game (like physics and player positions) reset normally.
• Scene View Status Overlay: A fully customizable, non-intrusive status indicator injected directly into the Scene View so you always know when the compiler is listening.
• Smart Fallback: If you attempt to make a structural code change that memory patching cannot legally support (like adding new Class Fields or changing Method Signatures), the tool intelligently ignores the patch and waits for a standard Unity compilation.
• OS Support: Windows Only (Requires kernel32.dll).
• Unity Version: Compatible with Unity 2021.3 LTS, 2022.3 LTS, and newer.

Stop waiting. Start creating.

Sakanfar Auto Compiler is an ultra-fast, in-memory script patching tool designed to completely eliminate Unity’s frustrating Domain Reload times during active development.

Whether you are in Edit Mode or actively testing in Play Mode, Sakanfar Auto Compiler allows you to modify your C# methods, tweak math, and adjust logic on the fly. Simply save your script, and your changes are injected directly into your running game’s memory in less than a second—without a progress bar, without breaking your flow, and without losing your game state.

Why choose Sakanfar Auto Compiler? Unlike heavy, expensive solutions that require massive third-party detouring libraries or proxy-class generation, Sakanfar uses a razor-sharp, lightweight approach. By utilizing unsafe C# and direct x64 IL injection, it achieves the exact same instant-refresh speeds for standard method modifications with practically zero memory overhead.

Bonus: The Play Mode State Preserver Unity notoriously erases all Scene changes the moment you exit Play Mode. We fixed that. With our built-in Preserver, you can move objects, change materials, and tweak lighting while the game is running. Simply select the customized GameObjects in your Hierarchy and hit Stop. Sakanfar Auto Compiler will instantly intercept the stop process and safely overwrite their Edit-Mode originals with your modified versions!

• Search across message text, full log text, and resolved source paths
• Severity icon filters with warning/error highlighting and adjustable highlight intensity
• Duplicate collapsing with per-row counts
• Double-click or press Enter to open the primary source file
• Optional stack frames in the details pane with per-frame Open buttons
• Copy modes: Clean, Stack, and Raw
• Clear split button with Clear on Play, Clear on Build, and Clear on Recompile
• Error Pause toggle that mirrors Unity Console behavior
• Source-column toggle for a wider single-column view
• Mute rules for specific messages or source files
• Compact right-docked layout
• Persistent window state between editor sessions
• Editor-only package, no runtime code included
• Recommended for Unity 6 or newer
• Open from Window > Analysis > Clean Logs

Clean Logs is a Unity Editor console companion for faster log triage. It helps you filter noisy logs, collapse duplicates, open source files quickly, copy cleaner bug-report text, and move through stack traces without replacing Unity’s built-in Console.

Great for developers who spend a lot of time debugging warnings, errors, and exceptions and want a cleaner day-to-day workflow inside the editor.

• Add runtime commands to Unity easily with attribute-based setup
• Debug gameplay systems live in Play Mode and player builds
• Auto-discover command providers with minimal setup
• Expose variables for real-time tuning and testing
• Use built-in slash search, history, help, and parameter hints
• Send DEBUG, INFO, WARNING, and ERROR logs directly to the console
• Control visibility and access for safer release builds
• Customize colors, layout behavior, opacity, and overall look
• Built with Unity UI Toolkit and suitable for production projects.

Game Console PRO is a runtime console for Unity that makes it much easier to add custom commands, debug your game while it is running, and build small in-game tools for development. You can drop the prefab into your scene, open the console in Play Mode or in a build, and start controlling parts of your game right away through a clean console-style interface.

Setting up commands is simple. You just add attributes to MonoBehaviours or static classes, and the system automatically finds them in the scenes you have loaded. That means less manual setup and a much smoother workflow when you want to add new debug tools, QA shortcuts, cheats, tuning controls, or internal developer commands.

It also includes the features you would expect from a good console: slash-command search, smart suggestions, command history, parameter hints, help commands, runtime logs, access control, and a UI Toolkit interface you can customize to fit your project. It feels lightweight and fast, but still gives you plenty of room to grow.

Supported files:

• FBX, Prefabs, Static and Skinned Meshes
• PNG, JPG, TGA, PSD textures

Core Systems

• Mesh compression presets (Low, Medium, High)
• Batch texture optimization system
• Dependency detection for referenced assets

Optimization Tool is a lightweight editor toolset designed to improve project performance, reduce build size, and optimize assets directly within the editor. It helps developers quickly analyze heavy resources and apply optimizations through simple, one-click workflows.

Features

This tool focuses on two main optimization areas:

3D Model Optimization

• Vertex and triangle count analysis
• Mesh memory usage estimation
• Disk size vs runtime comparison
• One-click mesh compression presets (Low, Medium, High)

Texture Optimization

• Batch texture compression workflow
• Maximum texture size control
• VRAM usage estimation
• One-click optimization for referenced textures

Benefits

• Improve runtime performance and frame rate stability
• Reduce overall build size and memory usage
• Speed up asset optimization workflow inside the editor
• Maintain cleaner and more production-ready projects

Unity version: All versions from 2022.3 LTS

Render pipelines: Built-in, URP, HDRP

Dependencies: AnkleBreaker Core (auto-installed on import)

Assembly definitions: 5 asmdef (Runtime, Editor, Editor.Installer, Sample, Tests)

Namespace: AnkleBreaker.ManagersLoaderSystem

Sample scenes: 3 scenes (Menu, Gameplay, ComplexDependencies)

Sample managers: 12 example managers (Audio, Save, Network, Auth, Database, Inventory, Multiplayer, Analytics, Score, Gameplay, MenuUI, GameplayUI)

Documentation: Illustrated PDF included

🚀 Managers Loader: Simplify Your Project Architecture

Managers Loader is a scene-driven initialization system that transforms chaotic game systems into a fluid, visual workflow. Eliminate fragile singletons and loading order conflicts: take full control over your managers' lifecycle, bye bye race conditions.

Why Choose Managers Loader?

• Intelligent Initialization: Control the exact loading order of your systems through a robust dependency resolution system.
• One-Click Manager Creator: Instantly generate scripts, ScriptableObjects, and prefabs with a dedicated wizard.
• Real-Time Visualization: Use the interactive Status Window with a dependency graph to identify cycles and monitor loading states in Play Mode.
• Scene-Driven Transitions: Trigger manager loading based on specific scene changes (FROM/TO scene pairs).
• Production Ready: Full support for URP, HDRP, and Built-in pipelines with an automatic material converter.

Key Features

• ManagerCategory: Use ScriptableObject-based "tags" to identify systems and declare dependencies.
• LocalManager: An abstract MonoBehaviour base class with a complete loading lifecycle (InitiateLoad, Load, DoneLoad).
• Automatic Validation: Built-in cycle detection and visual warnings in the inspector prevent logic loops and crashes.
• Extensible Workflow: Highly flexible tools that work for both visual-heavy users and those preferring a code-based approach.
• Manager Creator Wizard — Generate new manager scripts + prefabs + categories from the editor
• Event bus (ManagersLoaderHandlerData) — Static events for OnManagerLoaderReady, OnManagerLoaded, OnAllManagersLoaded, OnManagerCategoryLoaded
• DontDestroyOnLoad support — Per-manager and per-loader persistence control
• 68 unit tests (59 EditMode + 9 PlayMode)

Minimum Unity Version: 2021.1

Render Pipeline: Any — Built-in, URP, HDRP (no rendering dependency)

Scripting Backend: Mono and IL2CPP

Platforms: Editor, Windows, macOS, Linux, Android, iOS, and any Unity platform with System.IO file access

Namespace: LACDebugLogger

Assembly Definitions: Included — runtime and editor assemblies are separated

LAC Debug Logger — Tag-Based Unity Logging & Console Filter

LAC Debug Logger is a lightweight Unity debugging tool that replaces scattered Debug.Log calls with a structured, tag-based logging system. Filter Unity console output by category, write structured log files for Editor and builds, and manage everything from a focused editor window — without touching your code or recompiling.

Whether you are tracking AI behaviour, physics interactions, UI events, or any other game system, you define the tags, and the logger only passes what you need to the Unity Console right now.

Tag-Based Console Filtering

• Define unlimited custom log categories (tags) in the editor window
• Toggle any tag on or off instantly — active tags appear in the console, inactive ones are silently dropped
• Bulk controls to enable or disable all tags in one click
• Untagged log calls always pass through, so third-party and legacy code is never silenced

Structured File Logging

• Write log output to .txt files in the Editor, standalone builds, or both
• Each entry includes timestamp, severity, scene name, and tag for easy filtering in any text editor
• Choose a custom save path via folder browser, or default to Application.persistentDataPath
• Automatic 5 MB file rotation — active log is archived before a new one starts
• Flush on application quit, flush when buffer reaches a configurable entry limit, or call DebugLogger.Flush() from code at any time

Clean API — Drop In, No Setup

DebugLogger.Log("Pathfinding complete", "AI");
DebugLogger.LogWarning("Overlap detected", "Physics");
DebugLogger.LogError("Missing reference", "UI");
DebugLogger.LogVerbose("Frame data", "AI");

Editor Window (Tools > Debug Logger)

• Add, remove, enable, and disable tags without leaving the Editor
• All / None bulk tag toggle buttons
• File logging toggles, file name, save path, and buffer settings in one panel
• Settings persist in a ScriptableObject — version-control friendly, Inspector editable

Minimal & Non-Intrusive

• Zero runtime overhead when file logging is disabled — no allocations, no background threads, no global hooks
• Severity filtering is handled by Unity's own Console buttons — no duplication
• No third-party dependencies, no reflection, no editor-only scripts leaking into builds

Ideal for teams using categories like AI, Physics, UI, Network, Audio, Player, or any system-specific tag that helps isolate signals from console noise during development.

Prometheus Tool is an all-in-one editor extension that packs 10+ practical tools into a single window. From cleaning code and fixing references to organizing assets and spotting performance issues — all without leaving the editor.

What’s inside

Clear Log In Scripts — Scan and remove Debug.Log / LogWarning / LogError in C# files. Reduce allocations and tidy the codebase before build.

Find References — Scan the active scene for Missing or None references. Catch broken references before entering Play Mode.

Game Speed — Adjust time scale in Play Mode (0.5x, 2x, 5x or custom). Useful for slow-motion and fast-forward testing.

Quick Rename (Hierarchy) — Batch rename GameObjects with find & replace, prefix/suffix, and numbering. Helps keep the hierarchy organized.

Quick Rename (Files) — Apply the same batch renaming features to Project assets with patterns and numbering.

Performance Profiler — Lightweight metrics with key issues highlighted at a glance. Useful for quick checks without opening the full Unity Profiler.

Script Dependency Analyzer — Analyze script dependencies and detect circular references. Helps maintain a cleaner architecture and safer refactoring.

Unused Asset Cleaner — Detect assets that are not referenced anywhere in the project. Reduce project and build size safely.

Image Resizer — Batch resize textures (e.g. Power of Two). Includes optional background removal for UI and atlases.

Console Log PRO — Enhanced log viewer with filtering and inline code preview. Speeds up debugging workflow.

Audio Editor — Trim, mix, and process audio clips directly inside Unity. No need for external tools.

Favourite Items — A tool that allows developers to pin assets, scripts, prefabs, and other items into groups, so they can quickly access them with a single click when needed.

Customizable & genre-agnostic

Works with any Unity project and across all genres (2D, 3D, mobile, PC). No framework lock-in — use only the tools you need via Tools → Prometheus Toolkit.

Ideal for

Solo developers and small teams who want more power inside the Unity editor.

Projects that need cleaner builds, fewer missing references, and less log or unused asset clutter.

Developers who want batch renaming, resizing, cleaning, and lightweight performance or dependency insights without leaving the editor.

109 seamless textures

2048x2048

- Color

- Normal

- AO

- Height

- Mask

Save 50% with this pack

This pack contains:

• Stylized Textures - Vol 251 - Grass

• Stylized Textures - Vol 252 - Rocks

• Stylized Textures - Vol 253 - Rocks

• Stylized Textures - Vol 254 - Lava

• Stylized Textures - Vol 255 - Roots

• Stylized Textures - Vol 256 - Roots

• Stylized Textures - Vol 257 - Cobblestone

• Stylized Textures - Vol 258 - Cobblestone

• Stylized Textures - Vol 259 - Cobblestone

• Stylized Textures - Vol 260 - Desert

Resolution: 2048x2048

Maps included:

- Color

- Normal

- AO

- Height

- Mask

This pack contains:

19 seamless textures

Render Pipeline: URP (Universal Render Pipeline) 

Minimum Unity Version: 2022.3 LTS or higher

Assets:

• Number of VFX / Prefabs: 7
• Custom Shaders: 3 (Meteora Lit, ParticleAdditiveHDR, ZWrite Utility)
• Number of Scripts: 3 (MeteorController, ProjectileMove, CameraShaker)
• Number of Textures: 8
• Texture Resolutions: 512x512, 1000x1000, 1024x1024

Enhance your game's combat or environmental hazards with Meteor Effects URP. This package delivers high-quality, game-ready meteor projectiles that crash into your scene with explosive force.

Key Features:

• Highly Modular: Easily detach flight logic, trail particle systems, or impact craters to use in your own custom spells.
• Dynamic Shaders: Features custom Shader Graph materials, including a dynamic Voronoi-based lava shader that cools and glows realistically, and an optimized Additive HDR shader for intense fire effects.
• Smart Collision & Game Feel: Includes C# scripts that automatically align impact craters to surface normals, gracefully detach and fade trails upon impact, and trigger camera shakes for maximum impact feel.
• VR & Mobile Ready: Extremely well-optimized shaders and particle counts ensure smooth performance on standalone VR headsets (such as Meta Quest) and mobile devices.
• URP Ready: Built and optimized specifically for the Universal Render Pipeline.

Smart VAT Tool converts 3D animations to Vextex Animation Textures.

It allows easy user customization such as changing the naming convention and default settings all from a scriptable object.

It includes example assets and basic VAT shaders. Feel free to use them as a base for your own.

Smart VAT is a tool for converting 3D FBX and Alembic animations into VAT animations without the need of a 3D editing software.

Smart VAT saves texture space by excluding vertices that don't move. Increase the "No Move Tolerance" to optimize further by excluding vertices that only ever move slightly.

Smart VAT also detects if overlapping vertices exist. If 2 or more vertices are always within the "Same Pos Tolerance" from each other during every frame of the animation, Smart VAT generates texture Data only once and assigns it to all matches, once again saving on texture space.

Smart VAT can bake multiple meshes into a single one. Ideal for characters that have split parts. The object must be setup to use a single material, so no overlapping UVs.

Required Packages:

Alembic

Shadergraph

Timeline

Animation

ParticleSystem

Package Type

Extension Pack for BTGraph (Behavior Tree framework for Unity)

Editor-only registration hook integration.
No runtime reflection.
No dependency on BTGraph Pro.

Included Node Types

Composite Nodes

• Random Selector
• Weighted Random Selector
• Shuffle Sequence

Decorator Nodes

• Repeat (X Times)
• Repeat Until Success
• Repeat Until Failure
• Cooldown
• Timeout
• Delay

Execution Semantics

All nodes follow BTGraph lifecycle conventions:

• Proper Enter / Tick / Reset handling
• Stable child selection during Running state
• Per-instance state storage via NodeStateStore
• Multi-agent safe execution
• No mutable static runtime state

Deterministic Random Support

Weighted and uniform random nodes support deterministic execution when a Seed Key (Blackboard int) is provided.

• No global RNG state
• Instance-isolated random streams
• Predictable behavior for debugging and replay systems

Timeout & Timing Behavior

• Timeout only overrides children that are still Running
• No premature failure before child tick
• Delay and Cooldown handle edge cases (<= 0 values) safely
• Timing based on Unity time system (Time.time)

Performance Characteristics

• O(1) tick cost for decorators
• O(n) selection cost on Enter for weighted and shuffle nodes
• No per-tick allocations
• Cached buffers for weight and shuffle arrays
• No LINQ usage in runtime paths

Designed for scalability across multiple AI agents.

Editor Integration

• Registered via BTGraph public editor registry
• No assembly scanning
• No core source modifications required
• Deterministic search ordering (Group → Order → Title)
• Runtime and Editor separated via asmdef assemblies

Folder Structure

Assets/BTGraphControlFlowFree/

• Runtime/
• Editor/
• Demo/
• Documentation/

Fully self-contained and removable without affecting BTGraph core.

Assembly Definitions

• BTGraph.ControlFlow.Runtime
• BTGraph.ControlFlow.Editor

Explicit dependency references to BTGraph base runtime and editor assemblies.

Compatibility

• Unity 2021+ (recommended)
• Compatible with BTGraph base package
• Compatible with other BTGraph extension packs
• Does not require BTGraph Pro

Demo Scene

Includes a minimal showcase demonstrating:

• Weighted selection
• Cooldown constraints
• Shuffle execution
• Timeout behavior

No console spam. No Pro dependency.

Use Cases

• Enemy AI
• NPC logic
• Strategy / RTS AI
• Simulation systems
• Modular AI frameworks
• Decision-making layers
• Utility AI branch gating

Upgrade your Behavior Trees with advanced control flow and randomization nodes built specifically for BTGraph.

This free extension pack adds essential AI building blocks such as weighted random selection, shuffle sequences, cooldown decorators, repeat policies, delay, and timeout control — all designed for clean, modular, production-ready AI systems in Unity.

If you are building enemy AI, NPC logic, decision systems, or gameplay behaviors using Behavior Trees, this pack gives you the missing control structures needed to create dynamic, non-repetitive, and professional behavior logic.

What This Pack Adds

Randomization Nodes

• Random Selector
• Weighted Random Selector
• Shuffle Sequence

Create non-deterministic and natural AI behaviors with proper per-instance memory and optional deterministic seeding.

Control Flow Decorators

• Repeat (X Times)
• Repeat Until Success
• Repeat Until Failure

Control execution loops safely and predictably.

Time-Based Decorators

• Cooldown
• Timeout
• Delay

Add timing constraints to your Behavior Tree branches without custom scripting.

Designed for Professional AI Architecture

• No gameplay-system coupling (no animation, audio, or VFX dependencies)
• Fully modular extension for BTGraph
• Multi-agent safe runtime behavior
• No static mutable state
• Deterministic random option via seed key
• Zero runtime reflection
• Clean editor registration via BTGraph public hook
• Runtime and editor assemblies properly separated

This pack focuses purely on Behavior Tree control logic, making it suitable for:

• Enemy AI
• NPC decision systems
• Utility AI integrations
• Strategy or simulation games
• Large-scale AI systems
• Modular AI frameworks

Why Use This Pack?

Many minimal Behavior Tree implementations lack advanced control structures like weighted selection or proper timeout handling.

This pack fills that gap with:

• Production-grade execution semantics
• Stable selection during running states
• Proper lifecycle handling (Enter / Tick / Reset)
• Predictable timeout behavior
• Clean integration with BTGraph editor

Included Demo Scene

A lightweight demo scene is included to showcase:

• Weighted random branch selection
• Cooldown constraints
• Shuffle execution order
• Timeout handling

The demo is minimal and focused on logic clarity.

Requirements

Requires BTGraph (base package).

No BTGraph Pro required.

Perfect Companion To

• Utility AI Pack for BTGraph
• Perception Pack for BTGraph
• Tactics Pack for BTGraph

Uses Editor code and abstact classes to implement a easy to use maths configuration code

MathsEngine is a modular, node-based math evaluation system for Unity. Define any mathematical formula as a reusable ScriptableObject graph and evaluate it at runtime with a single line of code — no hardcoded logic, no formula spaghetti in your MonoBehaviours.

Whether you're building RPG damage calculations, AI scoring, procedural generation curves, or physics rules, MathsEngine keeps your math clean, inspectable, and entirely designer-friendly.

☄️ HIGHLIGHTS ☄️

– Node-Based Formula Graphs – ScriptableObject-Driven – Runtime Parameter Support – Live Equation Preview – Arithmetic, Trig, Utility & Random Nodes – AnimationCurve Integration – Unity Time Nodes – Fully Extensible Custom Nodes – Package Manager (UPM) Ready

• Node-Based Formula Graphs: Build complex expressions by composing small, reusable nodes into a tree. Nodes reference other nodes as inputs, and the graph evaluates from root to leaf to produce a single float result.

• ScriptableObject-Driven: Formulas are stored as MathFormula assets in your project. Tweak values directly in the Inspector without touching code — ideal for designers and non-programmers.

• Runtime Parameter Support: Pass dynamic values — player stats, enemy attributes, game state — into any formula at runtime using a simple variadic API: float result = formula.Calculate(playerAttack, enemyDefense);

• Live Equation Preview: Every formula auto-generates a human-readable equation string via ToEquation(), displayed directly in the Inspector for instant debugging and validation. e.g. (5 + 3) * 2 = 16

• Rich Built-In Node Library:

• Arithmetic: Add, Subtract, Multiply, Divide, Modulo, Power, Absolute, Negate
• Trigonometry: Sin, Cos, Tan, Atan2, Deg2Rad, Rad2Deg
• Utility: Min, Max, Clamp, Lerp, InverseLerp, SmoothStep, MoveTowards, PingPong
• Animation: AnimationCurve evaluation from any node value
• Time: Time, DeltaTime, FixedDeltaTime
• Constants: ConstantNode
• Random: UnityRange, XorShift32 RNG

• Fully Extensible: Create custom nodes by subclassing BaseMathNode and implementing Calculate() and ToEquation(). Custom nodes integrate into any MathFormula graph with no additional setup.

• UPM Ready: Installed directly via Unity Package Manager using a Git URL — no .unitypackage import required.

☄️ REQUIREMENTS ☄️

Unity Version: Compatible with Unity Package Manager (UPM). Minimum tested version not yet officially specified — verify against your project's Unity version before installing.

Dependencies: No third-party package dependencies. Relies solely on built-in UnityEngine APIs (Mathf, AnimationCurve, Time, Random).

Scripting Backend: Compatible with both Mono and IL2CPP.

Render Pipeline: No render pipeline dependency. This is a pure runtime/logic package — compatible with Built-in, URP, and HDRP.

Platform Support: No platform-specific restrictions. Pure C# runtime logic runs on all Unity-supported platforms.

☄️ INSTALLATION ☄️

1. Open Window → Package Manager
2. Click + → Add package from git URL
3. Enter: https://github.com/arijeetbaruah/Maths-Engine.git?path=Packages/com.arijeet.mathsengine/MathsEngine

📖 Documentation: https://arijeetbaruah.github.io/Maths-Engine/

• Unity: 2019.4 or newer
• Render pipeline: Built-in (UI)
• Platforms: Windows, macOS, Linux, WebGL, Android, iOS
• Shader: UI/Tutorial Spotlight, single pass, no textures, target 2.0, optimized for mobile and Web
• Scripts: C# (TutorialSpotlightSetting, TutorialSpotlightManager, TutorialSpotlightImage)
• Dependencies: Standard Unity UI only (Canvas, Image, RectTransform)

Key features of your package

Fullscreen dark overlay with a rectangular “hole” around the selected button or UI element
Soft hole edges and configurable overlay color and opacity
Clicks in the hole reach the button; the rest of the screen blocks input
Optional “tap here” finger graphic with offset and its own pulsation
Separate pulsation for hole and finger (speed and intensity each)
Turn overlay on/off in the inspector or from code
TutorialSpotlightManager: assign overlay once, then call ShowSpotlight(button), HideSpotlight() from UI or code
Editor preview without Play mode
Material is only used when the Tutorial Spotlight shader is assigned (does not affect UI/Default)
Shader optimized for mobile and WebGL (no textures, single pass)
Includes: shader, 3 scripts, example material and scene, README (EN/RU)

**Tutorial Spotlight** is a ready-to-use UI solution for tutorials and onboarding. It draws a fullscreen dark overlay with a rectangular “hole” around the button or UI element you choose. Only the hole is clickable; the rest of the screen is dimmed and blocks input. Optional finger / “tap here” graphic with its own pulsation. Control everything from the inspector or via **TutorialSpotlightManager** (ShowSpotlight, HideSpotlight, SetSpotlightTarget). Works in the editor without Play mode. Shader is optimized for mobile and WebGL (no textures, single pass, target 2.0).

Package Type
BTGraph extension module (requires BTGraph)

Unity Version
Built and tested with Unity 6.0 LTS and newer
Compatible with later LTS versions

Core Architecture

• Native Utility Selector node integrated into BTGraph
• Score-based child selection system
• Deterministic evaluation order by default
• Continuous reevaluation support
• Safe branch switching during runtime execution
• No reflection dependency for core functionality
• Reflection-based enhancements only when BTGraph Pro is present

Scoring System

• Modular score source architecture
• Plug-and-play score modifiers
• Curve-based score evaluation
• Weight multipliers
• Clamp and threshold support
• Composable score pipeline
• Extensible base classes for custom score implementations

Debugging & Visualization

• Live runtime score overlay
• Winner and candidate score display
• Score breakdown visualization
• Utility Score Inspector editor window
• Score history sparklines
• Lightweight opt-in recording system
• Low-overhead design suitable for runtime builds

Performance

• Minimal runtime allocations
• Clean modular C# architecture
• No per-frame garbage generation in core evaluation
• Suitable for multiple agents
• Designed for production scalability

Included Content

• Example Utility AI scenario (Attack / Flee / Heal / Celebrate)
• Sample scene
• Sample BTGraph tree asset
• Helper generator utilities
• Editor tools for score inspection

Dependencies

• Requires BTGraph
• BTGraph Pro optional (enhanced debugging integration)

Bring intelligent, score-driven decision-making to your BTGraph Behavior Trees with a fully integrated Utility AI system designed for production use.

The Utility AI Pack adds a native Utility Selector node to BTGraph, enabling smart action selection based on dynamic scoring. Instead of rigid priority order, actions compete using composable score sources, curves, weights, clamps, and thresholds — resulting in responsive, adaptive AI behavior.

This is not a bolt-on framework. It follows BTGraph’s naming conventions, patterns, and authoring workflow to feel like a natural extension of the core system.

Smart Score-Based Decisions

• Add Utility AI to existing BTGraph trees
• Native-feeling Utility Selector node
• Composable scoring with plug-and-play score sources and modifiers
• Fine-tune behavior using curves, weights, clamps, and thresholds
• Continuous reevaluation for real-time adaptive AI
• Safe branch switching while actions are running

Rich Runtime Visualization (No Pro Required)

The Utility AI Pack includes powerful debugging tools out of the box:

• Live runtime score overlay (winner, candidates, breakdown)
• Utility Score Inspector editor window
• Live score values with history sparklines
• Lightweight opt-in recording with low overhead
• Deterministic scoring by default

Designed for tuning, iteration, and showcasing AI behavior without performance penalties.

Optional BTGraph Pro Integration

When BTGraph Pro is installed, the Utility AI Pack integrates seamlessly via reflection-based enhancements:

• Utility score panel inside the BTGraph Pro workflow
• Jump to winning child node for faster iteration
• Enhanced debugging experience

BTGraph Pro is fully optional and not required.

Production-Friendly Design

• Minimal allocations
• Clean, modular runtime architecture
• Deterministic scoring behavior
• No debugger feature duplication
• BTGraph-style authoring workflow

Built for real projects — not just demos.

Included Sample Content

• Complete example Utility AI scenario (Attack / Flee / Heal / Celebrate)
• Sample scene
• Sample BTGraph tree asset
• Helper generators for quick setup

Perfect for learning, tuning, and demonstrating Utility AI systems in action.

• Grid/Tiles: 16x16 pixel tiles.
• Environment: Animated water tiles and environmental props.
• Dimensions: Character ~32x32 px | Tileset 16x16 px.
• Format: Sprites with transparency, game-ready.

Pixel art asset kit specifically designed for Zelda-like top-down adventure games.

Main Features

• Characters: 1 fully animated female protagonist.
• Faune Anims (11): Walk (Up, Side, Down), Walk with Lift (Up, Side, Front), Run (Up, Side, Down), Push, and Faint.
• Environment: Beach tileset with animated water and wind-swung trees.
• Extras: High-quality character portrait for UI/dialogue.

• Grid/Tiles: 16x16 pixel tiles.
• Environment: Multi-layered parallax background
• Environment Dimensions: ~521 (looped) x 192 px
• Dimensions: Character (28x28 px Hero Scale) | Environment (Seamless loop).
• Format: Sprites with transparency, game-ready.

A complete pixel art character and environment kit for retro-style 2D action platformers.

Main Features

• Characters: 1 fully animated action hero (Blaster Joe).
• Blaster Joe Anims (18): Run, Idle, Shoot, Jump, Fall, Crouch, Run Shot, Roll, Throw, Spin (Front), Hurt, Slide, Ladder Climb, Hang, Victory, Ladder Shoot, Dash, and Crouch Shoot.
• Environment: Urban city scene with modular tileset for structures.