Asset Store newest packages

Render Pipeline:

• Universal Render Pipeline (URP)

Unity Versions:

• 2021 LTS

• 2022 LTS

• 2023 LTS

• 2024 and newer

Platforms:

• Windows

• Mac

• Linux

• WebGL (URP-supported features only)

• Mobile (performance varies by device)

Included Files:

• VHS_Final_Master.shader

• Custom Inspector (VHSInspector.cs)

• Custom Renderer Feature / Injector (VHSInjector.cs)

• Demo Scene (preconfigured camera + material)

• Example Material

• Documentation PDF

• Organized folder structure (Demo, Documentation, Shader, Scripts, Pipeline)

Dependencies:

• URP Renderer with Scriptable Renderer Feature support

• No external packages required

Features:

• Fisheye lens distortion

• Radial DSLR blur

• Chromatic aberration (flare + RGB split)

• Color bleeding / tape lag

• Glitch bands and RGB bursts

• Scanlines + warp

• Grain (BW + chromatic)

• Flicker, jitter, vertical jump

• Blackout / dropout events

• Fully toggle-based modular system

File Structure:

Assets/

VHS/

Demo/

Documentation/

Pipeline/

Scripts/

Shader/

Materials/ (optional)

Textures/ (optional)

Known Limitations:

• Built-in Render Pipeline is not supported

• HDR

VHS FINAL MASTER – Analog Horror & Retro Distortion Suite (URP)

Bring authentic VHS, CRT, and analog horror distortion to your Unity project with the Fringe Logic VHS Final Master shader. This is a complete, modular, screen‑space effect designed for URP, featuring a full stack of retro artifacts, tape damage, lens distortion, glitch bands, scanlines, color bleeding, grain, jitter, and more.

Perfect for:

• Analog horror

• Retro aesthetics

• Found‑footage games

• VHS/CRT UI overlays

• Stylized glitch effects

• Cinematic distortion

The shader is fully modular — every effect can be toggled on/off individually. No scripting required.

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

FEATURES

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

• Blackout / Tape Dropout

• Fisheye Lens Distortion (Hybrid Projection)

• DSLR‑Style Radial Blur (Edge‑Weighted)

• Vignette & Border Darkening

• Chromatic Aberration (Radial Flare)

• Constant RGB Split

• Color Bleeding / Tape Lag

• Glitch Bands (Head Clogging)

• RGB Burst Events (Random or Scrolling)

• Static Grain (BW)

• Chromatic Color Grain (Chunky RGB Noise)

• Scanlines (Density, Speed, Rotation, Warp)

• Scanline Warp Layer

• Screen Flicker

• Vertical Jump

• Frame Jitter (Micro‑Shake)

• Fully toggle‑based system

• Clean inspector layout

• URP‑native blit pipeline

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

WHAT’S INCLUDED

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

• VHS Final Master Shader (URP)

• Custom Inspector

• Custom Renderer Feature (Injector)

• Demo Scene (ready to run)

• Documentation PDF

• Example Material

• Organized folder structure

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

EASY SETUP

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

1. Add the included renderer feature to your URP Renderer.

2. Assign the VHS material.

3. Press Play — the effect is active immediately.

4. Adjust settings in the material inspector.

No scripting required.

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

DEMO SCENE

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

The included demo scene shows the effect immediately when entering Play mode.

The camera is pre‑configured with the injector and material.

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

PIPELINE & COMPATIBILITY

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

• Render Pipeline: Universal Render Pipeline (URP)

• Unity Versions: 2021 LTS, 2022 LTS, 2023 LTS, 2024+

• Platform: Windows, Mac, Linux

• Works in 2D and 3D projects

• Works with UI and world‑space cameras

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

SUPPORT

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

For support, updates, or inquiries:

Email: your-email-here

Portfolio: https://yourusername.github.io/

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

Jelly Loop Jam – Sorting Puzzle Template + Editor is a complete game development template designed for creating and customizing jelly color-sorting puzzle games where players tap bowls to collect matching jelly balls extracted from a softbody image on a conveyor belt. The gameplay structure is inspired by popular hyper-casual sorting titles, such as Sand Loop, Sand Jam, and Jelly Loop.

It includes a full gameplay loop, Voronoi-based softbody jelly physics simulation, automatic level generation from photographs, three in-game boosters, and a fully featured in-game level editor with JSON import/export support. All systems are modular, data-driven, and easy to extend, making this template ideal for game jams, rapid prototyping, and production-ready casual or hyper-casual puzzle games.

🕹️ Try First: Browser Demo | Android Demo

OUR ADVANTAGES

• Developer-oriented architecture
• Clear documentation and setup workflow
• Built-in level editor and editor utilities
• Easy visual, color, and gameplay customization
• Clean, modular, and extendable Unity codebase

TEMPLATE INCLUDES

🪼 Jelly Sorting Puzzle Gameplay ‎ ‎ ‎ ‎ 

• Voronoi-based soft-body jelly ball physics simulation
• Tap-to-sort bowl mechanic with BFS pathfinding click detection
• Conveyor belt system with jelly extraction and liquid fill animations
• Color-coded bowls with mystery bowl support (hidden colors)
• Smooth and satisfying hyper-casual puzzle gameplay loop
• Voronoi-based soft-body jelly ball physics simulation
• Tap-to-sort bowl mechanic with BFS pathfinding click detection
• Conveyor belt system with jelly extraction and liquid fill animations
• Color-coded bowls with mystery bowl support (hidden colors)
• Smooth and satisfying hyper-casual puzzle gameplay loop

🏗️ Level Editor & Data System ‎ ‎ ‎ 

