Asset Store newest packages

Sperm Whale Low Poly 3D Model Animated

14 Animations In-place and Root Motion

3 Textures (4096x4096)

2 Material

1 Sample Scene

1 Prefab

2 Scripts

1 Skybox

1 Shader

Low Poly Model

7626 Polygons

7690 Vertices

Polygonal Quads Only Geometry

Textures

T_SpermWhale_D (Diffuse)

T_SpermWhale_N (Normal)

T_SpermWhale_S (Specular)

Animations list

Ascend (418-478)

BiteAttack (481-547)

Breathe (1066-1401)

Death (550-815)

Dive (355-415)

Hit (1404-1460)

Idle (63-183)

QuickTurnLeft (818-848)

QuickTurnRight (851-881)

Swim (0-60)

SwimFast (312-352)

SwimLeft (186-246)

SwimRight (249-309)

TailSlap (884-1063)

🐋 Sperm Whale – Animated Low Poly Marine Mammal

Bring the ocean depths to life with this fully animated Sperm Whale for Unity. Featuring a clean low-poly design and smooth animations, this asset is perfect for underwater environments, marine simulations, wildlife games, and cinematic ocean scenes.

🎮 Key Features

• 14 In-Place & Root Motion animations including swimming, diving, attacks, reactions, and directional movement
• 3 high-quality 4K textures (Diffuse / Normal / Specular)
• 2 materials fully set up
• Low-poly optimized model (7,626 polygons / 7,690 vertices, quads only)
• Includes Sample Scene, Prefab, Shader, Animator Controller, and 2 Scripts for easy integration

🧾 Technical Details

• Polygons: 7,626
• Vertices: 7,690
• Geometry: Polygonal quads only
• Textures:

• T_SpermWhale_D (Diffuse)
• T_SpermWhale_N (Normal)
• T_SpermWhale_S (Specular)
  

Animations List:

Ascend, BiteAttack, Breathe, Death, Dive, Hit, Idle, QuickTurnLeft, QuickTurnRight, Swim, SwimFast, SwimLeft, SwimRight, TailSlap

🧩 Ideal For

• Ocean environments and underwater simulations 🌊
• Marine wildlife and aquatic games
• VR / AR ocean experiences
• Educational applications and documentaries 📚
• Cinematic sequences featuring marine creatures

• Developed using Unity 6000.0.42f1 (LTS).
• Tested on Android devices (API 24+) and Windows 10 PCs.
• Minimal performance impact thanks to optimized detection & reusage system.
• The asset relies only on standard Unity components, with no third-party library dependencies. For text tooltips, Text Mesh Pro is required, also Unity UI for all the UI Pointers.
• No AI.

📄 Full Documentation (eng)

🖼️ See Full List Of Effects

Dynamic Hover Tooltips 🎯 is a system for creating tooltips in Unity projects. It manages pointers indicating targets for smooth player guidance. The system handles the technical side - detection, triggers, positioning, animations - so developer can focus on designing the actual visuals: interaction icons over objects, custom shaders, outlines, directional arrows, text popups, and any other effects the game needs.

Content:

• Multiple triggers (hover, also click, distance, collision, screen center)
• Check by ComponentValue - can trigger tooltips on triggering objects only with specific custom script values or other attributes (check by tag, layer, type, component presence, name, etc.)
• Smart visuals: UI pointers (canvas-based) and World pointers (world space), both can target UI and 3D objects
• Animation settings via ScriptableObjects + fully editable graphic content in prefabs
• Auto-generated frames and UI cutout masks with raycast blocking
• For text pointers: CSV-based localization supported, built-in keyboard key collection for TMP sprite assets usage
• Progress persistence (once/per session/reusable), saving state in JSON
• Cross-platform support (Desktop + Mobile)
• Old + New Input System support
• Customization methods

Examples of what you can create:

• A key prompt pops up when approaching an object (for example, open a chest, book, enter a location)
• An interaction icon appears when the center of the screen hovers over an object (for example, examine a clue)
• Clicking on an object displays its text description (for example, for a playing card or skill)
• Hovering over an object triggers highlighting in different colors depending on the target's state (for example, a white ground hint for a hex available for placement, and red for unavailable).
• An arrow positioned in front of the camera, leading the player to an object (for example, a mission start zone)
• A mask that requires clicking/hovering on a target, blocking other input, etc.

You can add your own logic to tooltip activation/deactivation, for example, enabling key input listening or triggering additional effects (custom shaders, outlines, sounds, etc.) The system is built on Unity's base components to avoid conflicts with designs used in projects.

Architecture:

1. Centralized tooltip collection per scene
2. External triggers on specific objects & prefabs
3. Manual calls via SceneReferences

The central collection stores the playback logic and the visuals to activate. Each visual is a prefab with graphical content and a settings ScriptableObject - fully customizable. See how it works with different object types and visuals in the DemoScene.

To get started:

• Add the TooltipSystem.prefab to your scene
• Scene References → Assign Target Canvas in it or it will be auto-detected. Assign Main Camera in it or it will be auto-detected
• Check if the Input Controller component inside prefab matches your Input System (Old/New)
• All set! Add tooltips to the TooltipCollection list, configuring their launch and display.

🎁 Upgrade to Automatic Tutorial Maker ($5 instead of $40) →

• Full DHT included + add-ons
• Input action recording > automatic tooltip generation
• Extended start & completion conditions (expected keyboard input, mobile gestures, double click, hold, drag & drop, etc).

Deriva is a humanist sans serif with 10 styles, built around rhythm, openness and subtle movement. It combines functional clarity with a warm structural presence, making it adaptable across editorial, branding and interface design.

