Feed aggregator

Core Technical

• Model Context Protocol
• HttpListener
• NewtonSoft.json
• C# Standard 2.0

This is a Unity implementation based on the Model Context Protocol (MCP), enabling AI assistants (Cursor, Claude Code, OpenCode) to directly control the Unity Editor and runtime applications.

Pure C# Implementation

Fully developed in Unity, compatible with Unity C# syntax.

MCP Protocol

Supports almost all features defined in the MCP protocol documentation (except Prompts).

Tool Development and Extension

• Provides 80 built-in editor tools
• Offers a simple tool definition method for users to extend tools according to project requirements
• Protocol supports multiple data types:
• Basic data types
• Unity built-in geometry types
• Array types
• User-defined custom types (with constraints)

AI-Assisted Coding Support

Provides AGENTS.md file for secondary development and extension with AI.

Modes

Supports both Editor and Runtime modes.

🧩 Technical Details

• Total prefabs: 168
• Total tris for each prefabs: Between 96 verts to 196 000 verts
• 90 unique material sets for optimal quality and performance
• Colliders: Custom mesh colliders and primitive colliders included
• Textures: PBR, optimized for modular use (4096 to 1024). Downgrade as you need for better performance on mobile.

⭐ Community ⭐

Join the Friday Night Studio Discord for support, exclusive updates, freebies, vouchers, and early access to new packages 🎁:

🚀 FRIDAY NIGHT STUDIO - DISCORD 🚀

🤝 Overview

This modular Futuristic Environment Pack is the Third entry in our biggest and most ambitious series yet. We are really excited to finally share it with the world! 💫

If you want to expand the environment even further, feel free to check out the others packages in the series, designed to connect seamlessly with each other.🧩

• Vol.1 Futuristic Environment Kit – Sci-Fi Mega Mall
• Vol.2 Futuristic Environment Kit – Sci-Fi Living Facility
• Vol.4 (Coming Soon)

Take a look at our unity asset store page for more futuristic environments! ✨🏞️

• Friday Night Studio - Unity Asset Store

Perfect for PC, consoles, VR, Mobile, games, cinematic projects, and interactive experiences. 🎮🎥

• Fully modular parts with PBR Metallic Roughness workflow.
• Game-ready prefabs and materials.
• Optimized colliders for smooth gameplay.
• Demo scenes included for easy showcase and testing.

🚀 Pipeline Compatibility

🛠️ All materials and prefabs already converted and ready to use.

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

✔️ Notes:

• Lighting and post-processing settings may vary between render pipelines. Adjust them as needed for your scene. 💡
• There are no scripts or animations included in this pack. Everything is modular, allowing you to customize each piece and attach your own scripts and animations as needed.
• The main Hall features four entry/exit points, allowing you to easily expand and build around it. Modular corridors and airlock sections (SAS) are included in the package.

The packs contains mainly :

• A main Hall Reception room
• Corridors
• Architectural waiting rooms
• Armory
• garage
• Shooting range
• Offices
• upgrade rooms
• Weapon rooms
• Offices rooms
• control rooms
• storage room
• vegetation room

⭐Follow us for updates, promotions, previews & more⭐:

DISCORD | INSTAGRAM

• File Format: FBX
• Texture Type: PBR (Albedo, Normal, Maskmap, AO)
• Texture Resolution: 2K
• Poly Count: Low to Mid Poly
• Materials: Compatible with Built-in 
• Scale: Real-world scale (meters)
• UV Mapping: Clean
• Prefab Setup: Ready-to-use prefabs included
• Platform Support: PC, Mobile, VR/AR
• Unity Version: 2022+ (or latest recommended)

Hospital Equipment Pack is a high-quality collection of realistic and optimized 3D medical assets designed for hospital environments, healthcare simulations, and medical training applications.

This pack includes a wide range of essential hospital equipment such as hospital beds, patient monitors, IV stands, Anesthesia Machine, Operation Light, Operation Table, wheelchairs, medical cabinets, X_Ray Flim Viewer and other clinical props. Each asset is carefully modeled with accurate proportions and optimized topology to ensure smooth performance in real-time applications.

All models are built with performance in mind while maintaining high visual fidelity, making them ideal for games, VR/AR experiences, simulation projects, and architectural visualization.

The assets are easy to use, well-organized.

Polygon count of computer: 88

Polygon count of streampad: 4117

Polygon count of triple computer screen: 385

Polygon count of computer screen: 250

Polygon count of microphone: 4468

Polygon count of headset: 782

Polygon count of keyboard: 13722

Polygon count of speaker: 898

Polygon count of mousepad: 14

Polygon count of mouse: 514

Polygon count of webcam: 578

Polygon count of table: 130

Polygon count of hex wall light: 24

Polygon count of hex wall light group: 168

Number of textures: 9

Texture dimensions: (Mousemat) 1920X1080

Texture dimensions: (Wood) 4096x4096

Texture dimensions: (Mic) 2769x2149

Texture dimensions: (Icons) 242x242

Number of meshes/prefabs: 27 prefabs

Number of Materials: 39

Number of Sprites: 15 (icons)

Number of scripts: 3 

Rigging: No

Animation type list: No animations

Animation count: No animations

UV mapping: No

LOD information (count, number of levels): No LOD

Types of materials and texture maps (e.g., PBR): Default / sprites

Whether you are building a life-simulator, a narrative-driven adventure, or a social hangout space, the Streamer Pack provides all the essential "clutter" and high-tech gear needed to make a room feel lived-in and modern.

What's Inside?

This pack contains 14 unique 3D models with 13 variants.

- Computer

- Streampad

- Triple computer screen

- Microphone (+2 extra variants)

- Headset (+1 extra variant)

- Keyboard (+1 extravariant)

- Speaker (+1 extra variant)

- Mousepad (+4 extra variants)

- Mouse (+2 extra variants)

- Computer screen (+1 extra variant)

- Webcam (+1 extra variant)

- Table

- Hex wall light

- Hex wall light group

RGB & Visual Audio

