Asset Store newest packages

Eniv AI Editor Toolkit is a powerful Unity Editor extension designed to accelerate game development using AI without leaving the Unity Editor.

It enables developers to generate Unity C# scripts from natural language, intelligently edit and refactor existing code, automatically apply Inspector attributes, and create textures and voice audio using modern AI models. Everything works directly inside the Unity Editor with an intuitive, workflow-focused UI.

Key Features

• AI Script Generator – Generate complete Unity C# scripts from plain English
• AI Script Editor – Modify and refactor scripts with side-by-side diff preview
• AI Attribute Applier – Automatically apply Inspector attributes intelligently
• AI Texture Generator – Create textures, materials, and prefabs using AI
• AI Text-to-Speech Generator – Generate MP3 voice audio with multiple voices
• Multi-Provider Support – OpenAI, Gemini, Claude, Groq, Grok, OpenRouter, AWS Bedrock, Ollama (local), and Freepik
• Non-destructive Workflow – Review, preview, and apply changes safely
• Works Fully Inside Unity Editor – No external tools required

API Usage

Developers must provide and manage their own API keys for supported providers. This ensures full control over usage, billing, privacy, and model selection.

Eniv AI Editor Toolkit is ideal for developers who want faster iteration, cleaner workflows, and AI-powered productivity directly inside Unity.

Eniv AI Editor Toolkit uses advanced Inspector attributes from Eniv Inspector Kit to provide a clean, well-organized, and visually clear editor UI.

Used attributes include Image, BoxGroup, FoldoutGroup, Tab, IconTitle, Button, and more—helping developers quickly understand and navigate Inspector fields.

• Click-to-pick object inspection system
• Smooth object movement to a configurable inspect position
• Manual rotation using mouse input
• Optional click-to-flip rotation (180° toggle)
• Selectable rotation axis (X, Y, or Z)
• Optional initial inspect tilt (+90° or -90° on pick-up)
• Smooth return to original position and rotation on drop
• Simple setup with minimal scripts
• Clean, readable, and well-documented code

Smooth Object Inspector is a lightweight and easy-to-use 3D object inspection system designed for games and interactive experiences where players need to pick up, examine, and rotate objects smoothly.

With a single click, players can pick up any marked object, inspect it in front of the camera, rotate it using intuitive controls, and drop it back to its original position and rotation. All movements are smoothly interpolated to give a polished, professional feel.

The system is fully customizable from the Inspector, allowing developers to enable or disable features depending on their game design needs.

Customization & Use Cases

This package is highly customizable and suitable for many genres, including:

• Adventure & exploration games
• Puzzle games
• Horror games
• Story-driven and narrative experiences
• Inventory or inspection-based mechanics
• First-person or third-person projects

All interaction behavior (rotation mode, tilt, smoothness, axis selection) can be adjusted directly from the Inspector without modifying code.

Technical Details

• Works with Built-in Render Pipeline, URP, and HDRP
• No external dependencies
• Uses standard Unity Input (legacy)
• Includes a demo scene for quick testing
• Clean folder structure ready for production

echnical Details / Key Features

• Captures high-resolution screenshots from the Game View during Play Mode
• Fully supports:
  Screen Space Overlay UI
  Screen Space Camera UI
  Multiple canvases
  TextMeshPro
• Two capture modes:
  Safe Mode (Game View capture + upscale)
  Pro Mode (native resolution when matched)
• Resolution presets:
  1920×1080 (Full HD)
  2560×1440 (QHD / 2K)
  3840×2160 (UHD / 4K)
  7680×4320 (8K)
• Optional UI hiding during capture
• Optional watermark/logo overlay with corner selection
• Global editor hotkeys (F10 / F11 / F12)
• Optional capture sound effect
• Does not permanently modify Game View resolutions
• Includes cleanup tool for removing legacy custom Game View presets
• Editor-only tool (no runtime impact on builds)
• Compatible with Built-in RP and URP
• Tested on Unity 2021 LTS and newer

Screenshot Pro is a simple but powerful screenshot solution designed for real production use not just static scenes.

Unlike many screenshot tools, Screenshot Pro focuses on reliability and compatibility:

• Captures the actual Game View output
• Supports Screen Space Overlay UI, TextMeshPro, and multiple canvases
• Avoids breaking UI scaling or editor settings
• Works safely alongside URP, camera stacks, and many third-party systems

Capture Modes

• Safe Mode (Recommended)Captures the Game View exactly as displayed and upscales to the selected resolution. This mode offers the highest compatibility and is ideal for most projects.
• Pro Mode (Native)Saves native pixels when the Game View resolution already matches the selected preset. If it does not match, Screenshot Pro automatically falls back to Safe Mode.

Additional Features