• Polygon Count: 400 – 2,500 polygons per model
• Number of Models: 7
• File Formats: FBX
• Textures: Included
• Materials: Included
• UV Mapping: Yes
• Game Ready: Yes
• Compatible with: Unity 2020 and newer versions

🔥 Features

• Stylized low poly design
• Game-ready assets
• Lightweight and optimized
• Suitable for FPS / TPS games
• Easy to customize materials

📦 Included Assets

• Pistols
• Rifles
• Shotguns
• Stylized weapon variations

💡 Use Cases

• Shooter games (FPS / TPS)
• Survival games
• Zombie games
• Mobile and indie projects

• Full inspector property reference table — every field with type, default, and description
• Complete public API reference — Push(), ApplyPreset(), TransitionTo(), AnimateSunTo(), SkyPalette.Lerp()
• SkyPalette struct with a working code example
• Editor window implementation notes — the domain-reload fix, texture leak fix, EditorPrefs persistence

A procedural sky shader for Unity's Built-in Render Pipeline. It generates a fully animated sky at runtime — no sky textures, no cubemaps, and no baking required.

Simply drag the material onto a background quad or assign it as a Skybox to instantly add a dynamic sky to your scene, featuring drifting clouds, a glowing sun, atmospheric haze, and a twinkling star field.

All visuals are controlled by six colors. Adjust these colors to instantly transform the entire sky — including gradients, clouds, wisps, stars, and atmosphere.

Includes 8 ready-to-use color presets, along with a custom editor tool that allows you to create and save your own palettes in seconds.

Includes:
- 1 cloud texture
- Resolution: 2048x2048
- Format: PNG
- Color depth: 8-bit
- Transparency: Yes

📦 18 Built-in Database Modules

• Items - Weapons, armor, consumables, materials with rarity and tags
• Abilities - Skills, spells, buffs, debuffs with cooldowns and costs
• Characters - Player templates with stats and starting gear
• Classes & Races - RPG character archetypes
• Quests - Main story, side quests, dailies with objectives
• NPCs - Non-player characters with dialogue and vendor items
• Crafting - Recipes with ingredients and outputs
• Currencies - Multiple currency types
• Professions - Blacksmithing, alchemy, etc.
• Spellbooks - Spell collections and grimoires
• Triggers - Event-based gameplay triggers
• Rules - Game configuration and settings
• Scenes - Scene metadata management
• Screen Text - Localization-ready text keys
• Playables - Playable character data
• Item Bar - UI bar configurations
• Progression - XP and leveling systems
• Game Settings - Global game configuration

🎨 Modern Visual Editor

• Clean, styled UI with professional appearance
• Smart dropdown selections (no manual ID typing!)
• Search and filter functionality
• Batch operations support
• Cross-reference resolution between modules

🎲 Content Generation

• One-click sample data population
• AI-powered content generators (via ContentGenerator.cs)
• Quick testing and prototyping

⚡ Powerful Runtime System

• JSON-based fast loading
• Singleton pattern for easy access (RuntimeDatabaseManager.Instance)
• Helper methods: GetItem(), GetQuest(), GetCharacter(), etc.
• Full LINQ compatibility for complex queries
• Automatic cross-reference resolution

📚 Complete Documentation

• API Reference with code examples
• Setup Guide
• Testing guide (README_TESTING.md)
• Working demo scene (DatabaseDemo.unity)
• Example scripts (DatabaseUsageExample.cs)

🔧 Developer-Friendly

• No dependencies except TextMeshPro
• Compatible with Unity 2022.3+ and Unity 6
• Works with both old and new Input System
• Modular architecture for easy extension

Quick Start

1. Open the editor: Menu → Tools → Nexus Database → Open Editor
2. Click "🎲 Populate with Sample Data" to generate example data
3. Explore modules in the sidebar
4. Open the demo scene: Assets/NexusDatabase/Scenes/DatabaseDemo.unity
5. Add RuntimeDatabaseManager component to a GameObject and press Play

The Nexus Database system is already integrated into your project and ready to use!

Nexus Database is a complete visual database management system for Unity game developers. It provides a modern, user-friendly editor interface for managing all types of game data—from items and quests to characters, NPCs, and abilities. Instead of manually editing JSON files or writing complex data systems, you can manage everything through a beautiful visual editor with smart dropdowns and one-click content generation.

Unity Version:

Developed in Unity 2022.3 LTS

Compatible with Unity 2022+ and Unity 6

Can be adapted to earlier versions with minimal changes

Render Pipeline Support:

• Built-in Render Pipeline (BRP) – ready out of the box

• Universal Render Pipeline (URP) – requires importing included URP.unitypackage

• High Definition Render Pipeline (HDRP) – requires importing included HDRP.unitypackage

Demo scenes are included for each pipeline.

Dependencies:

• Demo requires Input System package for controls

• Demo requires TextMeshPro for UI elements

Both can be installed via Unity Package Manager.

Core Requirements:

• Rigidbody (for vehicle physics)

• WheelCollider (for wheel simulation)

Architecture:

• Component-System-Configuration pattern

• Built on a reusable MonoBehaviour Component System

• Data-driven design using ScriptableObjects

Performance:

• Centralized system processing (no per-object update overhead)

• No per-frame allocations in core systems

• Scales efficiently with multiple vehicles

• Suitable for both mobile and desktop projects

Modularity:

• Each vehicle feature is implemented as a separate module

• Systems operate independently of each other

• New modules can be added without modifying existing code

Input:

• Input-agnostic design

• Accepts normalized float inputs (throttle, brake, steering)

• Compatible with any input solution (New Input System, legacy, custom, AI)