• 220 Unique levels included
• Built-in level editor scene integrated with the Unity Editor (no Play mode required)
• Visual bowl grid editor with Select Bowls and Edit Cells modes
• Image import tool with inline palette editor and re-rollable K-means++ color seeds
• Automatic color distribution based on image coverage
• JSON-based level export and import system
• Auto Level Generator for batch-creating levels from image folders
• Configurable ranges for colors, grid size, mystery bowls, and booster countsBuilt-in level editor scene integrated with the Unity Editor (no Play mode required)
• Visual bowl grid editor with Select Bowls and Edit Cells modes
• Image import tool with inline palette editor and re-rollable K-means++ color seeds
• Automatic color distribution based on image coverage
• JSON-based level export and import system
• Auto Level Generator for batch-creating levels from image folders
• Configurable ranges for colors, grid size, mystery bowls, and booster counts

🎮 Boosters & Gameplay Systems ‎ ‎ ‎ ‎ 

• Three built-in boosters: Extra Slot, Shuffle, and Magic Pick
• Level-based booster unlock system with tutorial popups
• Extendable booster architecture for adding custom abilities
• Flexible per-level booster configuration through JSON

🎨 Color & Visual Tools ‎ ‎ ‎ ‎ 

• K-means++ image quantization system for converting images into jelly grids
• Re-rollable seed system for generating varied color palettes
• Voronoi soft-body rendering with adjustable physics parameters (gravity, damping, jiggle)
• Easy replacement of materials, models, and visual effects

🧪 Developer & Debug Tools ‎ ‎ ‎ ‎ 

• In-game Developer Settings panel for level navigation and ad testing
• Keyboard shortcuts for fast level switching and booster unlocking
• Clean namespace structure
• Modular GameManager architecture

🎨 Customization Friendly ‎ ‎ ‎

• Easily replace visuals, UI elements, and animations
• JSON-driven level configuration with no hardcoded gameplay rules
• Generate new levels instantly by importing your own images
• Designed as a flexible foundation template rather than a locked system

📱 Mobile Ads Network ‎ 

• AdMob integration for banner, interstitial, and rewarded video ads
• Dummy ad provider for safe testing in the Unity Editor without a real AdMob account

💿 Supported Platforms ‎ ‎ ‎ ‎ 

• iOS
• Android
• WebGL
• Desktop

📄 Documentation

Online Documentation

Includes step-by-step guides for:

• Setting up the game scene and running your first level
• Using the Level Editor to design and configure bowl grids
• Importing images and generating levels with K-means++ quantization
• Exporting and importing JSON level files
• Adding and customizing boosters
• Extending the template for your own jelly sorting or hyper-casual puzzle game

📬 Support

If you have any questions or need assistance, feel free to get in touch:

📧 Email: ragendom@gmail.com

Technical Details

Asset Count

• 28 Unique Assets
• Variety of urban and utility props (Vehicles, Signage, and Street Furniture)
• Fully configured Prefabs included for all models
• StylisedPropsLayout scene included for quick demonstration

Included Assets Vehicles & Transport

• Ambulance2, PoliceCar2, HeliPad Street Furniture & Utility
• Bench, ParkBench, OutDoor Sitting, OutDoorStool, TrashCan, TrashBag, MailBox, VendingMaachine Signage & Traffic Control
• BusStopSign, NoEntrySign, NoParkingSign, SignBoard1, SignBoard2, StreetLamp, StreetLamp2, TrafficCone, Barrier, Barrier2 Buildings & Structures
• Building, LightHouse, WindMill Props
• Barrels, Bushes, Crates

Polygon / Vertex Count

• All assets are optimized for high-performance real-time rendering.
• General Props:
• Vertex Range: 300 – 1,800 vertices
• Clean topology designed for mobile and stylized PC games.
• Game-ready meshes with optimized geometry for VR and indie projects.

Textures

• Custom stylized textures including multiple atlases
• Format: PNG
• Resolution: 1024x1024
• Textures Included: * ColorPallete
• TextureAtlas5
• Specific sign textures (no-parking, bus sign, etc.)

Materials

• Materials are pre-configured with emission support
• Materials Included: * BusStopSign
• GoldEmission
• PurpleEmission
• All materials are properly assigned to prefabs for immediate use

Prefabs

• All models are available as ready-to-use prefabs inside:
• Assets/_Stylized_Props_Utility_Pack/Prefabs/
• Each prefab includes: * Standardized scale
• Correct pivot placement
• Pre-assigned materials and clean hierarchy

Performance

• Lightweight and mobile-friendly
• Highly optimized draw calls using the included TextureAtlas and ColorPallete
• Suitable for city builders, casual simulators, and stylized low-poly environments.

Scene Included

• StylisedPropsLayout demo scene included
• Demonstrates optimal asset placement and lighting setup.

Stylized Props Utility Pack is a collection of stylized 3D environment assets designed to help developers quickly create urban, roadside, and utility-themed scenes in Unity. The pack includes a variety of props such as vehicles, street lamps, barriers, benches, buildings, signboards, trash cans, bushes, and other environmental objects.

All assets are provided with FBX models, materials, textures, and ready-to-use prefabs, making them easy to integrate into any Unity project. The organized folder structure allows developers to quickly locate assets, while the included demo scene demonstrates how the props can be combined to create a complete environment.

This pack is suitable for simulation games, runner games, city environments, and stylized open-world projects, helping developers build scenes efficiently while maintaining a consistent stylized look.

• Unity version: 6000.3+ (Unity 6.3+).
• Type: Editor-only tool (no runtime dependency).
• Supported renderers: MeshRenderer, SkinnedMeshRenderer.
• Window path: Tools > Mesh LOD Visualizer.
• Features:
• Live LOD preview/range scrubber with camera marker.
• Scene overlay monitor with compact HUD.
• Scene Camera / Main Camera lens workflows.
• Renderer LOD bias controls and preview follow/lock flow.
• Mesh LOD details (triangles, vertices, transition distances).
• Scan Candidates for missing LOD data and heavy LOD0 meshes.
• Compatible with Built-in, URP, and HDRP editor workflows.
• Limitation: requires Unity Mesh LOD APIs available in Unity 6.3+.