• Optional UI hiding during capture
• High-resolution presets (1080p, 1440p, 4K, 8K)
• Optional watermark/logo overlay on screenshots
• Global hotkey capture (F10 / F11 / F12), even when the window is not focused
• Optional sound feedback on capture
• Clean, branded editor interface
• One-click folder access
• Legacy Game View preset cleanup tool

Screenshot Pro is suitable for any genre or project and is especially useful for:

• Marketing screenshots
• Store page images
• Social media posts
• Press kits
• Gameplay documentation
• Rapid iteration during development

Note: Screenshot Pro captures screenshots during Play Mode to ensure accuracy and full UI support.

Requirements

• Unity Version: 2021.3 LTS or newer (tested up to Unity 6)
• Required Assets:
  Game Creator 2 (Core)
  Character Customizer

Render Pipelines

• Built-in Render Pipeline
• URP (tested)
• HDRP (should work, not explicitly tested)

Platforms

• Windows
• macOS
• Linux
  (Uses Application.persistentDataPath for saves)

Features Overview

• JSON-based character save/load
• Per-character save folders
• Scene-based workflow (Create → Select → Play)
• Runtime character loading
• Camera seat preview system
• Editor Quick Start window
• No runtime scripting required

Included Content

• Runtime scripts
• Editor scripts
• Demo scenes
• Documentation (PDF)
• Quick Start window
• Example UI

Does NOT Include

• Character Customizer models or assets
• Game Creator 2 assets
• Animations beyond basic preview usage

Auxilium Integration - GC2 & Character Customizer is a lightweight yet powerful integration asset designed to connect Character Customizer with Game Creator 2.

This package focuses on one goal:

➡️ Turn customized characters into playable GC2 characters with a proper save → select → play workflow.

✨ Key Features

• Each character is saved to its own folder using JSON, keeping data clean and organized.Per-Character Save System
  
• Preview all created characters, switch between them, and choose which one to play.Character Selection Scene
  
• Selected characters are spawned into GC2 gameplay scenes correctly and consistently.Game Creator 2 Compatible Spawning
  
• Automatically moves the camera to focus on the selected character for a polished selection experience.Camera Seat Preview System
  
• No Stats, Inventory, or extra GC2 modules required.Zero Mandatory Add-Ons
  Only requires:
  Game Creator 2 (Core)
  Character Customizer
  
• Documentation & support links Editor Quick Start Window
  Includes a Quick Start panel with:
  Demo scene buttons
  Setup instructions
  Dependency checks
  
• Gameplay Scene (simple example)Demo Scenes Included
  Character Creation Scene
  Character Selection Scene
  

🎯 Designed For

• Survival games
• RPGs
• Character-driven games
• Projects using Game Creator 2 with Character Customizer

• Custom inspector UI exposes export/import, enable/disable, grouping, audio, and debug controls with explicit labels and tooltips.
• Spawn groups support weighted selection with per‑entry overrides for structured spawning patterns.
• Per‑prefab overrides encapsulate selection, pooling, gates, safe zones, initial batch rules, scaling, audio overrides, and events for granular control.
• Runtime logic implements group selection, gating/safe‑zone checks, pooling, burst/wave timing, spawn positioning, audio playback, and debug channels.

SpawnMega provides a custom inspector workflow to configure spawning behavior end‑to‑end: global settings, groups, pooling, gating, safe zones, timing (frequency/burst/waves), spawn locations, initial batch rules, rotations, audio cues, event hooks, and debug logging. It also supports per‑prefab overrides for fine‑grained control and has export/import utilities for moving configurations across scenes/projects.

Fully documented with Tooltips and a PDF covering each option available.

Support available through E-mail: theteam@ccgnomes.co

Number of textures[79]

Texture dimensions[1024, 2048 & 4096]

Polygon count of [1k to 60k]

Minimum polygon count[1k]

Maximum polygon count[60k]

Number of meshes/prefabs[83]

Rigging: No

Animation count[0]

Animation type list[one]

UV mapping: Yes

LOD information (count 8, number of levels8 )

Types of materials and texture maps (PBR & style)

Accelerated Development: These packs allow you to skip the 3D modeling phase . You can start building and populating your game world immediately by simply dragging and dropping pre-made prefabs into your scene . This is invaluable for quickly prototyping game mechanics or creating a Minimum Viable Product (MVP).

Unified Visual Style: A major challenge in game art is maintaining a consistent look. These packs provide a cohesive aesthetic where all models, from characters to props, share a similar design language, color palette, and level of detail . This ensures your final project has a professional and harmonious visual identity.

Optimized Performance: Low poly assets are, by design, efficient. They have low polygon counts and often share materials and textures (texture atlases) . This optimization reduces the strain on the computer or device, leading to smoother frame rates, faster load times, and better performance on mobile and VR platforms .

Cross-Platform Compatibility: Most modern asset packs are built to be compatible with Unity's latest rendering pipelines, like the Universal Render Pipeline (URP) . This ensures your game can easily scale to look great on a wide range of devices, from high-end PCs to mobile phones.