Project Organization:

• Core logic isolated in reusable packages

• Demo content separated for easy removal

• Clean structure suitable for production projects

Third-Party Content:

This asset includes third-party demo assets, but they are also licensed under the Unity Asset Store Standard EULA.

API Usage Disclosure:

This asset does NOT use any external APIs or third-party services.

• No API keys are included or required

• No external dependencies

• No network communication

All systems are fully self-contained within Unity.

Links And External Resources:

• Play a WebGL demo: https://transylvanian-tales.itch.io/simple-modular-vehicle-controller-demo

• Contact us at: transylvanian.tales.gamedev@gmail.com

• Step-by-step tutorials are available here: https://www.youtube.com/playlist?list=PL2ESxGsWSBc4aL4EqsdrzWQ9cuPCrFuSN

Play a WebGL demo:

https://transylvanian-tales.itch.io/simple-modular-vehicle-controller-demo

SMVC (Simple Modular Vehicle Controller) is a modular, extensible vehicle framework built using a clean component-system architecture.

Instead of relying on a single monolithic car controller, SMVC breaks vehicle behavior into independent modules such as Engine, Gearbox, Steering, Brakes, and more. This allows you to easily customize, extend, or replace functionality without affecting the rest of the system.

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

Contact And Support

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

Don't know how to run SMVC?

Don't know how to setup your own car models?

Have any questions or suggestions?

Contact us at:

transylvanian.tales.gamedev@gmail.com

Step-by-step tutorials are available here:

https://www.youtube.com/playlist?list=PL2ESxGsWSBc4aL4EqsdrzWQ9cuPCrFuSN

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

Use Any Car Model

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

SMVC works with any car model, feel free to use your own models.

The blue car comes with SMVC and is fully driveable.

The white car from the screenshots is NOT included!

If you don't know how to setup your own car models, watch the tutorial videos or contact us.

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

Core Architecture

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

SMVC follows a structured, data-driven design:

• Configurations (ScriptableObjects)

Define static data such as engine power, gear ratios, and braking force

• Components (MonoBehaviours)

Store runtime state and reference configurations

• Systems

Process all components globally, keeping logic centralized and efficient

This separation ensures clean code, high scalability, and easy maintenance.

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

Key Features

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

• Modular Design

Each vehicle feature is its own independent module

• Input Agnostic

Works with any input system (New Input System, legacy input, custom input systems, etc.)

• Data-Driven

Tune vehicles using ScriptableObjects without changing code

• Component-System Architecture

Systems process all components globally for better organization and performance

• Highly Extensible

Add new systems and modules without modifying existing code

• Multi-Pipeline Support  

Supports Built-in, URP, and HDRP.  

URP and HDRP demo content is provided via included .unitypackage files for easy import.

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

Included Modules

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

• Engine & Gearbox

RPM simulation, torque calculation, automatic shifting

• Steering

Wheel-based steering with configurable angles

• Brakes

Simple and responsive braking system

• Wheels

Physics + visual synchronization using WheelColliders

• Speedometer

Real-time speed calculation (KPH / MPH)

• Camera & Dashboard

Basic chase camera and UI needle system for demos

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

Use Cases

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

• Prototype vehicle mechanics

• Learn modular architecture in Unity

• Build arcade-style driving systems

• Create your own custom vehicle controllers

Note:

This asset is designed as a flexible foundation and learning resource, not a full realistic vehicle simulation.

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

Third-Party Content

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

This asset includes third-party demo content:

• A 3D car model used in the demo scenes

The model is provided as part of this asset and is covered under the Unity Asset Store Standard EULA for use within your projects.

Important:

• You can freely use the included car model in your games and applications

• No attribution is required

• There are no additional restrictions beyond the standard Asset Store EULA

Full details, including the original author, source, and permissions, are available inside the asset at:

/Assets/TransylvanianTales/SMVC/THIRD-PARTY NOTICES.txt

Note:

The demo content is optional and can be safely removed if you only need the core vehicle system.

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

API Usage Disclosure

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

This asset does NOT use any external APIs, web services, or third-party code libraries.

• No API keys are required

• No external services are accessed

• No data is sent or received over the network

All functionality is implemented entirely using Unity’s built-in systems.

Key features:

• Easy setup with minimal boilerplate
• Real-time streaming responses (partial output support)
• Flexible configuration via OllamaConfig
• Automatic retry with exponential backoff for network issues
• Multi-session conversation management
• Per-session system prompts for roles and character behavior
• Tools / Function Calling to trigger game-side features from the LLM
• Encrypted chat history with persistence support

Requirements:

• Unity 2021.3 or later (recommended)
• Windows 10/11
• Ollama server required (installation/setup guide is included in this asset package)
• mistral installed in Ollama (installation/setup guide is included in this asset package)
• GPU recommended (CPU is supported but slower)

Limitations:

• Unity-only (UnityWebRequest dependency)
• Windows-focused support
• Task-based APIs are coroutine-backed internally

Overview

EasyLocalLLM is a lightweight Unity library that makes local LLM integration simple and practical.
With as little as a few lines of code, you can add offline AI chat and immersive NPC dialogue powered by Ollama.

Included samples:

• SimpleChat (basic chat UI)
• LateralThinkingQuiz (gameplay-oriented example)
• QuickStartTest (minimal functionality check)

Key Features:

