Asset Store newest packages

⚙️ TECHNICAL DETAILS

• Resolution: 16384 × 8192 

• Format: HDR (RGBE), EXR (32-bit) 

• Projection: Equirectangular (2:1) 

• Seamless: Yes 

• Texture Type: Skybox / HDRI

Enhance your space environments with this premium pack of 16K nebula skyboxes, designed for high-end rendering, cinematics, and real-time applications.

All skyboxes are true 16K resolution (16384 × 8192) and fully seamless, ensuring maximum visual fidelity even in close-up shots.

These assets are rendered natively, without AI generation or upscaling, providing clean detail, natural gradients, and physically believable lighting.

✨ FEATURES

• 4 unique nebula skyboxes
• Ultra high resolution: 16K (16384 × 8192)
• Seamless equirectangular projection (2:1)
• True HDRI lighting support
• Clean, artifact-free rendering
• Native resolution (not AI, not upscaled)

📁 INCLUDED FILES

• 4 × HDR skyboxes (.hdr)
• 4 × EXR versions (.exr)

🎯 COMPATIBILITY

Compatible with:

• Unity Built-in Render Pipeline
• Universal Render Pipeline (URP)
• High Definition Render Pipeline (HDRP)

🎬 IDEAL USE CASES

• Space environments
• Sci-fi games
• Cinematics and cutscenes
• Backgrounds for space scenes
• HDRI lighting setups

⚠️ IMPORTANT NOTES

• These are equirectangular HDRI textures, not cubemaps
• Conversion to cubemap is supported inside Unity if needed
• Due to 16K resolution, use on systems with sufficient VRAM

Number of Animations: 158

Animation Types (Root Motion/In-place): Root Motion

Important/Additional Notes: Models are not included in project only available Animations.

Animation List :

AS_Sit Down_L_01

AS_Sit_Back_Move

AS_Sit_Open_Menu_Loop_R

AS_Sit_Order_Loop_R

AS_Sit_Order_L

AS_Sit_Idle_R_02

AS_Sit_Fork_Etting_Start_R_01

AS_Sit_Fork_Etting_End_L_01

AS_Sit_Fork_Etting_End_R_03

AS_Sit Idle_R_04

AS_Sit_Drink_End_L

AS_Sit Idle_R_05

AS_Sit_Idle_L_06

AS_Sit_Bread_Eating_End_R

AS_Sit_Bread_Eating_End_Twohand

AS_Sit_Chicken_Eating_Start_L

AS_Sit_Chicken_Eating_R

AS_Sit_Chopstick_Start_L

AS_Sit_Chopstick_R

AS_Sit_Ungrab_Onehand_R

AS_Sit_Eating_Loop_Onehand_L

AS_Sit_Eating_End_Onehand_R_02

AS_Sit_Seasoning_Start_L

AS_Sit_Ungrab_Seasoning_R

AS_Sit_Idle_12

AS_Sit_Mixing_Start Twohand

AS_Sit_Drink_fromplate_Start

AS_Sit_Idle_To_Mouth_Clean_R_01

AS_Sit_Idle_To_Cough_End_L

AS_Sit_Cough_To_Over_Etting_R

AS_Sit_Over Eating_End_L

AS_StandUp_Left_L_02

AS_Sit_Down_R_01

AS_Sit_Idle_01

AS_Sit_End_Menu_L

AS_Standup_R_01

AS_Sit_Idle_To_Open_Menu_L

AS_Sit_End_Menu_R

AS_Sit_Order_Loop_L

AS_Sit_Order_End_R

AS_Sit_Knife_Start_R

AS_Sit_Idle_L_02

AS_Sit_Fork_Etting_Loop_L_01

AS_Sit_Fork_Etting_End_R_01

AS_Sit_Grab_Mug_R

AS_Sit_Idle_L_04

AS_Sit Drink Loop_R

AS_Sit_Idle_L_05

AS_Sit_Bread_Eating_Loop_R

AS_Sit_Bread_Eating_End_L

AS_Sit_Bread_Eating Twohand

AS_Sit_Chicken_Eating_End_R

AS_Sit_Chicken_Eating_L

AS_Sit_Chopstick_End_R

AS_Sit_Chopstick_L

AS_Sit_Ungrab_Onehand_L

AS_Sit_Eating_End_Onehand_R_01

AS_Sit_Eating_End_Onehand_L_02

AS_Sit_Seasoning_Loop_R

AS_Sit_Ungrab_Seasoning_L

AS_Sit_Twofisted_Start

AS_Sit_Mixing_End_Twohand

AS_Sit_Drink_fromplate_Loop

AS_Sit_Idle_To_Mouth_Clean_L_02

AS_Sit_Idle_To_Cough_End_R

AS_Sit_Over Etting_To_Cough_L

AS_Sit_Over_Eating_End_R

AS_Sit Down Left_L_02

AS_Sit_Knife_Start_L

AS_Knife_Loop_R

AS_Sit_Fork_Etting_Loop_R_01

AS_Sit_Fork_Etting_End_L_02

AS_Sit_Grab_Mug L

AS_Sit Drink Start_R

AS_Sit_Drink_Loop_L

AS_Sit_Bread_Eating_Start_R

AS_Sit_Bread_Eating_Loop_L

AS_Sit_Idle_08

AS_Sit_Idle_R_09

AS_Sit_Chicken_Eating_End_L

AS_Sit_Idle_R_10

AS_Sit_Chopstick_End_L

AS_Sit_Idle_11

AS_Sit Eating_Start Onehand_R

AS_Sit_Eating_End_Onehand_L_01

AS_Sit_Grab_Seasoning_R

AS_Sit_Seasoning_Loop_L

AS_Sit_Seasoning_R

AS_Sit_Twofisted_Loop

AS_Sit_Mixing Loop_Twohand

AS_Sit_Drink_fromplate_End

AS_Sit_Idle_To_Mouth_Clean_R_02

AS_Sit_Cough_Loop_L

AS_Sit Over Etting_To_Cough_R