Inspiration and Learning: Many packs include fully fleshed-out demo scenes . These scenes are not just for show; they serve as powerful learning tools and sources of inspiration. You can deconstruct them to understand level design, lighting setups, and how the assets are meant to be used together .

Technical Details

Number of Characters: 5

Average Polycount: ~24,000 – 28,000 triangles per character

Vertices: ~12,000 – 14,000 per character

Textures: None

Materials: Unity Standard Materials (Solid Colors)

File Format: FBX

Rigged: Yes (Humanoid Compatible)

Animations: None

Prefabs: 5 Character Prefabs Included

Render Pipeline: Compatible with Built-in Render Pipeline and Universal Render Pipeline (URP)

Demo Scene: Included

Unity Version: 2021.3 LTS or newer

Stylized Tribal Character Pack

Stylized Tribal Character Pack is a collection of colorful stylized tribal characters designed for indie, stylized, and casual games. Each character uses simple solid-color materials, making them lightweight, easy to customize, and easy to recolor for different game styles or themes.

All characters include a basic humanoid rig, allowing developers to easily add their own animations or integrate the characters into existing animation systems.

This package is suitable for use as enemies, bosses, NPCs, or unique characters in various types of projects such as action games, adventure games, or prototypes.

Package Includes:

- 5 Stylized Tribal Character Models (FBX)

- 5 Ready-to-use Character Prefabs

- Basic Humanoid Rig

- Solid Color Materials

- Demo Scene

Features:

- Stylized tribal character design

- Lightweight solid-color materials for easy customization

- Basic humanoid rig for animation-ready characters

- Ready-to-use prefabs for quick scene setup

- Lightweight setup for quick integration into projects

Technical Details:

- Number of Characters: 5

- Average Polycount: ~24,000 – 28,000 triangles per character

- Vertices: ~12k – 14k per character

- Textures: None

- Materials: Unity Standard Materials (Solid Colors)

- File Format: FBX

- Rigged: Yes (Humanoid Compatible)

- Animations: None

- Render Pipeline: Compatible with Built-in RP and URP

- Demo Scene Included

Ideal For:

- Indie Games

- Stylized Games

- PC Projects

- Mobile Games

- Game Prototypes

Rigging: No

Animation: Animation can be easily migrated with seperated wheels system.

UV mapping: Yes

Pixel Count:

 Vehicles 1.000 Poly*

 Tools 200 Poly* 

*Avarage

LOD Level: 1

Types of materials and texture maps:

Main material for all prefabs

Glass material for truck windows

Texture dimensions:

Gridness Color Pack: 2048x2048 (Resizeable)

♦Gridness Studio Discord Server♦

♦ 11 unique prefabs

Scenes (x2)

♦ Demo Scene

♦ Model List Scene

Driveable Vehicles (x4)

♦ Tructor - Mini

♦ Tructor 

♦ Pickup

♦ FarmCar

Moveable Trails (x3)

♦ Trails

♦ Fluid Carrier

♦ Hay Loader

Vehicle Tools (x4)

♦ Loader

♦ Plough

♦ Weight

♦ Forklift

Materials (x2)

♦ Main Material 

♦ Transparent Glass Material

Wheels (x7)

Changable Wheels

Compatibility

♦ Support Universal Render Pipeline (URP)

♦ Support Built-In Render Pipeline

♦ Support HDRP

♦ Characters are setup to work with Mecanim (no animations included in this pack)

♦ Free Mixamo animations can be used on our characters

Level Optimizer is built around a centralized, persistent optimization manager that operates safely across scene loads without relying on expensive scene-wide searches.

The system uses an event-based registration model, allowing compatible components to register and unregister themselves automatically at runtime. This avoids the use of FindObjectsOfType, ensures pool compatibility, and supports dynamically spawned objects.

Each optimization domain is handled by a dedicated per-component optimizer, ensuring modularity and fine-grained control.

Core Architecture

• Singleton optimization manager (persistent across scenes)
• Event-driven component registration
• Per-component optimizers:
  Renderer Optimizer
  Light Optimizer
  Rigidbody Optimizer
  Animator Optimizer
• Internal HashSet tracking to prevent duplicate processing
• Zero-allocation runtime update loops

[Optimization Systems]

Draw Call Management (Runtime-Safe)

• Optional GPU instancing enablement for compatible renderers
• Controlled runtime adjustment of renderer flags that affect batching
• Optional static batching compatibility hints (editor or pre-runtime)
• No mesh or material rewriting at runtime
• All changes are reversible and non-destructive

This system does not perform destructive mesh operations or force batching behavior that could break lighting or prefabs.

Shadow Optimization