• Auto Fullscreen on Play: Option to automatically switch to fullscreen when entering PlayMode, or toggle it manually with hotkeys.
• Fullscreen For Any Window: Supports Game View, Scene View, Main View, or whatever window currently has focus.
• Toggle Toolbar: Instantly hide the top toolbar for maximum immersion.
• Smart Placement (Placement Source): Maximize windows on your main display, the display containing the Unity window, or directly on the screen where your cursor is currently located.
• Multi-Monitor Support (Mosaic): Advanced Mosaic mode helps distribute Game Views across multiple displays.
• Fully Customizable Shortcuts: Tailor the hotkeys to your liking (defaults to F8–F12, with Ctrl/Cmd, Shift, and Alt modifier support).
• Performance Optimization: Optionally disable Scene View rendering while in fullscreen to boost your FPS.
• Cross-Platform Support (Windows, macOS & Linux): Integrates seamlessly with native window features, including global toolbar hiding on macOS and X11 native fullscreen on Linux.

Fullscreen Editor & PlayMode is a handy plugin that lets you strip away all of Unity's distracting borders and panels, leaving only the exact thing you are currently working on.

Want to playtest your game exactly as your players will see it? The plugin automatically maximizes PlayMode to fullscreen the moment you hit Play. Tired of crowding your complex scenes into a tiny editor window? With a single keystroke, the Scene View takes over your entire monitor.

Designed to help rather than hinder, this plugin supports any editor window, works beautifully with multi-monitor setups, and easily adapts to your workflow.

Who is this for? Absolutely every developer. Regardless of your game's genre, a clean interface and deep focus on your current task will save you time and reduce eye strain.

What makes it unique:

• Smart placement system: Windows can maximize right where your mouse cursor is, or on a specific monitor of your choice.
• Respects your workflow: The plugin allows important utility windows to stay on top of the fullscreen view, so you don't have to constantly tab back and forth.

• Runtime implementation of the Barrier Pattern
• Lightweight, decoupled synchronization layer
• Supports multiple concurrent participants
• Clear API for registering and completing tasks
• Designed for modular project architectures
• Minimal overhead and clean integration
• Sample scene demonstrating practical use cases
• Compatible with Unity LTS versions
• No external dependencies

Barrier Pattern provides a clean, modular layer for synchronizing independent gameplay systems without tight coupling or complex state handling.

It allows multiple asynchronous operations — such as UI transitions, timers, animations, scene preparation, spawning logic, or system initialization — to register as participants in a barrier. Execution continues only when all participants have completed.

The package is designed to be simple to integrate, extensible, and safe for production use. It is genre-agnostic and suitable for any Unity project that requires coordinated execution flow, including loading systems, cutscenes, wave spawning, multi-stage initialization, or gameplay gating.

A sample scene is included demonstrating UI fade transitions and timed events synchronizing before gameplay proceeds, followed by a secondary barrier controlling unit spawning.

The system is fully customizable and can be extended to match project-specific architecture.

The system generates animations by manipulating Unity Humanoid muscle values using procedural motion curves.

Animation clips are generated programmatically and saved as standard Unity AnimationClips.

Supported muscle groups include:

• Spine
• Chest
• Upper Chest
• Neck
• Head
• Upper Arms
• Forearms
• Hands
• Upper Legs
• Lower Legs
• Ankles
• Fingers
• Thumbs

The system also supports:

• Root position animation
• Root rotation animation
• Keyframe reduction
• Configurable sampling rate

Generated clips are compatible with Unity’s Humanoid retargeting system.

Editor Interface

The editor interface includes multiple tabs for clear organization.

Main Tabs:

• Bake Settings
• Idle
• Walk/Run
• Strafe/Turn

Each animation tab contains sub-tabs for body parts:

• Head
• Torso
• Arms
• Legs
• Hands

This layout allows quick access to specific motion controls.

Animation Generation

Animations are produced by evaluating procedural motion curves across time and writing the resulting humanoid muscle values into animation curves.

Keyframe sampling and reduction are applied during baking to produce efficient animation clips.

Looping animation clips are automatically generated.

Requirements

Unity 2021.3 or newer recommended

Humanoid avatar rig required

The tool operates entirely within the Unity Editor and does not require external software.

Included Content

• Procedural Animation Generator
• Idle Preset System
• Walk/Run Preset System
• Strafe Preset System
• Example presets

Documentation

A detailed user guide is included explaining:

• Editor interface
• Parameter controls
• Animation generation workflow
• Preset system
• Root motion configuration

This tool is useful for:

• Game prototypes
• Indie developers
• AI character locomotion
• NPC animation
• Procedural animation systems

Rapid iteration of animation styles

Full C# code included.

Support

If you have questions or encounter issues, support and documentation are included with the asset.

Pacemaker Humanoid Procedural Animation Creator is a powerful Unity editor tool that generates realistic Idle, Walk, Run and Strafe animations entirely through procedural parameters.

Instead of relying on motion capture or external animation software, this tool allows developers to build high-quality humanoid animations directly inside the Unity Editor using intuitive sliders and real-time preview.

The system drives Unity’s Humanoid muscle system, ensuring the generated animation clips remain compatible with any humanoid avatar.

Animations are generated mathematically using parametric motion curves, allowing precise control over movement characteristics such as body sway, leg swing, arm motion, breathing, head movement, and root motion.

Developers can quickly iterate on animation styles, save reusable presets, and generate animation clips ready for use in gameplay systems such as locomotion controllers, AI characters, or prototypes.

All settings have full tooltips explaining their usage.

Key Features

Procedural Animation Generation

Generate humanoid animation clips entirely through procedural motion.

Supported animation types:

• Idle
• Walk/Run
• Strafe/Turn (Left / Right)

No external animation tools required.

Real-Time Scene Preview

Preview animations directly on the character in the Scene view before generating clips.

Preview modes include:

• Idle preview
• Walk/Run preview
• Strafe/Turn preview

This allows fast iteration when adjusting parameters.