AS_Sit_Over Eating_Start_L

AS_Sit Down Right_R_02

AS_Standup_L_01

AS_Sit_Idle_To_Open_Menu_R

AS_Sit_Order_Start_R

AS_Sit_Order_End_L

AS_Sit_Knife_End_R

AS_Knife_Loop_L

AS_Sit_Idle_L_03

AS_Sit_Fork_Etting_End_R_02

AS_Sit_Ungrab_Mug_R

AS_Sit_Drink_Start_L

AS_Sit_Drink_R

AS_Sit_Bread_Eating_Start_L

AS_Sit_Idle_R_07

AS_Sit_Bread_Eating_Start Twohand

AS_Sit_Idle_L_09

AS_Sit_Chicken_Eating_Loop_R

AS_Sit_Idle_L_10

AS_Sit_Chopstick_Loop_R

AS_Sit_Grab_Onehand_R

AS_Sit Eating_Start_Onehand_L

AS_Sit Eating Onehand_R

AS_Sit_Grab_Seasoning_L

AS_Sit_Seasoning_End_R

AS_Sit_Seasoning_L

AS_Sit_Twofisted_End

AS_Sit_Mixing_To_Idle_13

AS_Sit Drink_fromplate

AS_Sit_Idle_To_Cough_Start_L

AS_Sit_Cough Loop_R

AS_Sit_Over Eating_Loop_L

AS_Sit_Over_Eating_Start_R

AS_Sit_Front_Move

AS_Sit Open_Menu_Loop_L

AS_Sit_Order Start_L

AS_Sit_Order_R

AS_Sit_Knife_End_L

AS_Sit_Fork_Etting_Start_L_01

AS_Sit_Idle_R_03

AS_Sit_Fork_Etting_End_L_03

AS_Sit_Ungrab_Mug_L

AS_Sit Drink_End_R

AS_Sit Drink L

AS_Sit_Idle_R_06

AS_Sit_Idle_L_07

AS_Sit_Bread_Eating_Loop_Twohand

AS_Sit_Chicken_Eating_Start_R

AS_Sit_Chicken_Eating_Loop_L

AS_Sit_Chopstick_Start_R

AS_Sit_Chopstick_Loop_L

AS_Sit_Grab_Onehand_L

AS_Sit_Eating_Loop_Onehand_R

AS_Sit_Eating_Onehand_L

AS_Sit_Seasoning_Start_R

AS_Sit_Seasoning_End_L

AS_Sit_Grab_Twofisted

AS_Sit_Ungrab_Twofisted

AS_Sit_Idle_13

AS_Sit_Idle_To_Mouth_Clean_L_01

AS_Sit_Idle_To_Cough_Start_R

AS_Sit_Cough_To_Over_Etting_L

AS_Sit_Over Eating_Loop_R

AS_StandUp_Right_R_0

Technical Details

• Requires TextMeshPro
• Compatible with Unity 2021 LTS and newer
• Compatible with Built-in, URP, and HDRP
• Supports all Unity platforms

Runtime Architecture

• HyperlinkManager (auto-bootstrap)
• HyperlinkRegistry (ScriptableObject-based global URL registry)
• SceneHyperlinkRegistry (scene-level event bindings)
• TMPHyperlinkBehaviour (click + hover handling)

Performance

• O(1) ID lookup
• No LINQ in runtime
• No runtime string parsing
• Mesh-level hover modification (no material duplication)

Requires TextMeshPro

TMP Link Manager Pro provides a centralized, scalable hyperlink routing system for TextMeshPro.

Instead of hardcoding URLs or scattering click handlers across multiple scripts, define link IDs directly inside TMP <link> tags and route them through a single manager.

Designed for production environments where maintainability and clean architecture matter.

Supports:

• Web URL navigation
• Scene-level UnityEvents
• Custom logic execution

Key Features:

• ID-based hyperlink routing

• Centralized ScriptableObject URL registry

• Scene-specific UnityEvent routing

• Optional combined execution (URL + UnityEvent)

• Hover color effects (mesh-level modification)

• Custom inspectors

• Validation utilities

• Demo scenes included

Example Usage

Use standard TextMeshPro link tags:

<link="tos">Terms of Service</link>

Route "tos" to:

• A web URL
• A UnityEvent
• Or both

- Near Miss Detector component

- Offline Documentation

Near Miss Detector enhances the dodge experience in Game Creator 2’s Melee 2 module by detecting nearby incoming attacks, not just direct hit strikes.

By default, dodge reactions typically rely on the Striker physically passing through the character. This system expands that logic by detecting enemies attacking within a configurable radius, allowing dodge responses to trigger even when the strike narrowly misses.

The result is more responsive, cinematic, and forgiving combat, ideal for action-heavy and Soulslike-inspired gameplay.

🔧 What it does

• Detects attacking enemies within a configurable radius
• Triggers dodge logic on near-miss situations
• Works alongside Melee 2’s existing dodge system
• Lightweight and event-driven
• Fully compatible with Game Creator 2

🎯 Perfect for

• Soulslike combat systems
• Action RPGs
• Games that reward well-timed evasive maneuvers
• Developers seeking more dynamic and reactive melee combat

Near Miss Detector doesn’t replace Melee 2’s dodge system,
it extends it, making combat feel more alive and reactive.

REQUIREMENTS

• Unity 2021.3 LTS or higher
• Works with Built-in Render Pipeline, URP, and HDRP (no renderer-specific shaders used)
• Physics2D must be enabled (enabled by default in all Unity projects)
• No third-party packages or dependencies required

INCLUDED FILES

• TLD_CharacterController2D.cs - main controller (requires Rigidbody2D and CapsuleCollider2D)
• TLD_InputBridge.cs - Legacy Input and New Input System adapter
• TLD_CapsuleVisualRenderer.cs - procedural capsule mesh with state color feedback
• TLD_StateMachineBridge.cs - CharacterState enum and Animator parameter driver
• TLD_CameraFollow.cs - smooth follow camera with look-ahead, dead zones, and screen shake
• TLD_SetupWizard.cs - Editor only, one-click setup wizard and custom Inspector