Mesh LOD Visualizer for Unity 6 is an Editor extension focused on practical LOD tuning workflows. It helps you inspect how Mesh LOD levels switch, preview transition distances, and compare camera-driven behavior in Scene and Game workflows.

The tool provides a live LOD preview bar, scene monitor overlay, per-LOD triangle/vertex visibility, and direct controls for renderer bias and preview/override modes. It also includes a candidate scan workflow to quickly find meshes with missing Mesh LOD data or heavy LOD0 budgets and jump to them for correction.

This package is built for technical artists and optimization workflows that need clear, repeatable LOD validation inside the Unity Editor.

High-Performance UI Architecture

Built entirely with Unity’s modern UI Toolkit framework (VisualElements, UXML, USS).
No legacy IMGUI code ensures minimal editor overhead, smooth resizing, and stable performance.

Optimized for Large Projects

Virtualized ListView and GridView rendering display only visible elements, maintaining smooth navigation even with 5,000+ materials.

Responsive Interface

Flexbox-based responsive layout scales correctly across different resolutions, DPI settings, and 4K monitors.

💾 Data & Project Safety

ScriptableObject-Based Storage

Collections and folders are stored as standard .asset files using ScriptableObjects.

• Version control friendly (Git, PlasticSCM, Perforce)
• Reliable serialization
• Team workflow ready

Non-Destructive Workflow

The tool reads data via the AssetDatabase API and never modifies materials unless explicitly triggered by the user.

Clean Project Structure

Local user preferences are stored in EditorPrefs, avoiding temporary project files or hierarchy clutter.

🧠 Analysis & Processing

Smart VRAM Estimation

Memory usage is calculated using Profiler.GetRuntimeMemorySizeLong, with automatic texture reference de-duplication for accurate global statistics.

Duplicate Detection Algorithm

Potential duplicates are detected by comparing shader hash, active keywords, and texture references.

Asynchronous Preview Generation

Material previews load asynchronously to prevent editor freezes during browsing.

🔌 Compatibility

• Pipeline Agnostic: Built-in, URP, HDRP
• Unity Version: Tested and compiled for Unity 6 (2023.3+) and newer
• Editor Only: No runtime overhead

Analyze. Organize. Control.

📘 User Manual | 🛟 Support | 🎬 Demo Video

Stop drowning in unorganized materials. Apex Material Pro is the modern command center designed specifically for Unity 6 to help you master your project's visuals without modifying your assets or project structure.

Built with UI Toolkit, it integrates seamlessly with the Editor's dark theme for a fast, native experience.

🔍 ANALYZE – Know Your Costs

Stop guessing where your performance cost comes from.

• Scene & Project Scans — Detect all materials used in your scene or entire project.
• Material Cost Score — Identify expensive materials instantly (Low / Medium / High).
• Texture Analysis — Inspect resolution, format, and VRAM usage for every texture map.
• Shader & Keyword Tracking — Monitor active shader keywords and rendering settings.
• Duplicate Detection — Find identical materials (same shader, keywords, textures).
• Interactive Statistics — Click stats and graphs to filter results instantly.

📦 ORGANIZE – Build Your Workflow

Create a clean material workflow without changing your project structure.

• Custom Collections & Folders — Group materials logically using drag & drop.
• Favorites System — Keep important materials instantly accessible.
• Non-Destructive Organization — No file moves, no project restructuring.
• Persistent Collections — Stored as lightweight assets, shareable with your team.
• Grid & List Views — Visual browsing or data-driven inspection.

🎮 CONTROL – Take Action

Interact with your materials without leaving the tool.

• Select all objects using a material in one click.
• Toggle GPU Instancing instantly.
• Locate assets directly in the Project window.
• Filter materials by usage, rendering mode, or texture size.

Everything you need in one place.

SmartCopy copies and pastes all modifiable serializable fields across different unity objects, including:

• Public fields
• Private fields marked with [SerializeField]
• Fields marked with [HideInInspector]
• Nested serialized data

SmartCopy is a Unity Editor tool that lets you copy and paste serialized field values between any Unity objects by intelligently matching property path and type. It works across any built-in components, MonoBehaviours, and ScriptableObjects — even if they are unrelated classes — as long as their serialized fields match.

Learn more about the package's code here.

Key Features

• Global Mode: Automatically adds picker buttons to every compatible field project-wide. No manual setup required.
• Hierarchy Cycling: Use the Mouse Wheel while hovering to cycle through parent/child objects—perfect for picking a specific Button or Panel within a complex UI.
• Marquee Selection: Batch-assign multiple objects to Lists or Arrays by dragging a selection box (Shift + Drag) in the Scene View.
• Type Filtering: Automatically detects the required field type and filters out invalid targets.
• Quick Removal: Right-click objects directly in the Scene View to remove them from a List or Array.
• Attribute Support: Includes a [GameObjectPicker] attribute for explicit control when Global Mode is off.

GameObject Picker turns the Unity Inspector into an interactive experience. Instead of scrolling through hundreds of nested objects in your Hierarchy, you simply click the "dropper" icon on any field and pick your target directly from the scene.

Smart & Context-Aware:The tool isn't just a blind selector; it understands Unity’s type system. If a field requires a Light component, it will automatically filter the scene and only allow you to pick objects that contain a Light.

Who is this for?

• UI Developers: Navigate deep Canvas hierarchies effortlessly.
• Level Designers: Populate arrays and references for massive environments in seconds.
• Programmers: Speed up testing and reference assignment during rapid prototyping.

• Requires: BTGraph / BTGraph PRO
• Unity Version: (insert your supported version, e.g. 2021.3+)
• Fully compatible with BTGraph Core & Pro
• Event-driven dialogue runtime
• IQuestService interface for custom quest systems
• No reflection or heavy runtime dependencies
• No required third-party packages
• Works in 2D & 3D projects
• Zero external UI dependency
• Clean namespace separation