Parametric Motion Controls

Adjust detailed motion parameters for each body part:

• Head
• Torso
• Arms
• Legs
• Hands

Examples of adjustable parameters include:

• Pelvis bob
• Spine lean and sway
• Arm swing
• Leg swing
• Knee bend
• Ankle lift
• Wrist rotation
• Finger curl and spread
• Head movement and idle look behavior

Strafe Animation Support

Create realistic lateral movement animations including:

• Directional strafing (Left / Right)
• Rotational turning (Left / Right)
• Lead and trailing leg motion
• Natural body sway
• Synced or individual arm movement
• Optional root motion

The strafe system uses a lead-step and follow-step cycle to simulate natural sideways locomotion.

Root Motion Support

Animations can optionally include root motion.

Control:

• Root motion axis
• Root rotation
• Movement distance per cycle
• Direction

Root motion is authored directly into the animation clip.

Humanoid-Compatible Output

Generated animation clips are written using Unity's Humanoid muscle system, ensuring compatibility with:

• Any Humanoid avatar
• Mecanim animation controllers
• Retargeting across characters

Animation Export Modes

Multiple export options are available:

Single clip

Split clips:

• Upper body
• Lower body

Merged full-body clip

This allows flexible integration into animation systems and blend trees.

Preset System

Save and reuse animation configurations using ScriptableObject presets.

Preset types:

• Idle Presets
• Walk/Run Presets
• Strafe/Turn Presets

Presets store all animation parameters and can be applied instantly to recreate or modify existing animation styles.

Designed for Fast Iteration

The tool is built for rapid animation prototyping.

Typical workflow:

1. Adjust parameters
2. Preview animation in the scene
3. Generate animation clip
4. Use the clip in your Animator Controller

🦴 Ragdoll Inspection & Tuning

• Per-bone inspector with foldout sections
• CharacterJoint limits and springsVisual editing of:
  Rigidbody settings
  Colliders (Box / Capsule / Sphere)
  
• Global scale correction
• Safe enable/disable of physics without breaking pose

🎥 Physics Testing

• Preview any animation state and scrub to an exact frame
• One-click ragdoll activation
• Restore animation cleanly after testing
• Apply configurable hit forces and torque
• Optional whole-ragdoll spin for dramatic effects
• Works in Play Mode, where Unity physics behaves correctly

🎬 Animation Baking

• Bake ragdoll motion into AnimationClips
• Generic transform curvesSupports:
  Humanoid muscle curves
  
• key reductionAdjustable:
  duration
  sample rate
  smoothing
  
• Auto naming with _hit / _death suffixes

💥 Hit Reaction Mode

• Record short hit reactions
• Automatically restore pose after impact
• melee hit responsesIdeal for:
  damage flinches
  knockbacks
  

☠ Death Animation Mode

• Record full ragdoll collapse
• Apply impact and/or torque to any bone from any direction
• Perfect for procedural or physics-based death animations

🦴 Creature Ragdoll Builder

Create stable, game-ready ragdolls in seconds.

Features

• Bone-based ragdoll creation
• Perfect for Creatures and non-humanoid rigs.
• Config-driven defaults (ScriptableObject based)
• Mass distributionAutomatic:
  Rigidbody creation
  Collider sizing (Box / Capsule / Sphere)
  CharacterJoint setup
  
• Global scale correction
• Humanoid and Generic rig support

Roadmap

Phase 1: Creature Builder + RagdollTuner (Available Now)

Phase 2: Advanced Humanoid Ragdoll Builder + Unified Hit-React System

Phase 3: Advanced Recovery Blending & Gameplay Enhancements

Ragdoll Tuner Pro is a Unity Editor tool that lets you visually test, tune, and convert ragdoll physics into usable animation clips.

Instead of guessing joint limits, collider sizes, or hit reactions, you can:

• interactively simulate physics,
• preview exact start poses,
• preview joint limit movement on single or combined axis,
• apply forces or impulses,
• and bake the result directly into animation clips.
• create hundreds of hit or death animations in minutes.

It supports both Humanoid and Generic rigs and is designed for real production workflows — from indie games to studio pipelines. Auto-detects rig type and exports the appropiate clip type.

Creature Ragdoll Builder is an advanced and fully configurable ragdoll creator designed specifically to cater for complex non-humanoid generic models but can be used for humanoid models or simple bone-chains as well. Creature Ragdoll Creator can be used to "Extend" existing humanoid or non-humanoid ragdolls e.g include wings or tails.

Can be configured using a scripted object configuration file containing ignored bones, joint presets, bone mapping and many other features. Comprehensive mass distribution system can be applied on build or post build.

Both tools share the same configuration object and will use the same bone mappings and joint presets.

Join Discord

Key Features

• One-click automatic setup
• Free camera movement (WASD + mouse look)
• Adjustable Field of View and zoom
• Game pause toggle
• UI visibility toggle for clean screenshots
• Post-processing enable/disable
• Optional camera collision
• High-resolution screenshot capture
• Clean and intuitive user interface
• Well-structured and readable code

Technical Information

• Engine: Unity 2021.3 LTS or newer
• Render Pipelines:
  Built-in Render Pipeline
  Universal Render Pipeline (URP)
• No external dependencies
• No runtime allocations during use
• Fully customizable and extendable
• Includes demo scene and documentation

Easy Photo Mode is a lightweight and developer-friendly camera tool designed to create high-quality screenshots and in-game photo modes with minimal setup.

With a single click, the tool automatically sets up everything needed to start capturing clean, cinematic screenshots — no complex camera logic, no manual configuration, and no boilerplate code.

