Feed aggregator

• 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

Technical Details

• Scaled to real-world units (1 unit = 1 meter).
• Designed for 1/2 meter grid snapping.
• Pivots are placed at the bottom corners for easy modular placement.
• Includes Albedo, Metallic, Normal, Emissive, and AO maps.
• Optimized for real-time rendering.
• No lightmaps included.

Workflow:

• Enable Grid Snapping (magnet icon in the Scene view toolbar).
• Start by placing floor/platform modules.
• Add thick or slim wall pieces.
• Attach roof modules.
• Decorate with interior and exterior props.

Approximate Face Counts

• Walls: 30 – 150 faces
• Bridge: 1000 – 3800 faces (3 LOD levels included)Floors: 10 – 50 faces
  Roofs: 150 – 800 faces (3 LOD levels included)
• Lamp Posts: 85 – 600 faces (3 LOD levels included)
• Stairs: 118 – 230 faces (3 LOD levels included)

Assets are optimized for real-time rendering.

Lightmap textures are not included.

Texture & Material Info

• All textures are 4K resolution.
• Materials are located in the “Materials” folder. Textures are located in the “Textures” folder.
• Multiple objects share textures for improved performance.

Included Texture Maps

• Albedo
• Metallic
• Normal
• Emissive
• Ambient Occlusion

Render Pipeline Compatibility

• Built-in Render Pipeline: Supported
• URP: Supported (materials may require minor adjustment)
• HDRP: Supported (materials may require minor adjustment)

Tested with:

• Unity 2022.3.62f3 (LTS)
• Unity 6000.3.9f1

Dependencies

• For the provided scripts to work properly, you will need TMP Essential Resources

This package contains a modular set of traditional Japanese wooden architecture pieces designed for building customizable village environments.

What’s Included:

Modular Architecture:

Floors

• 5 Floor Types × 3 Texture Variations

Doors

• 2 Door Types (1 Slim, 1 Thick) x 3 Texture Variations
  Matching Door Frames Included

Slim Walls

• 3 Wall Types × 3 Texture Variations

Thick Walls

• 6 Wall Types × 3 Texture Variations

Roofs

• 5 Roof Types × 3 Texture Variations
• Most roof modules include 3 LOD levels

Interior Props:

• Chair × 2 Texture Variations (3 LODs)
• 2 Types of Lamps × 2 Texture Variations
• Table × 2 Texture Variations
• 4 Types of Tatami × 2 Texture Variations
• 6 Types of Shelves × 2 Texture Variations
• Floor Stair × 3 Texture Variations (3 LODs)

Exterior Props:

• Bridge × 1 Texture Variation (3 LODs)
• 2 Types of Corrugated Metal Sheets × 3 Texture Variations
• Fence × 3 Texture Variations (3 LODs)
• 2 Types of Lamp Posts × 1 Texture Variation (3 LODs)
• 2 Types of Stairs × 3 Texture Variations
• Torii Gate × 1 Texture Variation (3 LODs)

Scripts:

• The package includes 5 example scripts used in the “HouseExamples” scene to demonstrate functionality.

Included Scripts:

Door.cs
- Opens/closes doors when the player is nearby and presses “E”.

InteractionManager.cs
- Displays and hides interaction prompts near interactive objects.

Lights.cs
- Toggles lights when the player presses “F”.

Player.cs
- Simple example player controller.

SunCycle.cs
- Rotates the directional light to simulate a day/night cycle.

• 1271 unique designs total (not including resolution and outline variants);
• .PNG format;
• Multiple resolutions included (x64, x128, x256);
• Outlined variations included;
• Spritesheets of all icons (Outlined and Non-Outlined) included;

A collection of high-quality potion icons, created with 3D rendering and compositing. Perfect for RPG and casual games. Comes with both outlined and non-outlined versions.

3D content not included.

- Three Demo Maps

- Two Different Control Scripts

- A Lot Of Ready Examples

- Fully Customizable

- Easy To Use