• Distance-based shadow disabling per renderer
• Dynamic global shadow quality adjustment
• Supports Built-in, URP, and HDRP shadow APIs
• Changes are applied gradually to prevent visual popping

LOD Optimization

• Dynamic adjustment of QualitySettings.lodBias based on real-time FPS
• Uses configurable thresholds and smoothing to avoid rapid oscillation
• Fully reversible and pipeline-agnostic

Dynamic Resolution Scaling

• Implemented using ScalableBufferManager
• Gradual resolution scaling to avoid flicker or sudden sharpness loss
• Adjustable minimum and maximum scale limits
• Automatically disabled on unsupported platforms

Physics Optimization

• Runtime tuning of solver iteration counts
• Controlled adjustment of fixedDeltaTime and maximumDeltaTime
• Designed to preserve gameplay stability while reducing CPU load
• Does not disable physics simulation

Mesh Combine (Optional Advanced Feature)

• Optional static mesh combining for scene objects
• Optional runtime mesh combining for controlled scenarios
• Disabled by default and intended for advanced users
• Designed to work with pooled and dynamically spawned objects
• Clear documentation provided on limitations and best practices

Mesh combining is not required for the core optimizer functionality.

Performance Safety & Stability

• No memory allocations during runtime update loops
• Pool-safe and spawn-safe architecture
• Supports large scenes and open-world layouts
• All optimization changes are reversible
• Safe fallback behavior on unsupported platforms or pipelines

Level Optimizer – Performance Management System

Level Optimizer is a lightweight runtime performance management system for Unity that monitors frame rate and dynamically adjusts rendering, quality, and simulation settings to help maintain stable performance during gameplay.

Instead of relying on destructive or editor-only optimization techniques, the system uses safe runtime adjustments that adapt visual quality and simulation behavior based on real-time performance conditions. This makes it suitable for production environments where scene complexity, dynamic objects, or gameplay events can affect performance.

The optimizer continuously monitors FPS and applies controlled adjustments to rendering and simulation parameters such as camera culling distance, shadow quality, LOD bias, resolution scaling, and physics settings. Adjustments are applied gradually to maintain visual consistency while improving frame stability.

Level Optimizer is designed to work reliably in dynamic environments including large scenes, open worlds, procedurally generated content, and systems that spawn objects at runtime.

Key Features

• Runtime FPS monitoring and adaptive performance control
• Dynamic rendering quality adjustment based on frame rate
• Camera-based distance culling with optional layer filtering
• Automatic shadow distance and shadow quality scaling
• Runtime LOD bias adjustment to reduce rendering load
• Optional dynamic resolution scaling when performance drops
• Physics simulation tuning during heavy load conditions
• GPU instancing activation where supported
• Non-destructive runtime adjustments that do not modify assets permanently
• Modular design allowing optimization modules to be enabled or disabled individually

Optimization System

The system uses a modular controller that evaluates frame-time fluctuations and gradually applies performance adjustments when the frame rate falls below the target threshold.

Rather than aggressively changing settings, Level Optimizer applies incremental adjustments to maintain a balance between visual quality and stable performance. When performance recovers, the system can restore higher quality settings automatically.

This adaptive approach helps reduce sudden frame drops while preserving visual fidelity as much as possible.

Editor Configuration Window

Level Optimizer includes a custom Editor Window that provides a centralized interface for configuring optimization behavior.

From the editor window you can:

• Enable or disable individual optimization modules
• Adjust performance thresholds and target frame rate
• Configure rendering and quality adjustment limits
• Apply preset configurations (Mobile / Balanced / High Quality)
• Preview and tune optimization settings during Play Mode

All configuration can be performed without writing code, making the system easy to integrate into existing projects.

Render Pipeline Compatibility

Level Optimizer is designed to work across Unity’s supported render pipelines.

Supported pipelines:

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

The system uses pipeline-compatible APIs and automatically skips features that are not supported by the active pipeline.

Ideal Use Cases

Level Optimizer is suitable for projects that require stable frame rates under varying scene complexity.

Common use cases include:

• Mobile and low-end hardware optimization
• VR and XR applications where frame stability is critical
• Large or open-world environments
• Procedural or dynamically generated scenes
• Games with heavy object spawning or pooling systems
• Projects requiring adaptive performance management during gameplay

Included in the Package

• Runtime optimization system
• Modular performance control components
• Custom editor configuration window
• Demo scene with FPS visualization
• Documentation and usage guidelines

Technical Overview

• Implemented using safe runtime Unity APIs
• Non-destructive system that does not permanently modify assets
• Compatible with dynamically spawned and pooled objects
• Designed to run during gameplay without altering project files
• Modular architecture allowing flexible configuration

Limitations & Notes

Performance improvements depend on project complexity, target platform, and hardware capabilities.
Level Optimizer adjusts supported Unity runtime settings but does not replace proper optimization practices such as efficient assets, optimized shaders, and good scene design.