Build Complete Conversations — Not Just Trees

BTGraph – Dialogue & Quest Pack transforms your behaviour trees into fully interactive narrative systems.

Create branching dialogue, conditional choices, quest-aware conversations, and reactive NPC interactions — all inside the BTGraph editor.

No custom nodes required.
No hard-coded logic.
No external dialogue framework needed.

🎭 Dialogue Features

• Start / End Dialogue nodes
• Dialogue Line node (speaker, tags, optional metadata)
• Choices node with:
  Visible conditions
  Enabled conditions
  On-select effect lists
• Jump / Flow control
• Continue / Await input
• Random / Weighted dialogue (barks support)
• Once & cooldown gating

The included Dialogue Runner and Simple UI prefab allow immediate use without writing additional systems.

🧭 Quest Integration (Out of the Box)

Connect dialogue directly to your quest logic.

• Offer, complete, fail quests
• Set and advance quest stages
• Add quest progress
• Set / clear flags
• Raise quest events
• Wait until quest conditions are met
• Branch based on quest state, stage, progress, or flags

Includes a lightweight SimpleQuestService for immediate testing and prototyping.

For production use, implement the provided IQuestService interface to connect your own quest system seamlessly.

⚙️ Professional Architecture

Designed with clean integration in mind:

• UI-agnostic runtime (event-driven Dialogue Runner)
• Blackboard-compatible service resolution
• Minimal allocations and tick-safe nodes
• Modular design that extends BTGraph cleanly
• Works with existing BTGraph projects

This pack does not replace your quest system — it connects to it.

🎮 Example Use Cases

• NPC quest givers
• Reactive conversations based on player progress
• Branching RPG dialogue
• Dynamic city barks
• Multi-stage objective updates
• Conditional turn-in conversations

📦 What’s Included

• Dialogue nodes
• Quest integration nodes
• Condition and effect nodes
• Dialogue Runner component
• Simple Dialogue UI prefab
• SimpleQuestService demo implementation
• Example scenes
• Documentation

Editor version: 2022.3.26f1 and above

Right-click → generate MonoBehaviours, ScriptableObjects, enums, interfaces, and more.

What this tool does

C# Script Templates is a lightweight Unity Editor extension that adds a dedicated Project window context menu for creating C# scripts from templates. It removes repetitive boilerplate and eliminates the “create MonoBehaviour → delete inheritance → rewrite class” loop.

Key features

• Right-click → C# Script Templates → create scripts instantly.
• Root namespace friendly: templates can wrap code in the configured root namespace (and format cleanly using indentation-safe templates).
• Editor-only: no runtime overhead, no scene objects, no dependencies.

Included creators/templates

MonoBehaviour

• MonoBehaviour Script
• Abstract MonoBehaviour
• Virtual MonoBehaviour

Data / Assets

• ScriptableObject Script

C# Basics

• Empty Class
• Static Class
• Interface

Enums

• Enum
• Serializable Enum

Customization

Add your own templates by dropping .cs.txt files into your templates folder and wiring a menu item to create them—use this package as a starting point for a studio-wide standardized script workflow.

It's a production-ready Unity toolkit for building clean, decoupled gameplay communication without fragile object references.

It combines three core workflows in one package:

• EventBus<T> for global, code-first events between systems.
• ScriptableObject Event Channels for designer-friendly Inspector wiring.
• AnimationEventManager for turning any animation event into gameplay signals with simple key-to-channel mapping.

This asset is designed to reduce boilerplate, improve scene-to-scene reliability, and keep event logic scalable as your project grows.

Why It’s Useful

• Build features faster with less coupling between gameplay systems.
• Give designers a safer event workflow without writing code for every connection.
• Trigger gameplay directly from animation timing without custom one-off scripts.
• Keep runtime behavior predictable with explicit subscription lifecycle patterns.

Check documentation 

If any questions or problems, write on Discord

Number of textures: 22

Texture dimensions: 2048x2048 and 512x512

Polygon count: 12000 tris

Number of meshes/prefabs: 4 / 20

Rigging: Yes

Animation count: 108

Animation type list: In Place and Root Motion

UV mapping: Yes

LOD information: No

Types of materials: PBR

This asset has CARTOON FOX family models - adult and cub.

The model has 51 bones and 12000 tris.

Texture maps - albedo, AO / metallic / roughness, normal map (all 2048x2048).

Separate model for mobile phones with 3500 triangles.

100+ animations (IP/RM):

Attack (bite, move bite, front, left, right, jump, down), hit (front, back, middle), death (left, right), digging (start, loop, end), idle 1-7, eat, eat tear, drink, lie 1-2, lie belly 1-2, sleep, sleep belly, 15 stages jump (start, start forward, start place, fly up, fly up forward, fly horizontal, fly down high, fly down high forward, fly down low, fly down low forward, land, land forward, land place, fall edge, hooked and climbed), jump (forward, run, place), crouch move (front, left, right, back, back left, back right), crouch (idle 1-2, turn left, turn right), walk (front, left, right, back, back left, back right ), trot (front, left, right), run (front, left, right ), run fast (front, left, right ) swim (enter, front, left, right, back, back left, back right ), turn (left, right), turn 180 (left, right ), sitting (start, end, idle 1-2), scratch ear, etc.

The animator controller is missing.

If you have questions, then write to the mail:

RedDeer3D@gmail.com

● Unity 2021.3+: Compatible with Unity 2021 LTS and above

● No External Dependencies: Self-contained — no third-party packages required from Asset Store

● Dual Backend: LibGit2Sharp for fast local operations + Git CLI for remote operations (fetch, pull, push, stash, LFS)

● Dark & Light Theme: Full support for Unity Pro (dark) and Personal (light) editor skins