PHYSICS

• Collision detection mode: Continuous
• Rigidbody2D interpolation: Enabled
• Gravity managed manually per frame (Rigidbody2D.gravityScale set to 0 by the controller)
• Ground and wall detection: configurable Overlap Circle or Raycast modes
• Slope movement via surface normal projection

TLD Ultimate 2D Character Controller gives you a production-ready, fully procedural 2D character controller built entirely on a capsule shape. No sprites, no animator, no art required, every animation is written in code.

Open Window > TLD > Setup Wizard, pick your ground layer, click Create Character, and hit Play. Done.

MOVEMENT & PHYSICS

• Smooth acceleration and deceleration with separate ground and air values
• Variable jump height with fall multiplier and low-jump multiplier for tight, responsive arcs
• Multi-jump support (1 to 5 jumps, fully configurable)
• Coyote time, grace window after walking off a ledge
• Jump buffering, queue a jump slightly before landing
• Full slope detection and slope-normal movement
• Configurable gravity scale, max fall speed, and ground snapping

WALL MECHANICS

• Wall slide, slow fall while pressed against a wall
• Wall grab with optional stamina system (hold to cling indefinitely or drain over time)
• Wall jump with configurable force, lock-out timer, and directional control (Basic or Advanced mode)

DASH

• Directional dash (follows input direction) or Lateral dash (always horizontal)
• Configurable speed, duration, and cooldown
• Air dash with limited-use count per jump
• Optional gravity disable during dash
• Invincibility flag for use with your own health system

CROUCH & SLIDE

• Crouch shrinks the capsule collider from the top, feet stay planted on the ground
• Head clearance check prevents standing up inside geometry
• Slide with minimum speed requirement, duration, and separate cooldown
• Crouch speed multiplier

LEDGE MECHANICS

• Automatic ledge detection using raycasts, no trigger volumes needed
• Ledge grab, character catches the corner of a platform while falling
• Ledge climb, smooth two-phase animation climbs up and over the ledge
• Ledge jump, kick off the ledge into a full jump
• Drop from ledge by holding Crouch

PROCEDURAL ANIMATIONS

All animations are code-driven squish and stretch on the Visual child transform. No Animator or sprites required.

• Land squish, impacts compress the capsule, scaled to landing velocity
• Jump stretch, capsule elongates on takeoff
• Run lean, gentle rotation tilt during movement
• Crouch squish, visually compresses to match the collider shrink
• Slide squish, wide, flat shape during slides
• Wall-slide squeeze, narrow stretch while pressing against walls
• Dash warp, horizontal stretch during dash
• Air stretch and fall squash

All squish uses a bottom-anchored pivot so the feet never leave the ground visually. All values are fully tunable in the Inspector.

The capsule visual displays state-based color feedback (idle, run, airborne, crouch, dash, wall-slide, ledge grab) so you can prototype and test without any art at all.

EASY SETUP

• One-click Setup Wizard at Window > TLD > Setup Wizard creates a complete character with camera
• Custom sectioned Inspector with live runtime debug readout
• Works with Legacy Input or Unity's New Input System out of the box
• Swap in your own input by calling controller.SetInput() from any script

INTEGRATION & EXTENSIBILITY

• State Machine Bridge exposes a clean CharacterState enum and drives any Animator
• 8 UnityEvents: onJump, onLand, onDash, onWallJump, onLedgeGrab, onLedgeClimb, onCrouchChange, onGroundedChange
• Public API: Teleport, AddImpulse, ForceJump, StopMovement, GetStateSnapshot
• Screen shake API on the Camera Follow component
• Fully compatible with PlatformEffector2D one-way platforms
• Works with moving platforms via Rigidbody2D
• No third-party dependencies

• Built a data-driven inventory system.
• Built authoritative server logic, client request bridge, editor tools.
• Built simple Equipment / Shop / Attribute system for inventory demo.
• View the Code: https://github.com/taiqi-dev/CommonGamePlayKit.git

1. Split Server / Client logic, clear namespaces, Reusable Core Logic

• Split Runtime assemblies into Common / Server / Client namespace, with dependency boundaries.
• Event-driven model enables UI decoupling, swappable UI prefabs, reuse across modules: Shop / Crafting / Equipment.

2. Designer-friendly editor tooling, data-driven content pipeline

• Editor windows cover Authoring, Validation, GUID management, and Batch Export
• Validation rules (duplicate/missing GUIDs, empty shapes, invalid tags, etc.).
• ShapeGrid editing: generate toggle grids, auto-center placement, visualize origin/pivot for precise layouts.

3. Robust failure modes (graceful degradation + Clear ResultCode / UI Message)

• Logging is centralized via LogSettings.
• Key operations return a ResultCode and UI Messages.

About This System

This is a content customizable and suitable for common gameplay.

Key Features: 

• SDF Rounded Corners: Control individual corner radius or uniform roundness. 

• Gradients: Horizontal, Vertical, Radial, and Angle base-fills without extra shaders. 

• Drop / Inner Shadow: HQ Blur and Fast Blur options with Distance & Spread control. 

• Outer Glow: Create beautiful bloom borders. 

• Soft Masking: Effortless smooth masking via sprite alpha. 

• Interactive Ripple: Built-in animated click ripples. 

• SDF Stroke: Inner, Outer, or Center borders with Width & Softness modifiers. 

• Pro Color Grading: Edit Exposure, Contrast, Saturation, Blur, Sharpen, Tint, and Vignette directly on the UI Graphic. 

• Optimization: Highly performant custom Material Pooling engine.

• Supported OS / Pipeline: Windows, Mac, Linux, iOS, Android, WebGL • Built-in Render Pipeline (Supports Unity UI Canvas)

Upgrade your Unity UI with LuminUI – a powerful shader-driven procedural UI toolkit designed for modern games.