Support

For support, bug reports, or feature requests:

📧 yousseftq77@gmail.com

Lexis FREE - Feature List

Core Localization (fully functional, no limits):

- Unlimited translation keys

- Unlimited supported locales

- JSON and CSV file format support (read/write)

- TextMeshPro integration with per-locale font overrides

- UI Toolkit integration with UXML attributes

- Full RTL (right-to-left) and bidirectional text support

- Smart Strings: pluralization, gender, conditionals, number/date/currency formatting

- System locale auto-detection

- Locale-aware formatting (CultureInfo)

- Event-driven architecture (OnLocaleChanged, OnLocalizationReady)

- Zero MonoBehaviour dependencies — DI-friendly

Runtime Components:

- LocalizedTMP (TextMeshPro)

- LocalizedLabel (UI Toolkit)

- LocalizedText (Legacy UI)

- LocalizedImage (locale-specific sprites)

- LocalizedAudio (localized audio clips)

- LocalizedTexture (localized textures)

- LocalizedPrefab (localized prefabs)

- LocalizedFont / LocalizedLegacyFont

- RtlLayoutGroup (automatic layout flipping)

Editor Tools:

- String Table Browser with virtualized scrolling

- In-editor Language Switcher

- Setup Wizard with integration detection

- JSON and CSV Import

- Inspector property drawers with key dropdowns

- Multi-table workflows

Compatibility:

- Unity 2020.3 LTS through Unity 6

- All platforms: Windows, macOS, Linux, Android, iOS, WebGL

- All render pipelines: Built-in, URP, HDRP

Dependencies:

- Required: Unity 2023.1+ OR UniTask

- Optional: TextMeshPro, UI Toolkit, ZString

Upgrade to Lexis Pro for:

- Auto-Translation (DeepL, OpenAI GPT, Google Translate)

- Google Sheets cloud sync with bi-directional collaboration

- XLIFF provider for professional TMS integration

- PO/Gettext provider

- Sync operations (Pull/Push) with conflict detection

- File watching for live reload

- Validation tools (missing translations, unused keys)

- CI/CD unused key detection

- Pseudo-localization testing

- Full source code

Website | Documentation | Discord | Pro Version

Lexis FREE is the essential localization toolkit for Unity developers who want to ship multilingual games without wrestling with complex systems.

Unlike Unity's built-in Localization package, Lexis requires no Addressables dependency and features a pure C# architecture that works seamlessly with dependency injection frameworks like Zenject and VContainer.

Number of textures: 9

Texture dimensions: 2048 x 2048

Minimum polygon count: 80

Maximum polygon count: 2028

Number of meshes/prefabs: 10

Rigging: No

Animation count: 0

UV mapping: Yes

LOD information: None

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

- Albedo

- Mix map (metallic & roughness)

- Normal

There are 10 props, suitable for cozy, stylized and cute genres. Can be usable for urban areas,interiors and variable places.

Barrel: 596 tris

Box: 80 tris

Shopping Cart: 1988 tris

Standing street lamp: 2020 tris

Wall street lamp: 958 tris

Traffic cone: 534 tris

Small trash bin: 2028 tris

Big trash bin: 1204 tris

Vending machine: 1072 tris

Slippery floor sign: 548 tris

Movable parts (wheels, lids) separated

UV unwrapped

Texture size: 2048 x 2048

No LODs

The included materials are using URP, however you can easily change the render pipeline by making a new material and assigning the textures.

• Total sword count: 69
• Matching icon set included
• 3D format: FBX
• Texture format: PNG
• Transparent icon PNGs included in 64x64, 128x128, 256x256, and 512x512
• Unity materials included
• Unity prefabs included
• Demo scene included
• Total triangle count: 69,970
• Average triangle count: approximately 1,014 triangles per sword
• Minimum polygon count: approximately 980 triangles per sword
• Maximum polygon count: approximately 1,015 triangles per sword
• Number of meshes/prefabs: 69
• Rigging: No
• Animations: No
• UV mapped: Yes
• LODs: No
• Material type: URP/Lit
• Texture maps included: Base Color

Royal Swords Pack - 3D Models & Icons is a stylized fantasy weapon collection built around a polished royal / ceremonial sword theme. The pack is designed for developers who want a cohesive sword library with matching 3D assets and 2D inventory presentation inside Unity.

The package includes 69 unique sword models, each paired with a matching icon. The set is not based on simple recolors: every sword has its own shape variations, silhouette differences, and visual identity while still fitting the same overall art direction. Across the collection, the swords explore multiple magical and elemental-inspired themes, giving the pack broader visual variety while preserving a unified look.

Matching transparent icons are included in 64x64, 128x128, 256x256, and 512x512 resolutions, making the pack useful both for in-world weapon presentation and UI-driven systems such as inventories, loot panels, equipment menus, and fantasy item shops.