- Fully Documentation

⚡ Blink & Phase VFX System 💥

A powerful and fully customizable VFX system for teleport, dash, and blink effects.

Create smooth, stylish movement with shadow clones, dissolve transitions, and dynamic trails. Everything is easy to control — change timing, colors, shapes, and behavior to fit your game.

🔥 What’s Inside?

• Full teleport system: Disappear → Travel → Reappear

• Shadow clone system with smooth trails

• Dash, blink, teleport and phase effects

• Many ready-to-use demo effects included

• Easy to use — just drag & play

🎨 Full Customization:

• Change colors, materials, and style

• Control speed, timing, and movement

• Adjust clone count, spacing, and randomness

• Create your own unique effects in seconds

🎬 Demo Effects:

• A lot of ready examples included

• From simple blink to complex clone trails

• Use as-is or tweak for your own style

🧠 Why This Asset?

• Not just effects — full system you control

• Very easy to use, but powerful

• Clean, readable effects for gameplay

• Works for fantasy, sci-fi, action games

• Perfect for abilities like teleport, dash, shadow step

Whether you want a simple blink or a full shadow clone teleport system — you can build it fast and make it look exactly how you want.

Documentation & Support

The asset includes demo scenes and detailed documentation.

Join the Discord for updates and support.

Full documentation: Blink & Phase

💬 Support: tvitchivfx@gmail.com

Number of textures 142

Texture dimensions 4096x4096

Maximum polygon count 3497

Number of meshes/prefabs 10

UV mapping: Yes

LOD information (count, number of levels) no

Types of materials and texture maps (e.g., PBR) yes

3D model Circus Masks Pack. Contains 5 different High/Low poly masks and has 5 skins, textures and materials. All textures are PBR 4096x4096 Includes mask map, AO, etc. Game ready, Suits for characters. Metall/Rough, include AO, Height map, Mask map for HDRP. Suits for Unity, Blender, Unreal Engine4, UE5 and more.

Contains Low poly and High Poly variations. High Poly models are Print ready.

All texture can be compressed to 1024x1024 without loss much quality.

5 Nasks 5 Skins

Circus Mask 1 - 1661 polygons

Circus Mask 2 - 1911 polygons

Circus Mask 3 - 1100 polygons

Circus Mask 4 - 3497 polygons

Circus Mask 5 - 1809 polygons

5 High poly

Materials - 25

Textures - 142

Number of textures - 4 1024x1024

Minimum vertices count - 367 verts

Maximum vertices count - 700 verts

Number of meshes/prefabs - 3

LODs - LOD0-3

This medieval wall torch prop is designed for dungeons, castles, corridors, and medieval interiors.

Clean topology and high-quality PBR textures provide realistic wood and metal surface detail while remaining optimized for real-time applications.

The asset works well as an environmental prop for medieval environments, adding atmosphere to castle halls, dungeon passages, and torch-lit interiors.

Torch and wall mount are separate models.

Number of textures - 3 4096x4096

Minimum vertices count - 1418 verts

Maximum vertices count - 2887 verts

Number of meshes/prefabs - 6

LODs - LOD0-3

This medieval stocks prop is designed for town squares, prison yards, and medieval punishment environments.

Clean topology and high-quality PBR textures provide realistic wood and metal surface detail while remaining optimized for real-time applications.

The model features wooden restraints for head and hands, making it suitable for medieval village scenes, public punishment areas, and historical environments.

Model is divided into multiple movable parts.

Number of textures - 3 4096x4096

Minimum vertices count - 5582 verts

Maximum vertices count - 9443 verts

Number of meshes/prefabs - 4

LODs - LOD0-3

This medieval pillory prop is designed for town squares, prison yards, and medieval punishment environments.

Clean topology and high-quality PBR textures provide realistic stone and metal surface detail while remaining optimized for real-time applications.

The asset features chains and restraints, making it suitable for medieval village scenes, public punishment areas, and dark fantasy environments.

Model is rigged.