● FileSystemWatcher: Auto-detects repository changes and refreshes status automatically

UniGit brings a complete Git workflow directly into the Unity Editor. No more switching between Unity and external Git clients — manage your entire version control workflow from a single editor window.

Core Features:

● Setup Wizard — Guided 4-step setup: Git detection, user info, GitHub OAuth login, and project initialization

● Changes Tab — View modified files, stage/unstage, commit with message templates, and search/filter files

● History Tab — Browse commit history with virtual scrolling, view diffs, cherry-pick commits or individual files

● Pull Requests Tab — View, create, and merge GitHub PRs with reviews and comments, right inside Unity

● Conflict Resolver — Resolve merge conflicts with side-by-side comparison, Accept Ours/Theirs, and CSV cell-level diffing

● 3 Diff View Modes — Unified, Split (side-by-side), and CellSplit (CSV-aware) with inline character-level highlighting

● Branch Management — Create, switch, rename, delete, and merge branches from the toolbar

● Stash Support — Stash all or selected files, apply, pop, and drop with full diff preview

● Project Overlay — Color-coded status indicators on every file and folder in the Project window

● File History — Track the full history of any file with git log --follow

● LFS Support — Track, lock/unlock, push, pull LFS files directly

● Keyboard Shortcuts — Ctrl+C (commit), Ctrl+P (push), Ctrl+Shift+P(pull), Ctrl+R (fetch), Ctrl+F (search), and more

GitHub Integration:

● OAuth Device Flow authentication

● Browse and manage Pull Requests with reviews and comments

● Create repositories and clone from your GitHub account

※ Built for real projects — UniGit was developed and battle-tested in production game development. Every feature exists because we needed it.