This pack is well suited for RPGs, fantasy action and adventure games, stylized indie projects, and mobile-friendly workflows that benefit from lightweight weapon assets with consistent presentation. Because the models and icons share the same visual language, the collection works as a unified production-ready library rather than a set of disconnected standalone assets.

Format: WAV (High Fidelity)

Specs: 48kHz / 24-bit

Tuning: 440Hz

Total Files: 6 (3 Full Tracks + 3 Seamless Loops)

Loop-ready: All files marked with _Loop are professionally edited for infinite playback.

Custom Services & Support

Need a custom variation or a completely new track for your game? Contact me at: ivanbenedetti3@gmail.com

🎻 Every great adventure begins in a tavern...

Give your RPG, Adventure, or Visual Novel the warm, authentic atmosphere of a medieval inn. Tavern & Bard Music is a collection of 6 high-quality tracks featuring the intimate interplay between Classical Guitar and Flute.

What's inside the pack?

This collection includes 3 unique themes, each provided as a Full Track and a Seamless Loop:

00_Sunrise_Prelude_Full (01:34) - Atmospheric morning theme

01_Sunrise_Prelude_Loop (00:43) - Seamless loop version

02_A_New_Bard's_Tale_Full (03:06) - Lively and rhythmic tavern dance 03_A_New_Bard's_Tale_Loop (00:22) - Short seamless loop for backgrounds 04_Romanesca_Full (02:18) - Traditional courtly melody

05_Romanesca_Loop (01:05) - Extended seamless loop

(Note: preview is a short medley. The pack includes all full-length tracks and seamless loops)

What’s Inside the Pack:A comprehensive set of 4 high-quality WAV files (24-bit / 48kHz):

• 00_Seraphim_Full_Track_528Hz (4:18) – Complete musical journey.
• 01_Seraphim_Intro (0:54) – Perfect for cinematic transitions.
• 02_Seraphim_Seamless_Loop (0:31) – Edited for infinite, glitch-free repetition.
• 03_Seraphim_Ending_Stinger (0:54) – Solemn resolution for dramatic endings.

Technical Specifications:

• Format: WAV (24-bit / 48kHz)
• Total unique audio: 6+ minutes
• Number of Audio Waves: 4
• Do Audio Loops: Yes (Track 02)
• Supported Platforms: All (Mobile, Desktop, Console)

Elevate the spiritual and emotional atmosphere of your project with Seraphim.

Inspired by the timeless mastery of Renaissance polyphony (Palestrina, Gesualdo, Monteverdi) and Classical elegance (Mozart), this pack blends historical counterpoint with contemporary original composition.

The 528Hz Advantage:The entire composition is tuned to the 528Hz frequency, often referred to as the "Love Frequency." This specific tuning is designed to provide a deeply immersive, harmonizing, and relaxing experience, making it ideal for:

• Ancient Cathedrals & Sacred Temples
• Mystical or Divine Revelations
• High-Fantasy RPG exploration
• Meditation & Healing-focused games

Studio Master Edition:Unlike compressed versions, these files provide high-definition 24-bit vocal polyphony without background drones, ensuring every contrapuntal voice remains crystal clear even when played alongside game SFX.

Tracklist & Durations:

• 00_Harlequin_Full_Suite (05:33) - Complete narrative journey
• 01_Harlequin_Welcome (01:05) - Noble Intro & Ethereal Theme
• 02_Harlequin_Mischief (00:41) - Fast, quirky 2/4 action
• 03_The_Heros_Confidence (01:05) - Triumphant orchestral transition
• 04_The_Masks_Sorrow (01:33) - Emotional F-minor Aria
• 05_Harlequin_Farewell (01:09) - Reprise & Grand Finale

Technical Specs:

• Audio Quality: High-fidelity 24-bit / 44.1kHz WAV
• Format: Seamlessly compatible with all Unity Render Pipelines
• Total Length: Over 11 minutes of original music

Harlequin Orchestral Suite is a meticulously crafted collection of 6 neo-classical orchestral compositions. Designed for game developers who need a sophisticated, emotional, and high-quality soundtrack, this suite brings a touch of classical elegance to any project.

Whether you are building a fantasy RPG, a historical drama, or a narrative-driven adventure, these tracks provide the perfect atmosphere to immerse your players. 100% Human-Composed: This suite is entirely created and orchestrated by the composer. No AI tools were used in the creative process, ensuring a unique and authentic musical soul for your project.

📏 Technical Info:

- Format: FBX + Unity Prefabs

- Texture Sizes: 4096x4096

- Poly Count: Optimized for performance

- Unity Version: 2021.3+ recommended (URP or Built-in supported)

All models are UV-unwrapped and include:

✔️ Textures (Base Color, Normal, Roughness, Metallic, Height)

✔️ Materials set up for Standard Pipeline