LuminUI extends Unity's built-in UI Image component to deliver pixel-perfect, procedural SDF (Signed Distance Field) effects. Design beautiful interfaces with customizable rounded corners, glowing edges, and dynamic shadows—without needing to export hundreds of messy sprite assets. Designed from the ground-up for fast performance, it utilizes minimal graphics overhead and material pooling.

Included Components: • ProImage: The core component. • ProPanel: Pre-configured styled container.

All effects are controlled straight from the Unity Inspector with intuitive sliders, including full Master Opacity control!

- 5 free mesh editing tools

- Single object workflow with Use Selection button

- Professional dark theme UI

- Performance Assistant (scan only)

- Compatible with Standard, URP and HDRP

- Unity 2020.3+ supported

- Editor-only package (no runtime overhead)

- Full version available: Mesh Dominus Pro

Mesh Dominus Lite is a free demo version of Mesh Dominus Pro — a professional all-in-one mesh toolkit for Unity.

⚙️ INCLUDED TOOLS:

- Pivot Editor — Set pivot to Center, Bottom Center or Top Center

- Mesh Combiner — Combine child meshes into one static mesh (reduces draw calls)

- Mesh Separator — Separate combined mesh by submesh or material

- Freeze Transform — Bake transform values into mesh vertices

- Mesh Cleaner — Scan project for unused mesh assets

This lite version gives you a taste of what Mesh Dominus Pro offers. Purchase the full package to unlock all 14

professional mesh tools including Mesh Simplifier, Mesh Optimizer, Auto LOD Generator, Mesh Smoother, Double Side

Tool, Mesh Extractor, Material Atlas Generator, Auto Collider Generator & Mesh/SkinnedMesh Converter.

👉 Get Mesh Dominus Pro (Full Package):

This asset was designed for the 2D URP pipeline. It also works in 3D projects, but the refraction setup will not be available. To use refraction, a 2D URP project is required.

You can customize:

• Water waves (speed and amplitude)
• Refraction (noise, scale, and speed)
• Foam (color, position, noise scale, and amount)
• Color (top color, bottom color, opacity, and gradient)
• Transparency
• Texture
• Alpha clipping

Just apply this material to any 2D sprite and it will work.

NOTE: To enable refraction, you only need to complete a one-minute setup in your 2D URP asset. Detailed instructions are included in the PDF file that comes with this asset.

A 2D water material that is easy to set up. Just apply it to a square sprite and start customizing it to fit your project needs.

With this material, you can add refraction, waves (frequency, speed, and amplitude), color, foam, depth color from bottom to top, noise, transparency, and masking if needed. It is perfect for 2D projects and highly optimized for performance.

NOTE: This shader is only compatible with 2D URP.

• 3 original high-quality WAV tracks (48khz kHz / 24-bit)
• 07:55 of unique music
• 135 MB of music
• Unlimited Royalty-Free license
• Free Updates Forever

Audio Previews

Description

You need a unique sound. Something…different. Crazy Classical Game Music steps up to give you a one of a kind sound that will only work for the right game. This collection brings an insanely zany, creative, mold-breaking sound to your game. It sounds like a

• Madcap Classical Frenzy
• Classical Gone Feral
• Ransacked Symphony
• Chaotic Chamber Music Played By Humans and Monsters/Orcs/Goblins/Creatures

This first iteration of Crazy Classical Game Music is 3 hand-crafted tracks like no other using only the most famous and recognizable classical music.

1. Vivaldi’s Four Seasons: Spring
2. Beethoven’s 5th Symphony
3. Bach’s Cello Solo In D Major No. 1

========================

100% YouTube Safe Forever

========================

I will never, now or in the future make any claim on Youtube to take the monetization from your content that uses this audio.

Add Crazy Classical Game Music to your cart and buy now!

===============================

FILE-NAMING & FOLDER STRUCTURE:

===============================

BPM (beats per minute) added to every track filename: now you know exactly how fast every track will be before previewing, saving a ton of time when searching for your next track.

Keys: Every track has the key baked into the name so you always know exactly what you are going to get.

NEW TRACKS: As I add more tracks in the future, they will be included at no additional cost to you. These updates are always free!

Add Crazy Classical Game Music to your cart and buy now!

==================

About The Composer

==================

Hi! I’m Dan thanks for taking the time to check out my wild and mad-cap music! I am available to compose custom music for your game right now!

Send me an email here so we can talk about creating amazing custom music for your game: support@bestmusiccoach.com

My website: https://www.musicmentordan.com/projects?htrafficsource=unity&el=crazy-classical

Technical Details

Seamless Editor Integration

The tool is designed to feel like a native part of your Unity workspace, prioritizing practical accessibility and a frictionless workflow before relying on its heavier backend optimizations.

• Tabbed Workspace & Quick Ingestion: Manage multiple staging queues simultaneously using the persistent tabbed interface. Getting files into the tool is instantaneous: you can drag and drop entire folders or individual .cs scripts directly into the window, or simply highlight assets in your Project view and use the right-click context menu to instantly append them to your active workspace.
• Minimal Project Footprint: The asset is incredibly lightweight, consisting entirely of a handful of Editor scripts. It resides completely within its own isolated Assembly Definition (.asmdef) and custom namespace. It has strictly zero external dependencies and requires no initial setup.
• Zero Resource Drain & Safe Removal: The tool is engineered to sit quietly in your project. It consumes absolutely zero CPU or memory resources when the window is closed, and maintains a highly optimized, minimal footprint when open. Because it is strictly an Editor-only tool, it is completely excluded from your runtime builds. If you ever decide you no longer need it, simply delete the asset folder—it leaves no trace, dangling scripts, or broken references behind.
• Non-Destructive & Persistent: The exporter acts strictly as a read-only formatting engine. It loads files into memory to build the final payload and will never overwrite, truncate, or modify your actual source code on disk. Furthermore, native Unity UI state serialization ensures your active queues and scratchpad drafts safely survive script recompilations (Domain Reloads) without wiping your staged work.
• Safe Regex Comment Stripping: Comment removal utilizes a compiled Regular Expression engine meticulously designed to identify and preserve string literals ("...", $"...", @"{...}") before searching for comments. This ensures that // or /* characters found inside URLs or debug messages are never accidentally stripped.
• Assembly Caching & Path Normalization: To prevent Editor freezes during mass drag-and-drop operations, the tool bypasses standard string comparisons by building a lazy-loaded, instantly accessible cache of your project's assemblies. It also sanitizes all ingestion paths, automatically resolving Mac and Windows slash discrepancies so native compilation API lookups function flawlessly. This cache automatically flushes and updates the moment your project hierarchy changes.