The system provides a free camera with intuitive controls, allowing you to pause the game, hide UI elements, adjust field of view, toggle post-processing, and capture polished screenshots suitable for Steam pages, marketing materials, or in-game photo modes.

Easy Photo Mode is designed to work out of the box and can be easily customized or extended to fit different project needs, genres, or visual styles. It is suitable for indie developers, solo creators, and small teams who want professional results without spending hours building a custom camera solution.

Ideal use cases:

• Capturing marketing screenshots and trailers
• Creating an in-game photo mode
• Debugging scenes with a free camera
• Showcasing environments and characters
• Press kits and store page visuals

Requirements:

• Unity 2022.3 LTS or newer
• Game Creator 2 Core (required)
• Game Creator 2 Stats Module (optional, recommended)
• TextMesh Pro (included in Unity)

Package Contents:

• Full C# source code
• 14 GC2 Instructions, 12 Conditions, 12 Events
• 4 UI Components, 10+ Helper Components
• 3 Test Scene Generators
• Complete documentation

SWS — Spawn & Wave System is a complete spawning and wave management solution designed exclusively for Game Creator 2. Build Tower Defense games, Roguelike survival arenas, resource gathering systems, and more — all through Visual Scripting with no coding required.

Example Use-Case of Spawn & Waves System:

Your enemies already use GC2 Stats for health. Your combat system deals damage through GC2 Actions. SWS connects the dots.

Add SpawnedEntityTracker to your prefab — that's it. SWS automatically detects GC2 Stats, tracks health changes, and fires events when entities are defeated. No manual wiring. No custom scripts.

Enemy spawns → Takes damage → Health reaches zero → Wave updates → Next wave triggers

The entire flow works out of the box because SWS was built specifically for how GC2 games work. Not adapted. Not ported. Built for GC2 from day one.

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

Full Online Documentation: Website

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

Powerful Wave System

• Configurable wave sequences (Single, Loop, Endless modes)
• Multiple spawn timing modes (Instant, Sequential, Continuous, Burst)
• Difficulty scaling per loop with customizable multipliers
• Flexible end conditions (AllDefeated, Timer, SpawnComplete, Manual)

High-Performance Spawning

• Object pooling with configurable pool sizes per entity type
• Priority-based spawn queue (Critical, High, Normal, Low)
• Central entity registry for efficient tracking
• Automatic health integration with GC2 Stats

Path System (Tower Defense)

• Waypoint-based paths with visual editor
• PathFollower component with speed and rotation options
• Waypoint events and wait times

Resource System

• Harvestable resources with configurable harvest time
• Automatic respawning with per-type delays
• GC2 "On Interact" integration ready

GAME CREATOR 2 INTEGRATION

14 Visual Scripting Instructions

12 Conditions

12 Events

UI COMPONENTS

• WaveStatusUI — Current wave, progress bar, entity counts
• WaveAnnouncerUI — Wave start/complete announcements
• EntityCountUI — Real-time alive/defeated counters
• NextWaveTimerUI — Countdown between waves

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

HuckHub - Possible Updates and Integrations

This asset communicates with HuckHub to check for module updates, possible Integrations, upcoming releases and links external documentation.

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

Technical Details

Unity Version:

• Unity 2021.3 LTS or newer
• Tested in Unity 2021 LTS, 2022 LTS, and 2023 LTS

Render Pipeline:

• Built-in Render Pipeline
• Universal Render Pipeline (URP) compatible
• No HDRP-specific dependencies

Platforms:

• PC (Windows, macOS, Linux)
• Mobile (iOS, Android)
• WebGL (core systems supported)
• Console-ready architecture (no platform-specific code)

Input System:

• Unity Input Manager (legacy) by default
• Easily adaptable to the New Input System

Dependencies:

• TextMeshPro (Unity package)
• No third-party assets or plugins required

Programming Language:

• C#

Namespaces:

• All scripts are fully namespaced under GolemkinGames.CozyController

Code Architecture:

• Modular, component-based design
• Event-driven systems using UnityEvent
• Clean separation between controller, systems, UI, and tools
• Designed for extension without modifying core scripts

Performance:

• Optimized for life-sim scale scenes
• Layer-masked physics queries to reduce overhead
• Lightweight per-frame logic
• Object lifecycle management for runtime-spawned effects
• Suitable for mobile and low-end devices with proper asset setup

Save System:

• JSON-based save files
• Supports multiple save slots
• Auto-save and manual save support
• Uses Application.persistentDataPath
• Persistent runtime state for player, inventory, time, world objects, and placed items

Camera System:

• Multiple camera styles in a single component
• Optional camera collision
• Interior/exterior mode switching
• Mouse, keyboard, and fixed-angle controls supported

UI System:

• Built with Unity UI (UGUI)
• Uses TextMeshPro for text rendering
• Fully skinnable and replaceable UI components
• No hard dependency on a specific canvas setup

Physics:

• Uses Unity physics (Rigidbody + Collider based)
• CapsuleCollider-based character controller (not Unity’s built-in CharacterController)
• Layer-based interaction filtering

Audio:

• AudioSource-based playback
• Surface-based footstep system (component or tag driven)
• Event hooks for tool, movement, and interaction sounds

Networking:

• Not networked by default
• Systems are deterministic and event-driven, suitable for multiplayer integration

Extensibility:

• Add new tools, items, crops, fish, bugs, and placeables via data configuration
• Hook into gameplay events without modifying source
• Replace or extend UI and visuals independently

Documentation:

• Comprehensive in-package documentation
• Inline tooltips and clear inspector layouts

Included Content:

• Scripts only (no character models, animations, or art assets) + demo art assets under CC0
• Example prefabs and demo-ready components for all systems