✔️ Prefabs for quick scene placement

📂 Folder Structure:

- Models/

- [Each model with its Materials & Textures]

- Prefabs/

- Ready-to-use prefabs

- Scenes/

- Showcase scene (drag and drop to view models)

- Documentation/

- This file :)

📌 Notes:

- You can use these assets in both personal and commercial projects.

- Redistribution or resale of the assets as-is is not allowed.

📧 Support:

For any issues or suggestions, contact me via Unity Asset Store profile or email: [onurdgn2023@gmail.com]

🔥 Thank you for downloading this pack! Don’t forget to leave a review if you like it!

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

• Render Pipeline: Built-in / URP / HDRP compatible
• Texture Format: PNG
• Sprite Type: 2D Sprite (UI)
• Customization: Easily scalable.
• Demo Scene: Included

This asset pack contains a collection of modern UI button sprites designed for game interfaces and applications.

The package includes buttons in various shapes such as rounded rectangles, circles, capsules, and organic forms, with multiple color variations. All sprites are clean, lightweight, and easy to integrate into Unity projects.

There are 66 buttons in the package, and most of them are sized at 256x128.

A versatile asset that provides everything you need to bring your tower defense game idea to life. Check the Readme to learn how to get started or try the demos below.

Online Readme

Windows Demo - Controls: Left click to select, right click to cancel, middle mouse button to pan.

Android Demo (APK)

• Full 2D/3D support - Automatic Camera setup, entity rotation in 2D and 3D, support for 2D sprite animation (2,4,6,8 dimensions) and correct positioning of entities when they attack each other.
• Round Manager - Flexible system for creating rounds and waves for your game right in the inspector, supports endless mode.
• Path - The asset supports 3 types of paths. SplinePath, GridPath and GridAutopath: you can create mazes by building your towers and enemies will find the path to the exit automatically!
• Placement - You can define how players can place their towers in 3 ways: on the grid, freely within boundaries and with collision checks or in pre-designated spots on the level.
• Save/Load - save and load system so your players can continue the playthrough right where they left off.
• Towers and Units - Some TD games need only towers and enemies, others also require allied units to add complexity to the game. You can do both with this asset.
• Attack - Different attack patterns to create variety of towers and entities for your game. Melee, Ranged, Fires and Lasers. Also supports modifications: Multitarget, Bounce, Splash, Crit and Bash. Plus ability system that allows you to create unique attack modifications.
• Ability - Flexible ability system that allows you to create any ability, samples are provided to get you started! Create auras, stun enemies, apply burning effects, heal your units in the area and more with the comprehensive ability system.
• Leveling - Leveling capability allows your entities to gain XP and increase their levels, changing their stats. You can use it for heroes of your game, or towers. The choice is yours.
• Technology - Keep the availability of towers and abilities behind technology trees to make your game more interesting.
• Resources - Easily create and customize new resource types.
• Armor/Damage - Define your own armor and damage types with the corresponding effectiveness to add more layers to your gameplay.
• Audio System - Audio is important part of any game, and this asset allows you to define what kind of sounds should be played when entities interact with the world around them.

Assets used for 3D and 2D demo scenes: Tower Defense Kit (Kenney Game Assets) under CC0 1.0 Universal license; Free 2D Orcs Sprite Sheets and Free Stone Tower Defense Game Art under Freebie license. See Third-Party Notices.txt file in package for details

Technical details

Features

• Raycast-based interaction system (single-button, mobile-friendly)
• Pickup system for objects and keys (no trigger-based auto pickup)
• Advanced door system (open/close, key requirements, creak sounds)
• Exit door with dynamic “keys remaining” prompt and win panel
• Note / paper reading system with fullscreen UI and sound
• Radio / audio interactables
• Advanced horror enemy AI (patrol, investigate, chase, search)
• Trigger-based enemy kill with jumpscare sound and camera shake
• Environmental scare system (proximity-based falling objects)
• Proper pause & settings system (audio, graphics, logic-safe pause)
• Camera shake effects for scares and death
• Editor tools for batch-renaming materials and textures

Supported platforms

• Android
• iOS

Supported OS

• Android 8.0+
• iOS 13+

Link to documentation

Included in the package

🕯️ Modular Horror Game Interaction & Gameplay System

Create tense, immersive horror experiences without wrestling with messy trigger logic or reinventing core systems.

The Modular Horror Game Interaction & Gameplay System is a production-ready framework built for Unity developers who want to focus on atmosphere, fear, and storytelling—not boilerplate code.

Designed from the ground up for mobile and PC, this package replaces outdated auto-pickup and trigger-based mechanics with a clean, raycast-driven interaction system that feels deliberate, modern, and immersive.

Every action is player-driven. Every interaction builds tension.

🔦 One Button. Every Interaction.

A single, intuitive interaction button controls:

• Picking up objects
• Collecting keys
• Opening and closing doors
• Reading notes and documents
• Interacting with radios and audio props
• Triggering the final escape

This makes the system perfect for mobile controls while remaining just as effective on PC and console.

🚪 Intelligent Door & Key System

No more “all or nothing” key logic.

Doors can:

• Require any number of keys
• Display exactly how many keys are missing
• Open and close smoothly
• Play atmospheric door creaks
• Behave independently from the final exit door

The exit door clearly communicates progress, building pressure as the player searches for the last remaining key.

📜 Environmental Storytelling

Deliver lore the right way.

Notes and papers can be read in-game through a fullscreen UI that:

• Freezes gameplay
• Plays paper rustle sounds
• Keeps the player immersed
• Prevents accidental interactions behind UI

Perfect for logs, warnings, diaries, and unsettling messages.

😈 Horror-Focused Enemy AI

Enemies aren’t just moving obstacles — they’re threats.

• Patrol, investigate, chase, and search states
• Vision-based detection (field of view + raycast)
• Hearing-based reactions to player movement
• Clean, trigger-based kill system
• Jumpscare audio and camera shake on death

No physics pushing. No janky collisions. Just controlled, cinematic horror moments.

🎥 Impactful Horror Feedback

Fear is in the details:

• Camera shake for kills and scripted scares
• Environmental objects that fall when the player approaches
• Loud, positional sound cues to disorient and panic the player
• Enemy jumpscare audio that hits instantly

These small touches dramatically increase tension without heavy performance costs.

⏸️ Proper Pause & Settings System

A real pause system — not just Time.timeScale = 0.

• Fully freezes gameplay logic
• Blocks player input and AI
• Built-in settings menu
• Audio and graphics options
• Mobile-safe UI workflow

🛠️ Editor Utilities Included

Speed up your workflow with built-in editor tools:

• Batch-rename materials with _mat
• Batch-rename textures with _texture

Small tools that save real development time.

🚀 Built for Expansion

This system is modular by design.

Easily extend it with:

• Inventory systems
• Multiple enemy types
• Sanity mechanics
• Story triggers
• Procedural scares
• Additional interactables

Use it as a foundation for:

• Full horror games
• Game templates
• Prototypes
• Asset Store projects

• Includes 2 complete playable game templates: Arrow Escape (grid-based logic puzzle) and Solitaire Associations (card based solitaire-puzzle)
• Built on a modular HyperCasual Game Engine core architecture
• Shared core systems: Audio Manager, UI System, Camera Controller, Level Flow Manager
• Custom Unity Editor tools for fast level creation
• Data-driven level system (JSON & ScriptableObjects)
• Clean, scalable C# code structure
• Namespace isolated (HypercasualGameEngine)
• No third-party dependencies
• Mobile-ready (Android & iOS compatible)
• Optimized for hypercasual, puzzle, and arcade game development
• Beginner-friendly structure with production-ready workflow
• Designed for rapid prototyping and reskin-ready projects
• Ads Mediation (Admob) included

🚀 HyperCasual Game Engine – FREE Starter Pack (2 Game Templates Included)

Try the workflow before committing.

The HyperCasual Game Engine – FREE Starter Pack includes 2 playable game templates from the full toolkit, designed to help you explore the architecture, editor tools, and development pipeline for building hypercasual mobile games in Unity.

👉 Try First: Browser Demo | Android Demo

🎮 Included Game Templates

#1 Arrow Escape

A grid-based puzzle game template where arrows move in their facing direction and interact with other elements on the board. Designed to demonstrate logic systems and level-based gameplay.

#8 Solitaire Associations

A card-based puzzle game template focused on matching item cards to category cards across different piles, showcasing structured gameplay flow and UI systems.

📦 What’s Included in Each Template

• Core gameplay systems
• 1 sample level for testing and iteration
• UI setup and integration
• Modular C# architecture
• Shared core systems (Audio, UI, Camera, Level Flow)
• Namespace-based structure (HypercasualGameEngine)
• Admob Ad Mediation
• Level Editors for both games

These templates are intended as a foundation for building and customizing your own games, not as final publish-ready products.

🛠 Built for Prototyping & Learning

This starter pack is ideal for:

• Exploring game templates and reusable systems
• Building your own mobile game concepts
• Rapid prototyping for hypercasual and puzzle games
• Learning modular architecture and Unity editor workflows
• Creating variations for game jams or puzzle jams

No third-party dependencies.
Supports Android & iOS.
Structured for scalability and customization.

Ads mediation inlcuded (Admob)

🔓 Upgrade to the Full Toolkit

Unlock the complete package:

• 20 game templates
• Expanded puzzle game and arcade mechanics
• Advanced level systems and editor tools
• Ongoing updates

👉 Get the full HyperCasual Game Engine

Start prototyping and building your own hypercasual games today.