The Hex Wall Lights and a Microphone variant feature a continuous, smooth color-cycling effect. Perfect for that "Gamer Aesthetic". The Speaker includes a built-in "vibration" script that you can turn on and off.

본 에셋은 (판교)가상융합산업허브에서 실감형 콘텐츠 제작 교육을 목적으로 제작된 무료 HMD Unity 프로젝트입니다.

HMD 환경에서 360° 영상 콘텐츠를 적용하는 방법, Ambix(FOA) 공간 음원을 활용한 배경 사운드 구성,

움직이는 오브젝트에 공간 SFX를 적용하는 기본 구조를 실제 동작하는 프로젝트 소스를 통해 직접 확인하고 분석할 수 있도록 구성되어 있습니다.

주요 내용

✅ HMD 기반 360° 영상 적용 예제

✅ Ambix(FOA) 음원을 활용한 공간 음향 구성 예제

✅ 이동 오브젝트에 대한 Spatial SFX 적용 구조

✅ 360 영상, Ambix 음원, SFX 샘플 리소스 포함

✅ 별도의 설정 없이 바로 실행·분석 가능한 프로젝트 형태 제공

제작 배경

실감형 콘텐츠 제작은 영상 포맷, 공간 음향 구조, HMD 환경 설정 등 초기 진입 단계에서 많은 시행착오가 발생합니다.

본 프로젝트는 단순 튜토리얼 영상이 아닌, 실제 Unity 프로젝트 전체 구조를 그대로 제공함으로써 제작자가 직접 씬 구성, 오디오 세팅, 컴포넌트 연결 방식을 하나하나 분석하며 학습할 수 있도록 설계되었습니다.

대상 사용자

실감형 콘텐츠 / XR / VR 제작 입문자

Ambix 공간 음향을 Unity에 적용해보고 싶은 개발자

HMD 기반 360 영상 콘텐츠 제작을 처음 시도하는 크리에이터

교육·R&D 목적의 실감형 콘텐츠 제작자

라이선스 및 이용 안내

본 프로젝트는 교육 및 연구 목적의 무료 에셋입니다.

포함된 미디어 리소스는 학습 및 테스트 용도로 제공됩니다.

360 영상 원본 파일은 제공되는 Google Drive 링크를 통해 별도로 다운로드할 수 있습니다.

▶ Google Drive : https://drive.google.com/drive/folders/1QMtR6OuZ8Jln_p61UHv9UL--w2dVHqJ6?usp=drive_link

This free Unity asset is an educational HMD project developed by MetaverseHub in Pangyo to support immersive content creators and lower the entry barrier to XR production.

The project demonstrates, using real and fully functional source code:

• How to apply 360° video content in an HMD environment
• How to integrate Ambix (First-Order Ambisonics) audio as spatial background sound
• How to implement spatial SFX for moving objects

Rather than providing only scripts or video tutorials, this asset delivers the entire Unity project, allowing creators to inspect, analyze, and modify the structure in detail.

Key Features

• ✅ 360° video playback setup for HMD
• ✅ Ambix (FOA) spatial audio implementation example
• ✅ Spatial sound effects applied to moving objects
• ✅ Sample SFX, Ambix audio, and 360° video assets included
• ✅ Ready-to-run Unity project for direct analysis and learning

Why This Project Exists?

Creating immersive XR content often involves a steep learning curve due to:

• Complex video and audio formats
• Spatial audio configuration
• XR and HMD-specific setup requirements

This project is designed to go beyond basic tutorials by providing a fully structured reference project.

Creators can explore scene hierarchy, audio routing, component setup, and playback logic directly inside Unity, enabling deeper understanding than tutorial videos alone.

Target Audience

• XR / VR developers getting started with immersive content
• Creators experimenting with Ambix spatial audio in Unity
• Developers building HMD-based 360° video experiences
• Educators, researchers, and R&D-focused immersive content teams

License & Usage Notes

• This asset is provided free of charge for educational and research purposes.
• Included media assets are intended for learning and testing.

External Media Download Notice

Due to Unity Asset Store file size limitations, high-resolution 360° video files are not included in this package.

The original 360° video files can be downloaded separately via the provided Google Drive link.

▶ Google Drive : https://drive.google.com/drive/folders/1QMtR6OuZ8Jln_p61UHv9UL--w2dVHqJ6?usp=drive_link

Asset uses TextMesh Pro and Liberation Sans under their respective licenses; see Third-Party Notices.txt file in package for details.

Unity 6 (6000.0+) · Both Input System modes · No third-party dependencies

QuickSplash is an editor tool that builds your splash screen scene for you. Open the window, load a config, add your logo entries, and click Generate. The tool writes a fully wired Unity scene — Canvas, camera, background, all logo players, and the sequence controller — without you touching the Hierarchy.

Each entry supports four media types: a plain Texture2D, a Sprite, an animated GIF, or a VideoClip. GIFs are decoded at editor-time using a built-in pure-C# GIF89a parser, so there are no runtime DLL dependencies and no platform restrictions.

Per-entry timing gives you independent control over fade-in, hold, and fade-out durations. The fade system runs on unscaled time, so it behaves correctly even when Time.timeScale is zero.

Entries can be marked as Required, which prevents them from being skipped regardless of the global Allow Skip setting — useful for legal or compliance screens.

The black-and-white editor UI is clean and keyboard-friendly. Cards in the entry list are reorderable with responsive ▲/▼ buttons that only appear when they are actually useful. The generator is non-destructive: delete the output folder and regenerate at any time.

Compatible with Unity 6 (6000.0+).

Polygons: 139K

Vertices: 71.5K

Texture Resolution: 2K-4K Textures

Texture Maps: Base Texture, Outline Mask Texture, Alpha Textures, Matcap