Cozy Controller is an all-in-one life-sim character controller system built for cozy games: farming, fishing, collecting, building, and relaxing exploration. Drop it into a new or existing project and you’ll have a solid foundation for a complete life-sim loop—movement, camera, inventory, tools, interactables, UI, and saving—ready to extend.

What’s Included

Character Controller

• Smooth, camera-relative movement with walk/run/sneak
• Jump with coyote time + jump buffer for forgiving controls
• Ground detection + configurable layers
• Gameplay-ready events (jump/land/footsteps/speed changes)

Camera System (Multiple Styles)

• Cozy-style fixed angles with Q/E rotation
• Isometric mode (true isometric angle)
• Fixed follow mode
• Free-look orbit mode + zoom
• Optional camera collision + interior mode support

Inventory + Hotbar

• Category-based inventory (tools, fish, bugs, seeds, crops, materials, furniture, etc.)
• Stacking, equipping, consumables, placeables
• Currency support + buy/sell prices per item
• Events for UI updates, item added/removed, money changes, slot selection

Tool System (5 Tool Types)

• Fishing Rod, Axe, Net, Shovel, Watering Can
• Tool cooldowns, interaction range, rotate-to-target, optional movement blocking
• Dedicated tool model scripts for visuals/particles
• Tool events for easy integration (fish bite/caught/escaped, chop/tree felled, bug caught, dug item, plant watered)

Time & Seasons

• Simulated time (configurable minutes per day)
• Real-time mode and real-time scaled mode
• Day/night support with sunrise/sunset events
• Season progression with configurable days per season
• Lighting hooks for sun/moon setup

Farming: Plant Growth + Watering

• Multi-stage crop growth (seed → growth → main → harvestable)
• Water level + optional “requires watering”
• Harvest logic, quantities, optional regrowth
• Visual stage models + world prompts/effects/events

Harvesting / Chopping System

• Health-based destructibles with drops (trees, rocks, etc.)
• Optional harvest-mode for renewable resources (fruit trees, berry bushes)
• Regen options, hit shake, damage delay for animation sync

Fishing Minigame

• Cast → wait → bite cue → catch window
• Weighted fish pools with time + season restrictions
• Optional Fishing Spots with custom pools and overrides

Bug Catching

• Catchable creatures with wander + flee behaviors
• Flying options (height range + bob)
• Catch effects + events

Digging

• Weighted buried loot with chance of “nothing”
• Dug state tracking + optional respawn time
• Dig visuals/audio + events

Building & Decoration

• Building mode for placing/moving/picking up furniture
• Building zones with bounds, grid snap, capacity limits, Y tolerance
• Preview materials for valid/invalid placement
• Pre-placed object support + saved placement data

Shop System

• Buy/sell UI flow with stock counts and price overrides
• Sell price multiplier support
• Interaction range + trigger open option
• Transaction events (bought/sold/failed)

Save / Load System
Saves the core state needed for a life-sim loop:

• Player transform
• Inventory contents + currency + hotbar selection
• Time/day/season state
• Plant growth + watering state
• Choppables (health/harvest state/destroyed)
• Dig spots (dug state)
• Caught creatures tracking
• Placed objects (item ID, transform, zone)

Includes CozySaveable for persistent object identity and auto-save support.

UI Kit

• Hotbar UI, Inventory UI, Time UI
• Item popups (pickup notifications with fly-to-UI)
• Building UI
• Shop UI
• World tooltips + harvest button helpers

Audio

• Surface-based footstep system (component or tag-driven)
• Jump/land/swim hooks
• Tool SFX hooks ready via events

Editor Tools

• Quick scene setup helpers (create time manager/save manager/popup manager)
• Save reset/open folder shortcuts
• Debug menu utilities (skip hour/day, set season, log inventory)

• 8 Tracks
• Wav format
• 44.1kHz, 16bit
• Loopable

This pack includes:

• 4 original tracks plus 4 seamlessly looping versions (one for each track).

Full tracks range in length between 1:16 and 1:44 (all fade out naturally).

Looping versions range in length between 1:03 and 1:33.

Total pack length (including loop versions): 10:56

Details:

• Producer: juanjo_sound
• Created with: FL Studio (no AI used)
• Format: WAV

Happy creating!

• 21 modular track pieces

Track Pieces

Straight

• Long Straight | 6 Triangles
• Long Straight curb | 12 Triangles
• Long Straight Start | 66 Triangles
• Medium Straight | 4 Triangles
• Medium Straight curb | 8 Triangles
• Medium Straight Start | 44 Triangles
• Small Straight | 2 Triangles
• Small Straight curb | 4 Triangles
• Small Straight Start | 22 Triangles

Turn

• medium shicane Turn Left | 46 Triangles
• medium shicane Turn Left curb | 92 Triangles
• medium shicane Turn Right | 46 Triangles
• medium shicane Turn Right curb | 92 Triangles
• Medium Turn | 36 Triangles
• Medium Turn curb | 72 Triangles
• Small Turm | 26 Triangles
• Small Turm curb | 52 Triangles

U-Turns

• small U-Turn | 46 Triangles
• small U-Turn curb | 92 Triangles

Chicane

• Small fast Chicane | 48 Triangles
• Small fast Chicane curb | 96 Triangles

Information

• for questions or comments feel free to send an email to paddyproductionsyt@gmail.com

Features

• modular racing circuit pieces
• inlcudes all modular pieces scene
• includes Prefab with colliders

Number of Materials:1

Number of Material Instances:3

Number of Textures:14

Texture Resolutions: 1024x1024