• Gettext-first pipeline for Unity (.po/.pot).
• Runtime API:
• HyperPOLocalization.GetString(...)
• HyperPOLocalization.GetStringContext(...)
• HyperPOLocalization.GetPlural(...)
• HyperPOLocalization.GetPluralContext(...)
• Context (msgctxt) and plural (msgid_plural / msgstr[n]) support.
• Selection-based extraction from Unity assets.
• POT generation and update workflow from extracted manifest data.
• Poedit-compatible flows:
• Template-based (Create/Update POT)
• Update from Code with generated Temp/*.php.
• Extraction metadata attributes:
• TranslationComment
• TranslationContext
• TranslationPlural
• DontTranslate
• Project Settings integration for extraction presets, regex rules, and path configuration.
• Diagnostic Console messages with stable IDs (HPO-xxx).
• No required third-party dependencies.
• Includes demo scene and sample language files (demo_en.po, demo_es.po).

Hyper PO Localization is a production-focused Unity localization toolkit built around standard Gettext files (.po, .pot).

With Hyper PO Localization, you can extract translatable content from selected Unity assets, generate/update POT templates, translate in Poedit, and load languages at runtime from StreamingAssets/Languages.

It is battle-tested and actively maintained through real production use in our in-development game (Littlelands) and designed for small-medium indie teams that want a clean workflow without spreadsheet-heavy pipelines or fragile string-ID systems.

✨ Why this workflow works well:

• All text is stored in portable, version-friendly .po/.pot files. a widely used translation format, so many translators can work with it immediately.
• You can send translation files directly to translators without giving Unity project access.
• Non-technical collaborators can create or update translations using familiar tools like Poedit.
• Context (msgctxt) and plural forms (msgid_plural, msgstr[n]) are built into the format.
• You avoid maintaining custom Excel sheets and complex identifier tables for daily translation work.

✨ The package includes editor tools for extraction settings, presets, language paths, and translation status checks, plus a one-click sample installer and bilingual documentation (EN/ES). Included tooling and API:

• Editor workflow for Extract Strings, Create POT, and Update POT.
• Project Settings for extraction presets, regex rules, and path configuration.
• Runtime methods:
• HyperPOLocalization.GetString(...)
• HyperPOLocalization.GetStringContext(...)
• HyperPOLocalization.GetPlural(...)
• HyperPOLocalization.GetPluralContext(...)
• Diagnostic logs with stable IDs (HPO-xxx) for easier support/debugging.
• One-click sample installer and bilingual documentation (EN/ES).

✨ See documentation online

• All platforms — editor-only tool, generated output is standard ScriptableObjects and enums with no platform-specific code
• 97 C# scripts (23 Runtime, 74 Editor)
• 2 assembly definitions: SimpleEnemyForge.Runtime, SimpleEnemyForge.Editor
• 1 demo scene (.unity)
• 19 HTML documentation pages + 1 CSS stylesheet
• No third-party dependencies
• No runtime dependencies — entire toolset is editor-only, generated output has zero framework overhead
• Optional dependency: Simple Attribute Forge (detected automatically at edit time via reflection, never a hard reference)
• Optional dependency: Simple Item Forge (detected automatically at edit time via reflection, never a hard reference)
• 6 runtime helper classes included: SimpleSpawnRoller, SimpleSpawnEvaluator, SimpleScalingHelper, SimpleWaveRunner, SimpleBehaviorEvaluator, SimpleFactionHelper
• 6 genre templates: RPG, Soulslike, Survival, Tower Defense, Sci-Fi, RTS

Still designing enemies for your game by hand?

Seriously. Stop it.

Simple Enemy Forge gives you 7 interconnected wizard tools that generate production-ready enemy databases, squad formations, spawn tables, scaling profiles, wave sequences, behavior systems, and faction networks — complete with type-safe enums, custom ScriptableObject inspector editors, and full JSON supported content generation support!

Offline documentation available here!

THE SEVEN FORGES

• Enemy Forge — Define enemies with dynamic properties, icons, and optional modifier and loot table linking. 5-step wizard with 6 genre templates (RPG, Soulslike, Survival, Tower Defense, Sci-Fi, RTS).

• Squad Forge — Build enemy groups with named slots, per-slot counts, and custom properties. Links to your Enemy Database for validation.

• Spawn Forge — Design spawn tables with weighted pools, context conditions, and weight modifiers. Supports nested pool references and conditional spawning logic.

• Scaling Forge — Create scaling profiles with per-property rules. Choose from 7 scaling formulas (Linear, Exponential, Logarithmic, Polynomial, S-Curve, Step, Diminishing Returns). Live slider preview shows scaled values at any level.

• Wave Forge — Compose wave sequences with multi-wave timelines, per-entry spawn delays, enemy or squad toggles, loop settings, and difficulty scaling per loop. Links to both Enemy and Squad Databases.

• Behavior Forge — Define condition-to-action rule sets with priority-based conflict resolution and cooldowns. Reuses spawn conditions for consistency across your project.

• Faction Forge — Build faction networks with an NxN relationship matrix, symmetric stance editing, and dynamic properties per faction.

DYNAMIC PROPERTY SYSTEM

• No hardcoded fields.
• You define your own Categories, Flags, Numerics, and Texts in each wizard.
• Your game, your properties — works for any genre.

JSON-POWERED CONTENT PIPELINE

• Export your schema as Full JSON, Light JSON, or Markdown.
• Generate your enemies either by hand or paste into an AI LLM of your choosing.
• A detailed, verbose JSON schema allows you to generate literally hundreds or even thousands of enemies for your databases.
• Generate squads, spawn tables, scaling profiles, wave sequences, behavior profiles, or faction definitions based on these generated enemies that import directly into your database.
• Every JSON schema includes detailed AI instructions, format examples, and validation guidance.

GENERATED CUSTOM EDITORS

• Every wizard generates a professional Inspector editor alongside the database — split-panel layout, search, sort, filter by category, multi-select with bulk operations, and pagination.
• No Unity's default "Element 0, Element 1" entries in your Inspector.

WHAT GETS GENERATED (per wizard)

• Type-safe enum of all codes
• ScriptableObject database with full runtime API
• Custom Inspector editor with search, sort, filter, pagination
• Populated .asset file with all your data

RUNTIME HELPERS

• SimpleSpawnRoller — Roll weighted spawn tables with context-aware condition evaluation
• SimpleSpawnEvaluator — Preview spawn probabilities and validate table configurations
• SimpleScalingHelper — Apply scaling profiles to enemy stats at any level
• SimpleWaveRunner — Simulate wave sequences with play, pause, stop, and skip controls
• SimpleBehaviorEvaluator — Evaluate behavior rules with priority resolution and cooldown tracking
• SimpleFactionHelper — Query faction relationships and stance lookups

SIMPLE ATTRIBUTE FORGE INTEGRATION (Optional)

• When paired with Simple Attribute Forge, unlock modifier references on enemies.
• Fully automatic detection — just import both packages.
• Own both packages? They become one connected system.
• Import Simple Attribute Forge into the same project and Simple Enemy Forge automatically detects it — no setup, no configuration, no code changes.
• Every enemy gains a Modifiers section in the wizard and in the generated custom editor — drag-and-drop links to Simple Attribute Forge Modifier ScriptableObjects.
• Apply complex stat modifications, timed buffs, conditional effects, and stacking bonuses directly to your enemies.
• The JSON content pipeline is SAF-aware too.
• Schema exports include modifier format and AI instructions for generating enemies with modifier integration.
• Everything round-trips safely. Remove Simple Attribute Forge from your project — zero compilation errors, your databases still work, SAF data is preserved in the serialized fields.
• Re-import SAF later and it all comes back. No lock-in, no broken builds.

SIMPLE ITEM FORGE INTEGRATION (Optional)

• When paired with Simple Item Forge, unlock loot table linking on enemies.
• Fully automatic detection — just import both packages.
• Every enemy gains a Loot Table section in the wizard and in the generated custom editor — link enemies to loot tables from your Simple Item Forge Loot Database.
• Drop tables, boss loot, rare spawns — connect your enemy system directly to your item economy.
• The JSON content pipeline is SIF-aware too.
• Schema exports include loot table codes and AI instructions for generating enemies with proper loot references.
• Everything round-trips safely. Remove Simple Item Forge — zero errors. Re-import later — links restored.

INCLUDES

• 19-page HTML documentation (multi-page + single-page format)
• 1 demo scene: Bestiary Data Browser (browse enemies, squads, spawn tables, scaling previews, wave simulations, behavior evaluation, and faction relationships in a 7-tab interactive UI)
• 6 genre templates with example enemies
• Zero runtime dependencies — generated output is plain ScriptableObjects and enums

• Type: Editor extension (Editor-only assemblies)
• Core APIs: AssetPostprocessor preprocess hooks, Unity Presets
• Data: ImportRuleSet ScriptableObject, ordered rules, last-match-wins
• Entry point: Tools/Import Settings Rule Engine

Import Settings Validator & Fix keeps your project’s import settings consistent across Textures, Audio, and Models. Define your standards once using simple rules, and the tool makes sure every matching asset follows them automatically.

Create rules based on folder paths and asset type, then link each rule to a Unity Preset. From that point on, every new import or reimport is checked and corrected if needed. This prevents drift, reduces manual setup, and keeps teams aligned without constant oversight.

You can also scan the entire project at any time. The Validator shows which assets are compliant and which are not, grouped by type. For each asset, you can see which rule matched and what settings differ. Fix selected items or fix everything in the current view, with confirmation before changes are applied.

A dry run mode lets you preview what would change before enforcing it. The tool only reimports assets when settings actually differ, avoiding unnecessary processing. Clear logging and a simple Explain view make it easy to understand why a rule applied.

A compliance report can be exported for reviews, team handoff, or internal checks.

This version supports Textures, Audio, and Models. Rules are edited in the Inspector and use standard Unity Presets. The tool enforces the standards you define. It does not automatically guess optimal settings. It runs in the Editor only and does not add runtime code.

Features

217+ procedural primitives (2D, 3D, 4D, parametric, fractals)

Rule-Based Level Design (12 genres: platformer, tower defense, endless runner, puzzle, shooter, etc.)

Advanced Platformer Wizard (complete platformer with menu, level select, options)

Asset Generator (export primitives to PNG/JPG/TGA with 7 styles)

Audio Generator (procedural MIDI music by genre)

Materials Creation (generate, validate, verify materials)

Protection Tool (build obfuscation)

Installer Package Tool (create standalone installers)

Supported OS

Windows, macOS, Linux (Unity Editor)

Build targets: Windows, macOS, Linux, Android, iOS, WebGL

Documentation

Documentation/00_Overview.md (in package)

User guides (00–14) for tools, primitives, API, FAQ

GlyphAureaLabs ENTERPRISE is an all-in-one 2D game toolkit for Unity: procedural graphics, level design wizards, asset creation, and build tools.

Asset Generator (3 modes in one window)

The Asset Generator has three modes, switched via toolbar buttons:

1. Primitive Asset Generator

Export 217+ procedural primitives (2D, 3D, 4D, parametric, fractals) to PNG, JPG, or TGA. Select from categories, set size (128–4096), color, and 7 visual presets (Wireframe, Glow, Outline, Neon, Shadow, etc.), choose views (Front, Isometric, Top, Side, Custom), and batch export. Supports 4D polytope rotation and single or batch export.

2. Trim Image

Trim and crop raster images. Load a texture, then use removal tools (Freehand Erase, Rectangle Selection, Color Picker, Magic Wand) to remove areas. Set output size (Pixels or Percentage), keep aspect ratio, and export trimmed result. Includes Undo/Redo/Reset for editing.

3. Image Conversion

Convert raster images into vector-style graphics. Load an image, extract lines and fill (CV-based), apply style presets (Blueprint, Neon, Clean, etc.), and export. Useful for turning photos or sketches into game-ready line art or stylized assets.

Audio Generator

Generate procedural MIDI background music by genre. Customizable tempo, key, and structure. Use as placeholder or foundation for audio in your game.

Materials Creation

Materials workflow with submenu:Create Materials Showcase — Preview materials in a demo scene

Generate All Materials — Bulk material creation

Validate Headers — Check material metadata

Verify Material-Shader Links — Validate shader references

Open Liaison Map — View material–shader relationships

Open Specification — Inspect technical spec

Protection Tool

Obfuscation workflow in 3 steps:(STEP 1) Setup Raw Scenes For Protection Testing — Prepare scenes

(STEP 2) Add Protection Tools — Apply obfuscation (LIGHT, MEDIUM, HEAVY, MAXIMUM)

(STEP 3) Verify Protected Tools — Confirm protection is applied

Installer Package Tool

Package your build into a standalone installer for distribution. Creates ZIP archives and optional Setup.exe with Program Files, Start menu, and Desktop shortcuts.

Rule-Based Level Design (12 Genres)

Generate levels from prefabs, rules, and profiles. Genres:2D Platformer, Top-Down, Tower Defense, Endless Runner

Puzzle, 2D Shooter, Beat 'em up, Metroidvania

Survival / Base building, Fighting / Arena, Roguelike / Dungeon, Racing

8-step wizard: Profile → Folders → Scan → Review → Rules → Validate → Config → Generate. Uses prefab catalogs and conventions per genre.

Advanced Platformer (Non Rule-Based)

One-click 2D platformer: Main Menu, Level Select, Options, and multiple game levels. Pre-built UI, input, save, and game flow.

Customizable & Production-Ready

Prefabs, rules, and conventions are designed to be customized. Documentation (00–14), prefab conventions per genre, API reference, and troubleshooting guides are included. Works with Built-in and URP, Unity 2019.4+.

Version: 1.0
Unity compatibility: 2021.3+
Platforms: Editor (Windows, macOS, Linux)
Render pipelines: Built-in, URP, HDRP compatible
Dependencies: None
Setup required: No
Source included: Yes

Features included:

• PlayerPrefs viewer
• Inline value editing
• Key creation system
• Delete & confirmation system
• Undo changes per key
• Favorites & filtering
• Prefix grouping
• Batch operations
• Snapshot export/import
• Diff comparison system
• Restore from snapshot
• Editor auto-refresh

MAG PlayerPrefs Studio is a professional Unity Editor tool designed to make working with PlayerPrefs faster, cleaner and safer during development.

It allows developers to instantly view, edit, create and delete PlayerPrefs keys directly from the Unity Editor, without writing debug scripts or switching between play mode and code.

Built for productivity and debugging speed, this tool provides a compact, modern interface where all PlayerPrefs values can be managed in seconds.

🚀 Core Features

• Inline editing for Int, Float and String values
• Create new PlayerPrefs keys using the large quick-add button
• Delete keys with confirmation to prevent mistakes
• Undo / Discard changes for modified values
• Favorites system to pin frequently used keys
• Prefix grouping for better organization
• Batch save and batch delete operations
• Auto-refresh while working in editor
• Manual refresh option

📊 Snapshot & Diff System

A powerful debugging feature for development and testing:

• Export PlayerPrefs snapshots to JSON
• Load snapshots from file
• Compare current values vs snapshot
• Detect added / removed / changed keys
• Restore values from snapshot instantly
• Overwrite all PlayerPrefs from snapshot when needed

Perfect for QA workflows, balancing tests, and restoring development states.

🎯 Workflow Advantages

MAG PlayerPrefs Studio removes the need to:

• Write temporary debug scripts
• Open registry or local files manually
• Guess PlayerPrefs values during playtesting
• Restart play mode for small changes

Everything can be handled directly inside the editor.

💡 Designed For

• Game developers
• Tool developers
• QA & testing workflows
• Mobile game tuning
• Rapid prototyping
• Save system debugging

Works with any Unity project using PlayerPrefs.

🔧 Integration

No setup required.

Install → Open window → Start editing PlayerPrefs.

Unity Menu:
Tools → MAG Software → PlayerPrefs Studio

🧠 Built for Productivity

The tool focuses on speed and clarity:

• compact single-line layout
• minimal clicks
• instant feedback
• safe editing workflow

Designed to fit naturally into daily development work.

🌐 Explore More Tools

Check other MAG Software tools:
https://assetstore.unity.com/publishers/68634

TacticsPack – Tower Defense AI Expansion for BTGraph or BTGraph Pro

TacticsPack is a modular AI extension for BTGraph, designed specifically for isometric and grid-based Tower Defense games.

It provides a complete set of production-ready Behavior Tree nodes and clean gameplay interfaces for implementing advanced targeting, combat logic, economy systems, wave control, and waypoint-based movement — all fully decoupled and extensible.

This pack is built with architecture-first principles, allowing you to plug it into existing systems without hard dependencies or rigid gameplay assumptions.

🔥 Included Systems

🎯 Advanced Targeting

• Find Weakest Target
• Find Strongest Target
• Find Closest To Goal
• Dynamic Target Switching
• Priority-based Target Logic

⚔ Combat & Damage

• Rotate To Target
• Fire Projectile
• Apply AOE Damage
• Apply Status Effects
• Retarget Control Logic

💰 Economy & Placement

• Currency Validation & Spending
• Tile Reservation / Release
• Placement Validation Nodes

🚶 Waypoint Movement

• Move To Next Waypoint
• Is At Waypoint
• Goal Reached Detection

🌊 Wave Management

• Start Wave
• Spawn Unit
• Wave Cleared Detection

🧩 Clean Interface-Based Architecture

All gameplay logic is decoupled via interfaces:

• ITacticsTargetPriorityAgent
• ITacticsProjectileAgent
• ITacticsAOEAgent
• ITacticsStatusAgent
• ITacticsEconomyAgent
• ITacticsPlacementAgent
• ITacticsWaveAgent
• ITacticsCombatStateAgent
• ITacticsWaypointAgent

This ensures maximum flexibility and integration into your existing systems.

No forced inheritance. No rigid gameplay controller.

You stay in control.

🛠 Designed For

• Isometric Tower Defense games
• Grid-based strategy games
• Hybrid TD / RTS projects
• Developers who want structured, scalable AI

⚙ Requirements

Requires BTGraph or BTGraph Pro.

• Full C# Source Code included.
• Custom Editor Window (Tools > Quick Optimizer Pro).
• Deep Recursive Folder Search logic.
• Profiler based memory calculation for accurate reporting.
• No external dependencies.
• Supported OS: Windows, macOS, Linux.
• Documentation included (PDF).

Quick Optimizer Pro is the ultimate workflow tool for developers who want to optimize their projects without the headache of manual settings. 

Designed for the modern era where build size and runtime performance are critical, this tool provides a "Smart" one click solution for mobile (Android/iOS) and PC platforms.

CORE FEATURES:

- Smart Texture Compression: Automatically halves sizes and applies high efficiency ASTC format.

- Mesh Optimization: Quickly apply compression to all models in your project.

- Performance Materials: Enable GPU Instancing across your project to reduce draw calls.

- Audio Slimming: Convert heavy clips to Vorbis Mono to save up to 80% space.

- Type Converter: Change texture types recursively through deep folder structures.

- Real-time Reports: See exactly how many MBs you've saved with our sortable report window.

Stop wasting time on manual imports and let Quick Optimizer Pro handle the heavy lifting!

• Extends Unity’s Hierarchy window using editor callbacks
• Middle mouse click popup for per-GameObject customization
• Supports background colors, text colors, gradients, and bold labels
• Assign built-in Unity icons or custom Texture2D icons
• Adjustable gradient (fade) strength with live preview
• One-click apply to child GameObjects
• Preset system for colors and icons (ScriptableObject-based)
• Fully editable presets via custom inspector
• Enable / disable system from Unity menu
• Clear all hierarchy customizations with a single action
• Editor-only implementation with zero runtime overhead
• Does not affect play mode, builds, or performance

Essential hierarchy organization tool

Fellow Hierarchy lets you visually organize Unity’s Hierarchy window by customizing GameObjects with colors, gradients, icons, and text styles. It is designed to make complex scenes easier to read, faster to navigate, and more enjoyable to work with.

All customizations are applied instantly via a middle mouse click popup directly on Hierarchy items, with no extra windows and no save steps.

Designed to be

Minimal – Focused purely on Hierarchy visualization
Fast – Instant apply, no confirmation or save buttons
Intuitive – Right where you work: inside the Hierarchy
Customizable – Fully user-defined colors, icons, and presets
Editor-only – Safe to use with zero runtime impact

Hierarchy Customization Features

• Apply background colors to GameObjects
• Optional gradient / fade effect with adjustable strength
• Customize text color and alignment
• Bold labels for important objects
• Assign built-in or custom icons
• Apply styles to child objects in one click

Preset System

• Built-in color and icon presets
• Fully editable via ScriptableObject database
• Add, remove, and customize presets easily
• Reusable styles across different scenes

Clean & Efficient Workflow

• Works directly inside Unity’s Hierarchy window
• Middle mouse click to open the customization popup
• No save button – changes apply instantly
• Enable / disable the system from the menu
• Clear all customizations with a single action

Universal Project Support

• Compatible with Built-in Render Pipeline
• Fully compatible with URP
• Fully compatible with HDRP
• Suitable for any Unity project, any genre, any scale

Safe & Lightweight

• Editor-only functionality
• No runtime overhead
• Does not modify GameObject data
• No impact on build size or performance