Shader: Lil Toon Shader, Shader included with the package (https://github.com/lilxyzw/lilToon).

Materials: Eight Materials

Prefabs: Two

Rigged: Yes (Humanoid Rig)

UV Mapping: Yes

This Character is setup with Magica Cloth 2 for Hair & Cloth physics, if you don't have magica cloth 2 you will not be able to use realtime physics. Two prefabs are provided for each use case: one with magica cloth 2 setup & other with just basic constraints setup.

Character: Noel

Sex: Female

Rig: Humanoid

Facial Expressions (Blendshapes/Shape Keys): Total 128 Blendshapes. Facial Expressions are provided as Blendshapes (Shape keys). There are lots of Blendshapes for each Elements of the face which you can use to make any expression you like. Comes with 52 ARKit iPhone Blendshapes, Basic MMD Blendshapes, VRChat Visemes & Eye Look Blendshapes, Many other Blendshapes for Face expressions etc.

Animations: Supports all kinds of Mixamo animations or any other Humanoid based animation.

Support: Unity 2021.3 or Later

Pipeline: All Render Pipelines Supported (Built-in, URP, HDRP).

A Readme file is provided inside the package, please make sure to read & follow the necessary instructions before using the asset.

Mobile support

AAA Rpg Choices

Advanced Dialogs

Multiple endings

Time control for cutscenes

Built to call methods between choices and dialogs

Wizard combat system with advanced AI

Complete third person movement

Wizard School RPG Choices and Dialog Pro contains Wizard School RPG Choices and Dialog System and Wizard School Fighting Engine plus a dedicated mobile support. If you don't need the mobile support, you can get it here for a lower price:

Wizard School RPG Choices and Dialog System

If you want publish your game for Android and iOS, get the pro version with mobile support:

WIZARD SCHOOL FIGHTING ENGINE PRO

Also want fly with Broomstick? Get Broomstick Engine:

WIZARD SCHOOL BROOMSTICK ENGINE

Want a multiplatform AAA Save System?

WIZARD SCHOOL AAA SAVE

Ever dreamed of creating your own wizard combat RPG or open-world magic adventure? Wizard School RPG Choices and Dialog System is an action-packed RPG Choice and Dialog system, designed for AAA RPGs, bringing intense wizard duels, powerful spells, and epic magic battles to your game

Design emotionally charged conversations, branching storylines, and long-term consequences that shape the world, the characters, and the player’s ultimate fate. From subtle dialog variations to radically different endings, this system is crafted to support narrative depth at a professional production level.

Read to build your own wizard world with multiple choices and endings? Maybe you’ve tried other systems, but they were either too complicated or didn’t deliver the AAA wizard action you were looking for. Either way, your wait is over.

Wizard School RPG Choices and Dialog System is an easy-to-use, action-focused system that lets you build high-quality exploration with multiple story paths, consequences and an advanced combat system with AI for RPGs and open-world adventures. Inspired by AAA wizard duels, it gives you everything you need for dynamic, spell-fueled battles.

Here’s what you get with our powerful third-person wizard combat controller:

• Advanced RPG Choice and Dialog system
• Magical attacks, defenses, and cinematic spellcasting
• Target by distance or lower health
• Full third-person movement
• Wizard combat AI
• Full support for Xbox, Nintendo Switch, and PlayStation controllers
• Simple drag and drop system
• Use new Input system package to simplify player input
• Mobile support

Engineered for ambitious projects, it scales effortlessly from intimate character moments to complex, interconnected narrative arcs. Whether you’re building a dark fantasy epic, a narrative-focused RPG, or a story-rich adventure, this asset gives your team the freedom to direct the story like a film, without sacrificing performance or iteration speed.

Create branching destinies. Deliver multiple endings.

Build AAA narratives powered by your creativity.

Require new input system package 

Require AI Navigation package

Require Post Processing for Built-In

• Mobile support
• Fully controlled save & load flow
• Explicit write / read order (no hidden serialization)
• Key-based data registration system
• Supports multiple independent data blocks
• Safe loading (no crashes if save file is corrupt or missing)
• Built-in versioning support
• Designed for large-scale and long-term projects

Wizard School AAA Save Pro contains Wizard School AAA Save and Wizard School Fighting Engine plus mobile support. If you don't need mobile support, you can get it here for a lower price:

WIZARD SCHOOL AAA SAVE

Want a RPG Dialog and Choices System? Get RPG Choices and Dialog:

WIZARD SCHOOL RPG CHOICES AND DIALOG SYSTEM

If you want publish your game for Android and iOS, get the pro version with mobile support:

WIZARD SCHOOL FIGHTING ENGINE PRO

Also want fly with Broomstick? Get Broomstick Engine:

WIZARD SCHOOL BROOMSTICK ENGINE

In every great AAA game, choices matter, worlds persist, and progress is never lost. AAA Save was built with that exact philosophy in mind.

Whether your game is an RPG driven by decisions, an open world shaped by player actions, or a narrative experience where every detail counts, AAA Save gives you the confidence that nothing important is ever forgotten.

No black boxes.

No hidden magic.

Just a clean, modular, developer-controlled system that scales as your game grows.

From a single player stat to entire worlds, quests, and choices AAA Save keeps everything exactly where it belongs, across sessions, platforms, and versions.

Built to feel professional

Built to feel solid

Built for games that aim higher

Require new input system package

Require AI Navigation package

Require Post Processing for Built-In

Multiplayer Engine – Pro Edition is built on a modular architecture that bridges the gap between low-level networking and high-level game logic. It automates the "boring" parts of backend integration so you can focus on gameplay.

🔌 Networking & Architecture

• Hybrid Support: Seamlessly switch between Peer-to-Peer (P2P) for cost-effective co-op and Dedicated Game Servers (DGS) for authoritative competitive play.
• Netcode Foundation: Built on industry-standard frameworks with custom wrappers for Steamworks, UGS, and PlayFab.
• Network Smoothing: Interpolation for fluid proxy movement.Latency Mitigation: Advanced Character Controller features:
  Client-Side Prediction: Instant input feedback for players.
  Server Reconciliation: Corrects position desyncs without jitter.
  Lag Compensation: Rewind-based hit detection for fair combat.
  

☁️ Integrated Services & SDKs

The engine includes a Setup Wizard that handles the API handshakes and SDK installations for:

• Matchmaking: Ticket-based queuing and lobby management.
• Orchestration: Integrated deployment flows for Edgegap, AWS GameLift, and PlayFab Multiplay.
• Transport Layers: Optimized for high-frequency data transmission and reliability.

📦 Package Content

• One-Click Setup Wizard: Automates Project Settings, Scripting Define Symbols, and dependency fetching.
• Scalable MMORPG type matchmaking.
  5v5 Draft/Pick Lobby.
  
• Flexible Team-ID management.Gameplay Systems:
  Extensible Health/Damage interface.
  Network-synced Melee and Projectile systems.
  

💻 Requirements & Compatibility

• Unity Version: 2021.3 LTS or higher (Recommended).
• Render Pipelines: Built-in, URP, and HDRP compatible.
• Scripting: C# (Full Source Code included).
• Target Platforms: PC (Windows/Mac/Linux), Consoles, and Mobile (depending on backend provider).

📖 Documentation & Support

Your purchase includes comprehensive technical documentation designed for both beginners and senior engineers.

• Quick Start: Go from empty project to networked player in under 5 minutes.
• API Reference: Detailed breakdowns of core networking classes.
• Dev Support: Join our Discord for direct technical assistance and bug reporting.

Built for : Unity Gaming Services | Steam | PlayFab | Edgegap

Peer-to-Peer Networking and Dedicated Server Support

Multiplayer Engine – Pro Edition is a fully integrated system that supports both Peer-to-Peer (P2P) and Dedicated Server architectures — giving you the flexibility to build anything from small co-op games to competitive 5v5, battle-royale or MMORPG experiences.

🌐Supported Platforms:

• Steam
• Unity Gaming Services
• PlayFab

📦 Dedicated server providers supported:

• Edgegap
• Amazon GameLift
• PlayFab

⚙️ One-Click Setup System

No more complex manual configurations.

Our built-in Setup Wizard allows you to:

• Select networking architecture (P2P or Dedicated)
• Choose backend & service provider
• Automatically install required SDKs
• Configure services & dependencies
• Apply necessary project settings

With a single click, the system sets up everything for you.

This is a true plug-and-play solution designed to save weeks of development time.

🎮 Matchmaking & Game Modes

The engine includes fully functional examples of:

• Matchmaking system
• Persistent server support
• 5v5 custom match system
• Draft-pick lobby example
• Team-based lobby system (flexible team sizes)
• Multi-team match configurations

You can easily configure different team structures and match styles to fit your game design.

🧠 Advanced Character Controller

Includes a professional multiplayer-ready character controller with:

• Client-side prediction
• Server reconciliation
• Lag compensation
• Network smoothing

Also included:

• Basic P2P character controller
• Shooting system
• Melee attack system
• Health & damage system

📘 Documentation & Learning Resources

After installation, you’ll get access to:

• Complete setup documentation
• Step-by-step dashboard configuration guides
• Dedicated server deployment guide
• Full video tutorials on YouTube (Comming Soon!)
• Continuous updates & improvements

📜 Third-Party Usage

• Feather Icons by Google (MIT License)
• Unity Assets for demo use

Depending on your chosen backend integration, the following dependencies will be initalled:

• Edgegap SDK (if using Edgegap Servers)
• Steamworks.net (if using steam as backed)
• PlayFab.SDK, PlayFab-Party.SDK, and Playfab-Multiplayer.SDK (if using playfab as backed)

See the included Third-Party Notices.txt for details.

💬 Community & Support

Need help with setup, bugs, or updates?

Feel free to contact us anytime:

📧 ignitivelabsmail@gmail.com

🌐 Discord - https://discord.gg/59cFVYavpd

We’re happy to assist you!

We provide:

• Active support via Discord
• Direct assistance when needed
• Official website with extended documentation and updates

You’re never left alone during development.

If you're building a competitive multiplayer game or planning scalable online experiences, Multiplayer Engine – Pro Edition gives you everything you need — in one package.

Play DEMO there is much more to see

AI ASSISTENT AND DOCUMENTATION

🌪️ WHAT CAN TIME PARADOX ENGINE SLOW DOWN AND REWIND?

Physics & Movement

1. Player & Enemy Rigidbodies (3D & 2D): Full velocity and angular momentum tracking.
2. NavMeshAgent AI: Perfect slow-motion pathfinding with anti-slip momentum braking.
3. Custom Projectiles: Arrows, bullets, and rockets (Kinematic or Physics-based).
4. Kinetic Accumulators: Absorb hits during a Time Stop and release the kinetic energy all at once.
5. Hinge Joints: Automatically suspended during rewinds to prevent physics glitches.

Visuals, VFX & Audio

6. Shuriken Particle Systems: RAM Cache, Procedural Resimulation, or Reverse Playback modes.

7. VFX Graph: Native scrubbing backward with Time Slicing & Distance Culling.

8. Shader Properties: Slow down scrolling textures, water ripples, or glowing emissions via MaterialPropertyBlocks.

9. Cinemachine Cameras: Anti-damping teleportation ensures your camera doesn't drift through walls during a rewind.

10. Audio Sources: Dynamic pitch scaling and automatic Low-Pass Filters during anomalies.

11. URP/HDRP Volumes: Smooth post-processing transitions for Time Stop and Slow-Motion.

Logic, UI & Custom Code (Via The Math Bridge)

12. Ammo & Heat levels

13. Wind Zones:

14. Cooldown timers and Quest clocks:

15. Environmental Puzzles: Un-press pressure plates, un-open heavy doors, and reverse moving platforms.

20. Animator State Machines: Seamlessly scrub walk/attack animations backward, including bone-perfect historical snapshots.

🔥 NEW IN THIS VERSION:

• Time Echoes (Paradoxes): Rewind time and spawn a physical "Ghost" clone that replays your recorded history! Complete with synchronized Animator states, procedural bone mapping, and separate event triggers for ghosts
• Kinetic Accumulator (Stasis Impact): Hit a frozen object multiple times to build up potential energy, set the delay between,
• Expression Tree Math Bridge: Eliminated slow C# Reflection.Bind your custom variables (HP, Stamina, Light Intensity) via the Inspector, and the system compiles lambda delegates in real-time for zero-overhead manipulation.
• Decoupled Animation Framerate: Record heavy procedural bone histories at 15 FPS, while the engine mathematically up-samples and interpolates them back to 50 FPS during rewind for perfectly smooth playback.

⚡ AAA PERFORMANCE (ZERO GC & MULTITHREADING)

Built with high-performance C# and NativeArrays. Time Paradox Engine processes thousands of objects simultaneously using IJobParallelForTransform and the Burst Compiler. Circular buffers use O(1) bitwise operations. It allocates zero memory during standard gameplay loops. Fully optimized for Desktop, Consoles, Mobile, and VR.

🛑 ADVANCED LOCAL ANOMALIES (ZONES)

• Local Rewinds: Objects inside a zone are forced to walk backward in time, while the rest of the world plays normally forward.
• Kinetic Zones (Superhot Style): Time only moves when the player moves.
• Non-Alloc Object Pooling: Zones handle hundreds of overlapping projectiles without frame drops using pooled targets and Unity's non-alloc physics APIs.

⚠️ WHAT DOES IT TAKE TO REWIND A CUSTOM CONTROLLER? (HONESTY FIRST)

No asset can magically rewind an unoptimized, hardcoded spaghetti script. However, Time Paradox Engine is designed to seamlessly integrate with 99% of custom controllers if you follow our simple interfaces:

1. The Kill-Switch: Your script must survive being temporarily disabled during a rewind. Our Component Manager handles this automatically.
2. The Adapter Interface: Implement the tiny ITimeWarpCharacterAdapter interface to replace Time.deltaTime with our scaled local time, ensuring perfect slow-motion.
3. The State Listener: Implement ITimeWarpStateListener to get notified the exact frame a rewind ends, allowing your AI to instantly acquire new targets.

💬 24/7 DEDICATED AI ASSISTANT.

Chat with the Time Paradox Support AI Here: it was trained to help you set up everything in editor

❓ FAQ

Does it work with my custom Player Controller?

Yes! Swap your Time.deltaTime for GetLocalDeltaTime() via our simple interface, and your controller instantly becomes "Time-Aware" for slow-motion. or use custom channel and Bridge to get the values from the script working with Time Paradox

Can I create "Ghosts" that replay my actions?

Absolutely. The Time Paradox Module extracts positional history, Animator states, and custom events (like "Shoot" or "Jump") to spawn a physical clone that perfectly replays past actions and can even push physical objects out of its way.

Can I rewind the whole scene?

You can, but we give you the tools to do it smartly. By using Auto-Setup Layer Rules, you ensure the engine only records objects that actually matter, preventing massive RAM bloat compared to brute-force global rewinds.

Does it handle death and destroyed objects?

Yes. The lifecycle module safely hides "dead" objects instead of destroying them, allowing them to perfectly resurrect if time is rewound before their death frame.

Kyle Robot Character not included

Version on Unity 6

Let’s create something timeless ❤️

Technical Information

Audio Format: WAV

Sample Rate: 48kHz / 24bit

Style: Solo Piano, Cinematic, Impressionism

Looping: Easily editable

Royalty-Free: Yes (commercial & non-commercial use) - NO COPYSTRIKES!

Number of original music pieces: 6

Number of alternative versions and loop tracks: 7

Number of all Audio Wavs: 23

Minutes of audio from original music pieces: 19 min (19:04')

Minutes of all audio provided: 37 min (0:37:15')

Winter Piano is an emotional piano music asset pack designed for indie games, animations, and films. Inspired by French Impressionism, it delivers warm, melancholic, and cinematic moods perfect for winter-themed and story-driven projects.

The tracks are clear, minimal, and easy to use — ideal for menus, cutscenes, exploration scenes, and background music that supports gameplay without distraction.

Content:

6 original solo piano compositions

Handcrafted, expressive performances

Cinematic and impressionistic mood

Suitable for linear scenes and ambient storytelling

Track Use Suggestions:

First Snowflakes – opening scenes, exploration, calm environments

Iceskaters – lively winter towns, social hubs, light gameplay

The Longest Night – emotional cutscenes, slow narrative moments

Ice Ballerina – dramatic sequences, character focus

Last Swan – solitude, loss, atmospheric transitions

Lazy Morning – safe zones, endings, warm narrative moments

Development Render Pipeline: Built-In (Unity 2022) & URP (Unity 6)

Rigged: Yes

Humanoid Rig: Yes

Number of Characters: 1

Number of Weapons: 1

Number of Animations: 60

Number of Prefabs:

• Unity 2022:
• Mobile Prefabs: 3
• PC Prefabs: 3
• Unity 6:
• URP Prefabs: 3

Triangle Count:

Body: 25,876

Sword: 3,794

Number of Textures: 13

Texture Resolutions: 2048x2048, 4096x4096

Number of Materials:

• Unity 2022:
• Mobile Shaders: 6
• PC Shaders: 6
• Unity 6:
• URP Shaders: 6

Join the N-hance Studio community

Discord | YouTube | Facebook

_____________________________________________________________________________

Attention:

If you plan to use our assets, including this one, in any NFT or blockchain projects, please reach out to us via email first!

_____________________________________________________________________________

Asset Description:

This package is designed for stylized / fantasy games. This asset is well detailed and can be used for First and Third Person camera.

Various color Materials, animations & Weapon Component for wide customization included!

Features:

• PBR Setup
• 3 Hand-painted skin colors (see screenshots for details)
• Weapon Asset
• 60 animations
• Humanoid Rig

• PBR Stylized Material:
• 6 Hand-painted Diffuse Maps
• 2 Normal Maps
• 1 Emissive Map
• 2 Metallic & Smoothness Maps
• 2 Ambient Occlusion Maps

• Style Variations:
• Green Cursed Knight
• Purple Cursed Knight
• Red Cursed Knight

Check out our Packs & Bundles:

• Bundles:
• Elementals Bundle
• Nature Bundle
• Sea Animals Bundle
• Creatures Bundle #1
• Creatures Bundle #2
• Enemy NPC Bundle #1
• Enemy NPC Bundle #2
• 250 Materials Bundle
• Spell Icons Ultimate Bundle
• Packs:
• Forest Creatures Pack
• Kobolds Pack
• Centaurs Pack
• Cave Crystal Creatures Pack
• Ogres & Trolls Pack
• Banshee Pack
• Lich Pack
• Dinosaurs Pack
• Dragons Pack
• Monsters Pack
• Fantasy NPC Pack

• Attribute-based dependency injection system ([Inject], [Install], etc.)
• Direct injection for scene-based objects
• Indirect injection with custom key support for runtime systems
• Collider and Collider2D injection for gameplay interactions (trigger, collision, overlap)
• Manual binding and resolving (Bind, Resolve, TryResolve, ResolveAll)
• Support for singleton and transient lifetimes via factory bindings
• Static dependency injection support
• Lightweight container-style architecture (no heavy setup required)
• Runtime configuration system for execution control and safety
• Coroutine-based initialization (WebGL-friendly, no async dependency issues)
• Debug and validation tools (TryResolve, IsBound, verbose logs)
• Dependency unbinding system (including UnbindAfterInjection behavior)
• Runtime refresh and reset system (Haystack.Refresh, Haystack.Reset)
• Support for inactive object injection and delayed execution
• Cross-platform compatibility (Desktop, Mobile, WebGL)
• Editor tools and configuration assets included
• Demo scenes and sample scripts included
• Backward compatibility with legacy attribute aliases

Haystack is a lightweight and flexible dependency injection framework designed for Unity developers who want cleaner architecture, better scalability, and faster development workflows. It provides a simple yet powerful way to manage dependencies across gameplay systems without heavy setup or complex configurations.

The framework supports multiple injection approaches including direct injection for scene-based objects, indirect injection for runtime and dynamic systems, and collider-based injection for interaction-driven mechanics such as triggers, pickups, and combat systems. This makes it highly adaptable for different types of projects, from small prototypes to large-scale games.

Haystack is built with performance and platform compatibility in mind, ensuring stable behavior across desktop, mobile, and WebGL builds. It avoids common issues related to async workflows by supporting coroutine-based initialization, making it especially suitable for WebGL environments.

Developers can use attributes to define dependencies clearly, reducing tight coupling and improving code readability and maintainability. The framework also includes manual binding and resolving options, allowing a lightweight container-style workflow for advanced use cases.

Key features include:

• Attribute-based dependency injection for clean and organized code
• Direct and indirect injection systems for flexible workflows
• Collider and Collider2D injection for gameplay interactions
• Manual binding and resolving for lightweight container control
• Runtime configuration settings for performance and behavior tuning
• Debug-friendly tools such as TryResolve, unbinding, and validation helpers
• Support for both singleton and transient dependency lifetimes

Haystack is suitable for any game genre, including multiplayer, simulation, RPG, FPS, and mobile games. It is designed to scale with your project while remaining easy to use for both beginners and experienced developers.

The package includes runtime systems, editor tools, configuration assets, and demo examples to help you get started quickly.

Each model has:

Tris: 90-2000

Verts: 190-3000

Size: 12kb - 52kb

_______________________

Texture: 2 (512x512)

Works on versions with URP and HDRP

_______________________

Amount: 5

This is a demo version of the full package: Mega Low Poly Weapon Pack

• Total Triangles: 12,956
• Rigging: Bow is rigged; others are static.
• Optimization: All-in-One Material.
• Textures: 2 Texture Maps total.

Add a dash of love to your combat! The Valentine Weapon Pack focuses on elegance and charm, featuring flowing lines and a gentle color palette. Designed for "Magical Girl" themes or seasonal rewards, these 6 high-quality weapons provide a polished look while remaining exceptionally performance-friendly for any stylized game.

• Total Triangles: 7,673
• Rigging: Bow is rigged; others are static.
• Optimization: All-in-One Material.
• Textures: 2 Texture Maps total.

Celebrate the spooky season with a touch of warmth! The Cozy Halloween Weapon Pack replaces terror with playfulness, featuring rounded shapes and vibrant colors. Optimized for mobile and indie projects, these 6 weapons (Hammer, Axe, Lance, Sword, Shield, Bow) are ready to bring a festive "spooky-cute" vibe to your world.

• Modular energy system framework built for gameplay, not real-world simulation
• Request-based energy flow (consumers request, sources respond)
• Generators (fuel-based and renewable sources)
• Battery storage with configurable capacity and input/output limits
• Switches for manual and logical power control
• Support for continuous and action-based power consumers
• Visual wiring system for building power networks
• Plug-and-play components with clean, simple interfaces
• ScriptableObject-driven configuration for generators, batteries, and consumers
• Clean, readable C# architecture designed to scale with gameplay
• Multiple focused demo scenes covering common use cases
• Full source code included

📚 Documentation & Support

• Documentation: https://doc.nogue.dev/docs/assets/ues
• Community & Support: Discord (https://discord.gg/kbwnyGhYMP)

Ultimate Energy System (UES) is a modular, gameplay-ready energy framework for Unity, built for survival, base-building, crafting, automation, and simulation games.

It allows you to design clear, predictable power networks using generators, batteries, switches, wiring, and custom consumers — without dealing with complex real-world electrical simulation.

UES is built around a request-based energy flow:

• Consumers request power
• Sources respond
• Energy flows through the network in a controlled and transparent way

This model makes power behavior easy to reason about, easy to debug, and safe to scale inside real gameplay scenarios.

🔌 Core Features

• Modular EnergyNode architecture
• Generators (fuel-based and renewable)
• Batteries with configurable input/output limits
• Switches to manually control power flow
• Continuous and action-based power consumers
• Visual wiring system
• Clean, readable C# code
• ScriptableObject-driven configuration
• No hidden automation — full developer control

🧪 Included Demo Scenes

The package includes focused demo scenes, each demonstrating a specific use case:

• Generator → Light (continuous consumption)
• Generator → Battery → Light
• Generator → Battery → Switch → Light
• Solar → Door (action-based consumption)
• Solar → Battery → Door

All demo scenes work out of the box and are designed to be copied directly into your project.

🎮 Ideal For

• Survival games
• Base-building & crafting systems
• Sandbox & automation projects
• Factory / industry gameplay
• City builders and simulation games

⚠️ Design Philosophy

UES is not a real-world electrical simulator.

It intentionally avoids:

• Smart grids
• Automatic load balancing
• Implicit priorities
• Hidden energy redistribution

This keeps the system transparent, predictable, and gameplay-friendly.

🚧 Roadmap

🔹 Version 1.1 (Free Update)

Planned improvements based on real-world usage and community feedback:

• Power priority support (critical vs non-critical consumers)
• Improved battery behavior with multiple consumers
• Additional demo scenes covering edge cases
• Extended debugging and diagnostics helpers
• Minor performance and stability improvements

Simulation Pipeline

• Execution order: NavigationSystem → QueuingSystem → AwarenessSystem → ObstacleAvoidanceSystem → SurfaceSystem → MovementSystem

Spatial Hashing

• Simulation cell size: 5 m, spawn cell size: 2 m
• O(1) neighbor queries per agent
• Secondary snapshot map provides O(1) position, velocity, and state reads across systems without structural queries

LOD

• Three tiers: High 0–50 m, Medium 50–120 m, Low 120 m+
• Implemented via enableable components — no structural entity changes during transitions
• Full simulation at High, obstacle avoidance skipped on alternate frames at Medium, navigation and movement only at Low
• Distances configurable via the authoring inspector

Obstacle Avoidance

• Forward sphere cast confirms a real obstacle before avoidance engages
• Nine scan rays fanned ±82.5° around the lane forward axis
• Per-ray boundary corridor depth computed before casting — prevents false rejections at lane seams and narrow corners
• Rays scored on goal alignment, absolute clearance, and temporal stability
• Committed direction persists across frames to prevent oscillation

Queuing & Traffic Signals

• Forward scan distance: 4 m
• Forward cone threshold: cos(53°) ≈ 0.6
• Minimum 3 blocking agents required before a congestion stop triggers
• Yields immediately when an avoidance commitment is active

Agent Separation

• ORCA-style separation forces via spatial hash neighbor lookups
• Head-on encounters resolve to opposite sides using XOR of entity indices — no shared state or write contention

Surface Conforming

• Two raycasts per agent per frame: center probe for Y-authority, forward probe for surface look-ahead
• Three consecutive misses required before fall state engages — absorbs transient gaps at step edges and physics seams

Spawner

• Boundary compatibility pre-computed once per spawner at startup — O(1) per spawn attempt
• Up to 20 placement candidates attempted per agent
• Collider avoidance on spawn configurable via layer mask

Editor Menu (Tools → Traffic Engine → Crowd)

• Create Spawner in Scene — places TrafficCrowdSpawnerAuthoring directly inside your DOTS Sub-scene, ready to bake
• Validate Scene Setup — runs all pre-play checks and surfaces missing or misconfigured dependencies
• Debug Mode → Enable / Disable — adds or removes the TRAFFIC_ENGINE_DEBUG scripting define and recompiles automatically
• Create Visual Debug Config — creates the debug config ScriptableObject under Assets/Resources/
• Open Documentation — opens online documentation in the default browser

Debug Visualization

• Enabled via TRAFFIC_ENGINE_DEBUG scripting define — zero cost in release builds, all debug code stripped
• Eight independently toggleable categories: Core, Entity ID, Navigation, Avoidance, Queuing, Awareness, Movement, Surface
• Core draws a LOD-tier ground disc per agent
• Entity ID shows a screen-space label with entity index, speed, and current state
• Navigation draws the desired velocity arrow
• Avoidance draws the forward detect cast, all 9 cone rays, committed direction arrow, and obstacle contact point
• Queuing shows a state tick above the agent head
• Awareness draws the ORCA influence radius ring and separation force arrow
• Movement overlays DesiredVelocity and smoothed Velocity as two separate arrows
• Surface draws every probe raycast line colored by outcome
• Strict one-hue-per-semantic-role color contract: Blue = navigation intent, Green = valid state, Red = blocked or failed, Yellow = committed avoidance or congestion hold, Orange = separation force, White = boundary too narrow, Magenta = full probe range, Cyan = forward step hit, Gray = ORCA influence radius
• LOD filter and configurable max draw distance (150 m default) keep overhead manageable in large scenes

Requirements (most packages are automatically included)

• Unity 6.0 or newer
• com.unity.entities
• com.unity.entities.graphics
• com.unity.burst
• com.unity.collections
• com.unity.mathematics
• com.unity.physics
• Lane Graph

Package Contents

• 30+ C# source files
• 2 sample scenes - Basic and Advanced setup.
• One sample prefab showcasing Animecs based pedestrian character setup.
• Doxygen-style documentation throughout

Ideal For

• Urban simulations and city builders
• Open-world games with high pedestrian counts
• Architectural visualisations
• Any project requiring large crowds without sacrificing frame budget

Up and running in under a minute.

Create your pedestrian prefab, add TrafficCrowdAgentAuthoring. Drop a TrafficCrowdSpawnerAuthoring in your scene, point it at the prefab, set your count — done. Thousands of fully simulated DOTS entities, live in your scene with zero boilerplate.

📖 Documentation | 💬 Discord | 📧 Email Support

TrafficEngine Crowd is a DOTS-native pedestrian simulation plugin for Unity. Every system runs as a Burst-compiled parallel job — no MonoBehaviour overhead, no polling loops. The simulation is built to hold frame budgets at crowd sizes where traditional approaches break down.

Agents navigate a lane graph using spline-based look-ahead, respond to traffic signals, queue behind congestion, avoid static obstacles, separate from each other, and conform to terrain surfaces including stairs and ramps. Each behaviour is isolated to its own system with a clear ownership contract — navigation writes intent, downstream systems modify it, movement commits the final result.

Navigation - Agents follow lane splines with a 2 m look-ahead for smooth directional sampling. Lane transitions, boundary containment, and dead-end reversals are all handled within the navigation pass.

Queuing & Traffic Signals - Each agent scans forward for red signals and congestion. A stop is only triggered by genuine blockage — preventing false stops from isolated stationary pedestrians. Queuing yields immediately if an avoidance commitment is active.

Agent Separation - ORCA-style separation forces are applied between neighbouring agents using spatial hash lookups. Head-on encounters automatically resolve to opposite sides with no shared state or write contention.

Obstacle Avoidance - A forward cast confirms a real obstacle before avoidance engages. Nine candidate rays fan around the lane forward axis, each measuring its navigable corridor depth against the lane boundary polygon before casting, then scoring on alignment, clearance, and temporal stability. The committed direction persists across frames to prevent oscillation.

Surface Conforming - Two raycasts per agent per frame keep agents grounded on terrain, ramps, and stairs. A grace period absorbs transient misses at step edges and physics seams before fall state engages.

LOD System - Three distance tiers implemented via enableable components. Full simulation at close range, progressively reduced at distance. No structural entity changes occur during transitions — just component enable/disable.

Spawner - Agents spawn inside valid lane boundaries with boundary compatibility pre-computed once at startup. Collider avoidance on spawn is configurable via layer mask to prevent agents spawning inside geometry(eg. obstacles).

Asset Count 

• 28 Unique Assets 

• Modular kitchen system included (Cabinets, Counters, and Appliances) 

• Fully configured Prefabs included 

• Demo Scene included to showcase kitchen layout 

Included Assets 

Cabinets & Counters 

• Base Cabinet (Standard) 

• Base Cabinet (Corner - L-shaped) 

• Upper Cabinet (Wall-mounted) 

• Upper Cabinet (Corner) 

• Countertop (Straight Section) 

• Countertop (L-shaped Corner) 

• Kitchen Island 

Major Appliances 

• Refrigerator (Two-Door) 

• Stove / Range (4-burner with Oven) 

• Sink (Under-mount with Faucet) 

• Dishwasher (Built-in) 

• Microwave (Over-range) 

Furniture 

• Kitchen Table (Rectangular) 

• Kitchen Chair (x4 – same design) 

• Bar Stool (x2 – same design) 

Small Props 

• Cooking Pot with Lid 

• Frying Pan 

• Utensil Holder with Utensils 

• Cutting Board with Knife 

• Electric Kettle 

• Toaster 

• Coffee Maker 

• Fruit Bowl with Fruit 

Polygon / Vertex Count 

• All assets are optimized for performance and real-time rendering. 

Small Props: 

• 150 – 350 triangles 

Medium Assets: 

• 300 – 600 triangles 

Large Assets: 

• 600 – 1000 triangles 

Total Pack Estimate: 

• ~12,000 – 18,000 triangles 

Optimized Geometry: 

• Clean topology suitable for modular placement 

• Game-ready meshes optimized for Mobile, PC, and Console projects 

Scale 

• Real-world scale used throughout the pack 

• 1 Unit = 1 Meter 

Standard Dimensions: 

• Counter Height: 0.9m 

• Table Height: 0.75m 

• Upper Cabinets Placement: ~1.4m above floor 

Textures 

• Stylized low-poly textures 

• Format: PNG 

• Clean color-based materials 

Texture Style: 

• Wood (light, medium, dark) 

• Metal (chrome, stainless steel) 

• Simple PBR-inspired look 

Materials 

• Materials are pre-configured and ready to use 

• Optimized for performance and consistency 

Material Types: 

• Wood Materials (Cabinets, Furniture) 

• Metal Materials (Appliances, Handles) 

• Plastic Materials (Small appliances) 

• Glass Materials (Oven, Microwave, Coffee Maker) 

• All materials are properly assigned to prefabs 

Prefabs 

• All models are available as ready-to-use prefabs inside: 

• Assets/Prefabs/ 

Each prefab features: 

• Correct real-world scale 

• Proper pivot placement 

• Clean hierarchy 

• Pre-assigned materials 

Pivot Points 

• Base Cabinets: Bottom center 

• Upper Cabinets: Back center (for wall mounting) 

• Appliances: Bottom center 

• Countertops: Bottom back edge 

• Small Props: Bottom center 

Performance 

• Lightweight and optimized for real-time performance 

• Mobile-friendly asset design 

• Suitable for simulation, interior design, and stylized games 

• Efficient draw calls using optimized geometry 

Scene Included 

• Kitchen demo scene included 

• Demonstrates modular placement of cabinets and appliances 

• Shows realistic kitchen layout composition

This Low Poly Kitchen 3D Pack provides a complete stylized kitchen environment suitable for mobile, PC, and WebGL projects. The pack includes modular kitchen furniture, props, and a ready-to-use demo scene that helps you quickly set up a modern kitchen interior.

All assets are optimized for performance and designed with a clean low poly art style, making them ideal for simulation games, tycoon games, interior design apps, educational projects, and prototypes.

The modular structure allows you to easily customize layouts and create multiple variations of kitchen environments. Materials and textures are organized for quick editing, enabling fast color or style adjustments according to your project needs.

Key Features

• Complete kitchen environment

• Modular kitchen layout

• Optimized low poly models

• Includes demo scene

• Game-ready assets

• Clean topology

• Easy to customize materials

• Suitable for mobile, PC, and WebGL

• Organized folder structure

Assets Included

• Kitchen cabinets (upper & lower)

• Kitchen island counter

• Refrigerator

• Sink and faucet

• Stove and kitchen appliances

• Table and chairs

• Decorative props

• Materials and textures

• Prefabs

• Demo scene setup