- PBR textures- Attention This model uses its own UE5 skeleton. Compatible with any animations from Free sources and others. It has PBR textures. There is no animation But you can try using the ones that are on the sites. The video features a demonstration animation of the dance, showing how the character's equipment is set up.

faces 4928

verts 4705

tris 9186

Polycount
Demon Girl Raven Faces 44482 Verts 48623 Tris 87143

4K Textures
Hair, Eyes, Teeth, Cornea, Head, Body, Clothes

Textures Included: Base Color, MaskMap , Normal, MatID

Emissive Alpha RootGradient etc.

These maps are combined into a single texture to optimize performance and workflow.

⚙️ Multi-Pipeline Custom Shaders

The included custom Shader Graph materials support all three render pipelines: Built-in, URP, and HDRP.
The shaders are designed to work consistently across different pipeline setups.

MatID

🎨 Customizable Materials

This character uses custom shaders that allow you to adjust the color of any part of the character directly in the material settings.
You can easily modify hair, skin, and other elements without editing textures.

FullBody
Full Body is Included.

Body texture is censored.

Additional bones added to the Epic Skeleton: 

BONES

https://docs.google.com/document/d/10sRLqMHptLxoquQy9Fku69seY6kQj4-cbeTJGboG9IQ/edit?usp=sharing

## Features

* **Visual Graph**

* **Cycle Detection**

* **Build Guard**

* **Architecture Rules**

* **Headless Mode**

* **Dependency Tracing**

* **Duplicate Finder**

* **Size Treemap**

* **Heatmap Analysis**

* **Reference Counting**

* **Smart Filtering**

* **Assembly Support**

* **Batch Processing**

* **CI/CD Ready**

* **One-Click Fixes**

* **Project Health**

* **Orphan Detection**

* **God-Class Finder**

* **Editor Integrated**

* **Zero Runtime**

* **Custom Presets**

* **HTML Export**

* **JSON Reports**

* **Auto Layout**

* **Performance Optimized**

* **Offline Docs**

## Supported Unity Versions

* Unity 2020.3 LTS

* Unity 2021.3 LTS

* Unity 2022.3 LTS

* Unity 2023+ (All cycles)

* Unity 6 (Above)

## Technical details

* **Editor-Only Tool**: Zero runtime overhead.

* **Source Code**: Full C# included.

* **Dependencies**: None (Stand-alone).

## Supported OS

* Windows 10 / 11

* macOS

* Linux

## Link to documentation

Online Documents

As Unity projects scale, code structure slowly degrades. Scripts start referencing each other without clear boundaries, dependencies grow uncontrollably, and circular references creep in. Over time, refactoring becomes risky, builds become fragile, and small changes start breaking unrelated systems.

Nexus Graph is a professional Unity Editor tool built to visualize, analyze, and enforce clean architecture in real production projects. It gives you full visibility into how your C# scripts depend on each other and actively prevents dangerous architectural issues from reaching builds.

🕸️ Complete Dependency Visualization

Nexus Graph generates a live, interactive dependency graph of your entire C# codebase.

Each node represents a script and each connection represents a real reference. The graph supports zooming, panning, auto-layout, and smart filtering, allowing you to understand complex systems at a glance. Unity internal assemblies can be hidden automatically so you focus only on your own code, not engine noise.

The system is optimized to handle large projects with hundreds or thousands of scripts smoothly.

🔄 Advanced Circular Dependency Detection

Circular dependencies are one of the biggest causes of tightly coupled and unmaintainable code.

Nexus Graph automatically detects:

• Direct cycles (A → B → A)
• Deep dependency loops (A → B → C → D → A)
• Hidden coupling chains across multiple systems

Problematic cycles are highlighted clearly, making it easy to identify the exact reference that closes the loop and refactor safely.

🛡️ Build Guard — Architecture Firewall

The Build Guard integrates directly into Unity’s build pipeline and acts as a safety gate for your architecture.

Before every build:

• The project is scanned for circular dependencies and rule violations
• Critical issues can automatically block the build
• Severity levels can be configured as warnings or hard stops

Batch mode support makes it suitable for CI/CD pipelines, ensuring broken architecture never reaches production or shared branches.

🧠 Architecture Rule Engine

Define and enforce architectural boundaries across your project.

You can:

• Restrict which layers or folders are allowed to reference others
• Enforce clean and modular architecture patterns
• Create custom rules using flexible pattern matching

When a rule is violated, Nexus Graph reports the exact dependency responsible, making enforcement clear and actionable.

📊 Project Health & Codebase Insights

Nexus Graph provides high-level insights into your project’s structure:

• Identify highly referenced “god classes”
• Detect orphan scripts that are never used
• Analyze dependency density and coupling hotspots
• Understand which files are risky to modify

These insights help teams plan refactors, reduce technical debt, and maintain long-term stability.

🧩 Advanced Analysis & Reporting Tools

• Interactive node-based graph with auto-layout
• Dependency Path Finder to trace reference chains between any two scripts
• Smart filtering to isolate specific systems or layers
• Asset size and duplication analysis
• Export architecture reports as JSON or HTML for team reviews, documentation, and audits

HTML export allows teams to share clear, readable architecture reports without requiring Unity access.

⚙️ Built for Professional Workflows

• Editor-only tool with zero runtime overhead
• Non-destructive analysis (never modifies code logic)
• Optimized for large, long-term projects
• Fully compatible with Assembly Definition (.asmdef) workflows
• Full C# source code included (no DLL lock-in)

Nexus Graph helps you see your architecture clearly, stop bad dependencies early, and keep your Unity projects modular and scalable as they grow.

JOIN DISCORD | DOCUMENTATION | OTHER ASSETS