Technical Specifications

• Namespace: Veridian.ContextBundler.Editor
• Assembly: Veridian.ContextBundler.Editor.asmdef
• Environment: Unity Editor Only (Safely stripped from all runtime builds).
• Output Formats: Generates output directly to the system clipboard, or saves to local disk as Markdown (.md) or Plain Text (.txt).
• Dependencies: None. This tool utilizes standard internal Unity Editor APIs and requires no external packages or libraries.

The CleanScript Exporter is a time-saving Unity Editor utility designed to instantly collate and export C# scripts without the friction of opening an external IDE. Opening multiple scripts in standard code editors just to copy their contents is a tedious, time-consuming bottleneck. This tool bypasses that entirely, allowing developers to drag and drop entire folders or specific files directly into a Unity window for immediate clipboard access. While its primary function is rapid, IDE-less text extraction, it is augmented with powerful optimization features—including comment stripping and dependency mapping—to output clean, bounded text payloads.

Note: Once imported, this tool operates under its internal engineering name which is "Context Bundler". Access it via the top menu: Tools > Veridian > Context Bundler. .

Core Workflow & Interface

• Instant Staged Queue: Drag and drop folders or individual .cs files directly into the window. The tool recursively searches directories and populates a staging queue, keeping updated versions of your scripts ready to be copied instantly.
• IDE-Free Extraction: Select entire modules and instantly copy the combined C# logic directly to your clipboard or local drive, completely bypassing external editor load times.
• Safe Comment Stripping: A custom Regex-driven engine allows you to globally or individually strip legacy inline (//) and block (/* */) comments to reduce the overall text footprint. An optional setting intelligently preserves structural C# XML documentation (///).
• Custom Instruction Preamble: Prepend high-level directives to the top of your exported file using a version-controlled InstructionPresetLibrary (ScriptableObject) to save, share, and inject standardized export instructions.
• Architecture & Dependency Mapping: The tool natively reads Unity's CompilationPipeline data to generate a Markdown-formatted map of all staged assemblies (.asmdef) and their explicit one-way dependencies.

Primary Use Cases

1. Collaboration & Asynchronous Peer Review

When collaborating with external contractors or conducting peer code reviews, sending an entire multi-gigabyte Unity project repository is impractical. The CleanScript Exporter allows lead engineers to grab a specific feature module, strip redundant legacy comments, and instantly output a single, clean .md file. This provides the reviewer with the exact, bounded context they need without exposing the proprietary codebase or forcing anyone to manually aggregate files.

2. Rapid LLM Context Preparation

For developers utilizing Large Language Models (LLMs) for code analysis, refactoring, or generation, gathering context is often a frustrating process. Opening five different scripts in an IDE simply to copy and paste their text wastes valuable time. The CleanScript Exporter solves this by acting as an instantaneous context-window engine directly inside Unity.

• Frictionless Copying: Drag a feature folder into the tool and instantly copy the codebase to your clipboard in a single click, keeping your workflow fast and uninterrupted.
• Token Footprint Optimization: By utilizing the comment stripper and preserving only structural XML, developers significantly reduce the character footprint of their payload, saving valuable token bandwidth for the actual API response.
• System Prompt Injection: The Instruction Library acts as a centralized repository for system prompts, ensuring consistent LLM constraints across the studio without having to retype them.
• Preventing Architectural Hallucinations: By prepending the Architecture & Dependency Map, the LLM reads the one-way dependency flow of your architecture first. It is explicitly instructed to adhere to these boundaries, effectively constraining the model from generating code that assumes access to isolated namespaces or creates circular dependencies.

3. Project Documentation

The tool serves as a rapid generator for internal technical documentation, allowing teams to instantly bundle module logic and structural boundaries into text formats suitable for Git wikis or internal knowledge bases.

Package Expectations

• Editor-Only: This is strictly an Editor utility and will not affect or bloat runtime application builds.
• No Demo Scene or Artwork: This package contains only the functional Editor window and background compilation scripts. It does not include demo scenes, 3D models, or artwork.

More from Veridian:

If you find this tool useful, please consider browsing our publisher page for additional free assets, or reviewing our premium optimization suite below.

BurstLOD: Burst-Powered Optimization Suite

BurstLOD is a production-grade decimation and optimization suite engineered for high-performance Unity development. Built entirely on the Unity Job System and Burst Compiler, it provides a complete pipeline for generating, refining, and deploying high-quality mesh LODs without slowing down your workflow.

Core Physics & Controller Architecture

The foundation of the asset is the AtmosphericStarshipController, a robust rigidbody-driven system designed to decouple flight logic from input sources. Interface-Driven InputThe system relies on the IShipDriver interface pattern. This abstraction allows the controller to accept inputs from any source—whether it’s the PlayerShipDriver (via Unity Input System) or the SimpleAiPilot—without modifying the core physics loop. This ensures that AI agents are subject to the same physical limitations and flight envelopes as the player. Advanced Aerodynamic ModelMoving beyond simple drag, the controller implements a custom aerodynamic simulation that calculates:

• Linear & Quadratic Drag: Simulates air resistance that scales exponentially with speed, allowing for realistic terminal velocities and "energy bleeding" during maneuvers.
• Directional Drag: applies differential drag coefficients to forward vs. sideways motion, preventing ships from sliding indefinitely like zero-G craft while still allowing controlled drifting.
• G-Force Governance: A built-in limiter monitors angular and linear acceleration, automatically throttling inputs to keep G-forces within a survival threshold defined by the ship’s profile.

Modular Utility AI & Pilot System

The AI architecture employs a decentralized "Brain vs. Pilot" model, separating high-level strategy from low-level execution. The "Brain" (Decision Layer)The AiBrain operates on a configurable "Think Cycle" to evaluate the environment. It utilizes a prioritized list of AiActionSO (ScriptableObjects) to select behaviors. This structure supports complex decision trees, such as:

• Conditional Logic: Evaluates health, proximity, and role (Leader/Wingman) to switch states.
• Hysteresis: Uses distinct Engage/Disengage distance thresholds to prevent state-flickering during combat.
• Behavior Factory: Instantiates behaviors (e.g., BehaviorAttack, BehaviorPatrol) only when needed, keeping memory usage efficient.

The "Pilot" (Execution Layer)The SimpleAiPilot translates the Brain's navigation goals into raw flight inputs. It features a PID Controller (Proportional-Integral-Derivative) flight style, which smooths out rotation and thrust errors. This allows for precise formation flying and organic, non-jittery movement updates that look indistinguishable from player control.

Sensory & Tactical Intelligence

Provider-Based Sensory SystemThe ShipSensorySystem uses a Provider Pattern (ISensorProvider) to abstract physics queries. This allows the system to perform:

• Ground Detection: Calculates altitude for ground-effect physics and safety overrides.
• Obstacle Avoidance: Uses a state-driven scanner that switches from passive forward checks to active, multi-ray searches when an obstacle is detected, generating escape vectors for the pilot.

Centralized Faction ManagementThe FactionManager acts as the tactical authority for the scene. It maintains optimized registries of all active ships, bases, and waypoints. Instead of expensive FindObjectsOfType calls, AI agents query the Manager for instant access to:

• Squadron Logic: Identification of friendly Leaders vs. Followers.
• Threat Assessment: Rapid retrieval of the nearest hostile targets sorted by distance.
• Lifecycle Events: Centralized handling of respawn timers and object pooling logic.

Profile-First Configuration

Similar to the BurstLOD workflow, this asset centers around ScriptableObjects to decouple data from logic. This allows designers to tune the game feel without recompiling code.

• StarshipProfileSO: Defines the physical mass, engine power, maneuverability curves (agility vs. speed), and boost capacity.
• FlightPersonalitySO: Defines the AI pilot's skill level—tuning their PID gains, aggression, and error tolerance.
• WeaponStats: Configures fire rates, projectile prefabs, and guidance logic (locking angles, range).
• EnvironmentProfileSO: Sets global constants for gravity and atmospheric density, allowing for different "planet" feel settings.

Scalability & Optimization

Dual-Mode Simulation (Physics vs. LERP)To support massive scenes (like the included 1024km² demo), the controller features an automatic LOD system for Physics.

• Physics Mode: Nearby ships use the full Rigidbody simulation for accurate collision and interaction.
• LERP Mode: Distant AI agents automatically switch to a Kinematic Linear Interpolation mode. This drastically reduces CPU load by bypassing complex drag and G-force calculations while maintaining visual movement fidelity.

Event-Driven VFX & UIThe StarshipFXController and StarshipHUDManager utilize a C# Event-driven architecture. This ensures that visual effects (particles, sound) and UI updates only consume resources when state changes occur, rather than polling data every frame.

Upcoming Full Version Features

The upcoming full release of the Atmospheric Starship Controller will expand upon this foundation with a comprehensive suite of advanced systems:

• Advanced Avionics: Includes a fully integrated Minimap and a significantly improved targeting system.
• Expanded Combat: Features enhanced weapon guidance logic and a new physics layer for high-fidelity starship collisions and explosions.
• New Environments: Includes a dedicated Space Demo Scene and a specialized Racecourse Scene for testing high-speed maneuvers.
• Next-Gen AI: Deploys a fully expanded Utility-Driven AI system for complex, autonomous decision-making.

Third-Party Notices:

• Asset uses Sci-Fi Sounds by Kenney under the CC0 License; see the Third-Party Notices.txt file in the package for details.

Documentation

• Atmospheric Starship Controller (Demo Controller): https://docs.google.com/document/d/1bK8_wqpfBkHQ05B-Yrv6QLEylCNeUeeQzIWG-dmVrLk/edit?usp=sharing
• BurstLOD (Core System & Runtime API): https://docs.google.com/document/d/1Sk9thBSGfofy9_fclAIcv66rbWjJ4WfckWfhqC3beGU/edit?usp=sharing

Veridian Atmospheric Starship is a production-grade flight framework engineered for arcade-style combat and atmospheric exploration in Unity’s Universal Render Pipeline (URP).

Designed with modularity as a priority, it provides a complete gameplay loop—from physics-based aerodynamics and input handling to a robust Utility AI system—without the overhead of rigid, monolithic scripts. Whether you are building a "Rogue Squadron" style shooter, a racing game, or an open-world sandbox, this asset offers the foundational architecture required to get ships flying immediately.

Physics-Driven Flight Dynamics

The core of the framework is the AtmosphericStarshipController, a Rigidbody-driven system that balances realistic laws of motion with the responsiveness required for arcade gameplay. It moves beyond simple transform translation, calculating forces to simulate weight, drag, and propulsion.

• Advanced Aerodynamics: Implements a custom drag model that calculates linear and quadratic drag based on velocity, simulating atmospheric density. It features directional drag (allowing for drift mechanics) and ground effects that create a "cushion" of lift when flying low.
• G-Force Simulation: Includes a G-Force governor that limits turn rates at high speeds to prevent unrealistic maneuvers, adding weight and consequence to pilot inputs.
• Scalable Fidelity (Physics vs. LERP): Engineered for scale, the controller features a dual-mode system. While the player and nearby enemies use full physics simulation, distant AI agents automatically switch to a low-cost Kinematic LERP mode to maintain high frame rates in large-scale battles.
• Modern Input Integration: Built entirely on Unity’s New Input System, complete with rebindable action maps for Mouse/Keyboard and Gamepad support.

Modular Utility AI System

The asset features a decentralized AI architecture that separates high-level decision-making from low-level flight execution. This "Brain vs. Hands" approach allows for complex, non-cheating AI behavior that adheres to the same physics limitations as the player.

• The Pilot & The Brain: The AiBrain handles strategic decisions (Targeting, State Switching), while the SimpleAiPilot handles the execution, using PID controllers to fly the ship toward navigation goals. This ensures AI pilots actually "fly" the ship rather than sliding along a rail.
• ScriptableObject Behaviors: AI behaviors are modular and data-driven. You can create and tune complex behaviors—such as Patrol, Dogfight, Interceptor, and Sentry—entirely through ScriptableObject profiles, allowing for rapid iteration of enemy personalities without recompiling code.
• Squadron & Faction Logic: A centralized FactionManager handles team rosters, differentiating between Leaders and Wingmen. The AI utilizes this tactical data to form squads, execute coordinated attacks, and respect engagement/disengagement zones.

Integrated Combat Suite

The asset includes a fully operational combat layer managed by the ShipWeaponController and HealthComponent, designed to support diverse weapon types and damage models.

• Multi-Role Weaponry: Support for primary energy weapons (Lasers with accuracy falloff), secondary ballistics (Unguided Rockets and Guided Missiles with target locking), and heavy bombardment payloads (Gravity Bombs).
• Predictive Targeting: The AI leverages a first-order interception calculator to lead targets based on projectile speed and enemy velocity, ensuring capable and dangerous opponents rather than static turrets.
• Gimbal & Turret Logic: Weapons feature configurable gimbal constraints, allowing hardpoints to rotate and track targets independently of the ship’s nose, within defined arcs.
• Lifecycle Management: A robust health and shield system handles damage mitigation, shield regeneration, and death sequences, including automated respawning via the Faction Manager.

Massive Sandbox Environment

To demonstrate the scalability of the framework, the package includes a massive, production-ready demo scene (1024km² playable area) built for the Universal Render Pipeline (URP).

• Open World Architecture: The scene features 5 distinct 64km² islands, each populated with unique biomes, alien flora, and rocky terrain.
• Live Faction Warfare: The environment is populated by two opposing factions with distinct "Home Bases." You will encounter AI squads flying patrol routes, engaging in dogfights, and defending strategic locations with ground-based turrets.
• Free Art Assets: Includes a library of production-ready assets, including Starship prefabs (Player and Enemy variants), modular buildings, turrets, and environmental assets (alien trees, rocks).

Architecture & Configuration

The system emphasizes a Profile-First Workflow, utilizing ScriptableObjects to decouple configuration from code. This ensures that designers can tweak the "feel" of the game without modifying scripts.

• Data-Driven Profiles: Define ship handling (StarshipProfileSO), AI personalities (FlightPersonalitySO), and weapon statistics (WeaponStats) as reusable assets.
• Decoupled FX & UI: Core logic broadcasts state changes via C# Events. The included StarshipFXController and StarshipHUDManager listen for these events to handle visual effects (thruster particles, muzzle flashes) and UI updates, keeping the core physics loop clean.

Ecosystem & Roadmap

Veridian Atmospheric Starship [Lite] is a free preview of the upcoming full Atmospheric Starship Controller. It serves as both a standalone framework and a demonstration of the Veridian performance ecosystem:

• Integration with BurstLOD: This controller is the foundation for the [BurstLOD] runtime demo. When paired with BurstLOD, the ships in this kit support runtime mesh sculpting—allowing lasers to carve holes in armor and rockets to physically dent hulls in real-time.
• Optimized by VeridianImpostors: The massive density of the demo environment is made possible by [VeridianImpostors], which handles the high-performance rendering of the distant alien forests and background infrastructure.

• Works directly in Scene View (Edit Mode, no Play Mode required)
• Frustum-based performance scanning
• Simulated camera far-clip distance
• Layer filtering support
• Supports MeshRenderer & SkinnedMeshRenderer
• Live HUD overlay in Scene View
• Real-time heatmap visualization
• Top offenders detection system
• One-click optimization helpers (GPU instancing / shadows)
• HTML & CSV performance reports export

Important:
Performance metrics (batches, SetPass, draw calls) are estimated for fast editor optimization and may differ from Unity Profiler results.

🔥 Track performance LIVE in Edit Mode and simulate camera movement to see Play-mode behavior instantly — batches, tris, draw calls, materials and more, exactly in the direction your camera is looking. Ultra-fast optimization for mobile, console and PC.

MAG Performance Radar – Scene View HUD + Heatmap 🔥
Stop guessing where your scene becomes heavy.
MAG Performance Radar shows you real rendering cost directly in Scene View, while you design levels — no Play Mode, no Profiler setup, no workflow interruption.Move the camera → instantly see what becomes expensive.
Just like testing gameplay performance, but inside the editor.🚀 What it does

⚡ Live HUD in Scene View with:
- Estimated Batches
- SetPass
- DrawCalls
- Triangles / Vertices
- Materials
- Shadow casters
- Realtime lights
- Simulates camera view:
- Frustum-based analysis
- Custom far-clip simulation
-Radius scan mode

⚡ Real-time heatmap:
- See heavy zones instantly
- Identify problem segments while building maps
- Click any cell → select all objects inside

⚡ Top offenders detection:
- Heaviest objects ranked automatically
- Click to select & frame
- Jump directly to optimization targets
- Instant optimization helpers:
- Disable Cast Shadows (Undo supported)
- Enable GPU Instancing
- Select material / triangle / batch offenders

⚡ Risk scoring:
- LOW / MID / HEAVY performance indicator
- Mobile-friendly thresholds (Low-end profile)
- Understand performance impact at a glance

⚡ Export tools:
- H TML performance report
-CSV path recording
- Share optimization data with team🎯 Built for real production workflows

⚡ Perfect for:
- Mobile games
- Open worlds
- Simulators
- Large environments
- Level designers

⚡ Optimization passes before releaseInstead of entering Play Mode and opening Profiler constantly, you:
- Move camera in Scene View
- See performance cost instantly
- Jump to heavy objects
- Fix them in seconds. Why it’s different
- Unity Profiler shows numbers.

⚡ MAG Performance Radar shows WHERE the problem is.You see:
- which direction is heavy
- which segment breaks performance
- which objects cause it
and you can fix them immediatelyAll without leaving Edit Mode.🧠 Performance metrics (important)
- Batches / SetPass / DrawCalls are estimated using real renderer grouping
(mesh + material + lightmap + shadow settings).They are designed for fast optimization decisions in editor, not as a replacement for the Unity Profiler.Use Radar → detect problems fast
- Use Profiler → validate final resultsThis combo is extremely powerful.🧩 Profiles included

- Low-end mobile (30 FPS)
- Mid devices
- High-end PC/console

⚡ Custom profiles (save your own thresholds)📦 Use cases

- Optimize mobile scenes before publishing
- Detect heavy map zones instantly
- Validate LOD / shadows / batching visually
- Speed up level design workflow
- Reduce iteration time dramatically💬 Ideal for teams & solo devs

⚡ Level designers see instantly if:
- a prop is too heavy
- a segment kills performance
- shadows are overused
materials break batchingNo need to wait for build or profiling sessions.🏁 Result

You optimize while building, not after.Faster workflow.
- Cleaner scenes.

Better performance on every platform.If you build environments, large maps or mobile games, this tool will save you hours every week.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 54

Animation types : In-place

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 54 FPS Gameplay Spell Animations.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 24

Animation types : In-place

Number of Materials and Material Instances: 1

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 24 Electro Shock Animations in FPS Camera.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 16

Animation types : In-place

Number of Materials and Material Instances: 1

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 16 Gameplay Shoulder Radio Animations in FPS Camera.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Rigging: Yes

IK bones are included: Yes

Number of Animations: 74

Animation types : In-place

Number of Materials and Material Instances: 0

Supported Development Platforms:

Windows: Yes

Mac: Yes

Consoles:Yes

Important/Additional Notes: Camera point is head joint.

| ANIMATION LIST

| PREVIEW VIDEO

| DISCORD SUPPORT

• 74 Gameplay Classic Fists Animations in FPS Camera.
• Manny_FP Model Included.
• HDR Background is for showcase purposes only and is not included.

Number of Audio Tracks: 6

Audio Format: WAV

Sample Rate: 44.1 kHz

Bit Depth: 16-bit

Channels: Stereo

Total Duration: 8:06

Loopable: Yes (except the victory jingle)

File Size: 48.8MB

Compatibility: Compatible with the Unity Audio System

Unity Version: 2020.3 or higher recommended

Bring nostalgic charm and positive energy to your game with this Happy 8-Bit Adventure Music Pack, a collection of uplifting chiptune tracks inspired by classic retro games.

This pack is designed specifically for 2D adventure, puzzle, and light RPG games, providing a cohesive musical experience for different gameplay situations such as exploration, menus, ambience, boss encounters, and victory moments.

The music features bright square-wave leads, classic retro bass lines, and playful melodies that create a warm and engaging atmosphere without overwhelming gameplay. Each track is designed to work well as looping background music, making it ideal for long gameplay sessions.

Whether you're building a cozy indie RPG, a relaxing puzzle game, or a cheerful platformer, this soundtrack will help bring your world to life with nostalgic retro charm.

Included Tracks

• Got a Bit Warm
• Happy Adventure
• Happy Exploration
• Happy Ambience
• Happy Boss Battle
• Level Complete (Victory Jingle)

These tracks cover multiple in-game scenarios, allowing developers to quickly add a consistent musical style across their entire game.

Number of textures 16

Texture dimensions (4096x4096, 2048x2048)

Polygon count of [Triangles 54 638]

Minimum polygon count 54 638

Maximum polygon count 54 638

Number of meshes/prefabs 7

Rigging: Yes

Animation count 25

Animation types (Root Motion/In-place): 6/19

LOD information (count, number of levels)

Description

• 🤖 INFORMATION 🤖

This pack contains:

1. Character - Fantasy Cyborg - Queen

• 🤖 FEATURES🤖

1. ✅ Animated (25 animations)
2. 🎨4 skin for each item

• 🤖 About product🤖

This is game-ready animated character It is ideal for RPG, FPS and all related genres.
*sound, FX not included*

Character has Custom skeleton

• Idle - 2
• Roar - 1
• Turn 180 - 1
• Walk - 8
• Death - 2
• Attack - 5
• Gethit - 6

Character:

Triangles: 54 638

Vertices: 36 605

• 🤖 Support🤖

❤️My friend, don't be shy, write to us❤️ - dramaturg34ru@mail.ru

I'm waiting for your every question, whether it's the stupidest question, or if you need some kind of "special character animation".

I will be happy to reply to any of your messages ❤️

We also have a Discord channel where we publish all the news, updates, information about upcoming sales and also hold giveaway

🎁OUR DISCORD 🎁

[Used source file(s)] sizes

File count : over 1000 tiles

Animated: No

Additional: pixelart, 2D topdown view, tilesets, tile resolution 16x16

✨ Over 1000 16x16 pixelart tilesets pack in one BIG package ready to use ! Multiple dungeon type dans style ✨

✅ Multiple dungeons environments :

• classic
• fire
• egyptian
• ancient
• modern
• and more soon !

Note : Please note this package ships a few sample maps, only to get an understanding of how to use the assets. Screenshots above show how to use the assets as well, but do not represent the samples included. The assets are organised in tilepalettes :)

I hope you like it !

🚨 Important : This package is an extension of 2D Cozy RPG - Farming - Tilesets - Characters - Pixelart FULL BUNDLE | 2D Environments | Unity Asset Store

This means it contains additionnal contents, such as tilesets and/or props.