Asset Store newest packages

Features:

• 82 High-quality UI Sprites: Hand-crafted pixel art for RPG/Adventure genres.
• 9 Color Variations: Flexible bar fills for HP, MP, Stamina, and more.
• Ready-to-use Prefabs: Pre-configured HUD and UI components for Unity UI (uGUI).
• Animated Elements: Smooth HUD opening transitions using Unity Animator.
• Demo Scene: Includes a fully functional UI layout example.

Asset Specifications:

• Total Sprites: 82 PNG files
• Resolution: 16x16, 32x32, and custom UI sizes (Pixel Perfect)
• Format: Transparent Lossless PNG
• Unity Version: 2021.3 LTS or higher (Recommended)
• Render Pipeline: Works with Built-in, URP, and HDRP
• UI System: Unity UI (uGUI)

Included Components:

• Prefabs: 2 (Main HUD, UI Components)
• Fonts: 3 (Noto Serif: Regular, Medium, Bold)
• Animations: 1 (HUD Open/Close)
• Scripts: No C# scripts required (Plug & Play)

🏰 Pixel HUD UI: Fantasy RPG Kit

"The Final Piece to Complete Your Pixel World"

Stop wrestling with UI design and start building your game. A great game deserves a professional interface. Whether you're tracking health, managing gold, or exploring a mini-map, this Pixel HUD UI Kit provides everything you need to give your project a polished feel in seconds.

⚔️ WHAT'S INSIDE

This pack contains 82 high-quality pixel art sprites designed for modern RPGs and adventure games.

• Status & Progress Bars
  2 bar styles × 9 colors (18 fills + 2 backgrounds)
  Status bars: HP fill + 9 color variations
  9 Colors: Red, Blue, Green, Orange, Pink, Purple, SkyBlue, BlueGreen, Yellow
  Includes 9 potion icons + HP heart icon
• 18 Game Icons
  Consumables: Apple, Carrot, Pumpkin
  System: Gold, Gem, Attack, Defense, Alarm, Chat, Lock, Menu, Download
  General & Tools: Compass, Hourglass, Map, Logging Axe, Repair Hammer, Branches
• UI Components
  Panels: Currency, SlotPane (x2), Text, Thumbnail, Title
  Slots: Normal, Selected, Dim (regular & small)
  Frames & Indicators: 3 Map Frames, Heart/Red Dot/Tag indicators, Buttons, and Backgrounds

🎮 PERFECT FOR

• 2D Pixel Art RPGs & Adventures
• Survival & Crafting Games
• Top-down & Side-scrolling Projects
• Game Jams & Prototyping (Quick setup!)

💎 WHY THIS KIT?

• Consistent Style: Uniform pixel art style across all 82 sprites.
• Unity Prefabs Included: Skip hours of UI setup with ready-to-use prefabs.
• No Dependencies: Works out of the box without extra plugins.
• Commercial Use: Included in all editions for your indie or pro projects.

LICENSE:

• YES: Use in personal/commercial projects, modify as needed, include in software builds.
• NO: Resell or redistribute as-is, upload to asset marketplaces, or use in AI/NFT datasets.

If this kit helps your project, a ⭐⭐⭐⭐⭐ rating would mean the world to me! Your support is the best motivation to keep creating.

How Snapshots Work

SceneGit uses a lightweight JSON-based storage system:

• Each GameObject gets a persistent GUID for tracking

• Component data serialized using Unity's JsonUtility

• Hierarchy relationships preserved via GUID references

• Prefab connections tracked via asset paths

Storage Location

Snapshots stored at: Assets/Editor/SceneGit/Storage/Snapshots/

Settings stored in: EditorPrefs (per-user, not in project)

Performance Characteristics

• Snapshot Creation: ~100ms for typical scene (500 objects), ~1s for large scene (5000+ objects)

• Restore: Similar to creation time, depends on scene complexity

• Change Tracking: Minimal overhead, updates every 0.5s in edit mode

• Storage: ~5-50KB per snapshot depending on scene size

Compatibility

• Unity Versions: 2020.3 LTS and newer

• Render Pipelines: Built-in, URP, HDRP

• Platforms: Windows, macOS, Linux

• Special Components: Works with UI, Particles, Physics, Animation, etc.

Unlike traditional version control systems that work at the file level, SceneGit works at the GameObject and Component level, giving you granular control over scene state management. Whether you're experimenting with level design, iterating on gameplay, or need a safety net before major changes, SceneGit has you covered.

What Makes SceneGit Different?

• Works entirely within Unity - no external tools required

• Real-time change tracking with visual hierarchy indicators

• Comprehensive restore logging to catch missing assets

• Supports all GameObject types including prefabs, UI, and particles

• Non-destructive workflow with automatic safety snapshots

• Image fomart: transparent PNG.
• Image dimension: 1024 x 1024.
• 392 tiles.
• 6 tile palettes.
• 7 demo scenes.

Ultimate Hex World Tiles Pack - Triple Realms Edition is a professional 2D hex tilemap asset pack for Unity, featuring 392 high-quality tiles.

The pack includes three complete world styles:

• 🟢 Normal Realm (195 tiles): grasslands, forests, cities, towns, villages, mines, deserts, and ruins
• 👁️ Horror Realm (97 tiles): corrupted lands, dark structures, eerie ruins, and twisted environments
• 🔥 Lava Realm (100 tiles): volcanoes, magma rivers, molten grounds, and wastelands

It also features buildings, statues, portals, monster remains, meteor craters, and more.

Fully compatible with Unity Tilemap, ideal for RPG, strategy, survival, and roguelike games.

Core Features:

• Two-Panel Navigation - Category cards and detailed content views

• Hierarchical Organization - Categories → Groups → Entries structure

• Collapsible Groups - Expand/collapse content sections with smooth animations

• Quick Category Switching - Tab navigation for fast browsing

• Hover & Selection States - Visual feedback on all interactive elements

Input Support:

• Legacy Input Manager - Works out of the box

• New Input System - Full support with InputActionReference

• Configurable toggle key/action

Game Integration:

• Automatic Game Pause - Optional Time.timeScale control when guide opens

• Singleton Pattern - Easy global access via GuideManager.Instance

• Event System - OnGuideOpened and OnGuideClosed events for custom logic

Designer Tools:

• ScriptableObject Database - No coding required for content

• Fully Serialized - All settings exposed in Inspector

• Custom Editor Extensions - ShowIf attribute for conditional field visibility

• Assembly Definition - Fast compilation times

What's Included:

• Complete C# source code (fully commented)

• 4 ready-to-use prefabs

• Sample database with example content

• Demo scene

• Comprehensive documentation

Technical Requirements:

• Unity 2021.3 LTS or higher

• TextMeshPro (included in Unity)

• Input System Package (optional, for new input support)

• Works with Built-in, URP, and HDRP

• All platforms supported

Performance:

• Optimized for mobile and console

• No Update() overhead when closed

• Efficient UI rebuilding

• Assembly Definition for fast compilation

Guide System is a complete, production-ready in-game encyclopedia and tutorial UI system for Unity. Give your players the information they need with a sleek, modern interface.

Perfect for:

• Game Tutorials - Step-by-step guides organized by topic

• Lore Compendiums - World-building, history, locations

• Item Databases - Equipment, consumables, collectibles

• Character Profiles - NPCs, enemies, allies, factions

• Bestiary - Creature information, stats, weaknesses

• Achievement Guides - Tips, unlockables, secrets

• Help Systems - In-game documentation & FAQs

The system features a beautiful two-panel navigation design. Players first see category selection cards with custom backgrounds and icons, then dive into detailed content views with expandable groups and rich entry information.

All content is managed through an intuitive ScriptableObject database - no coding required to add or modify guide content. Designers can create and organize entries directly in the Unity Inspector.

The modular architecture means you can easily extend the system to fit your specific needs. Add search functionality, bookmarks, custom entry types, or integrate with your existing game systems using the built-in event hooks.

Whether you're a solo developer or part of a larger team, Guide System will save you weeks of development time while delivering a professional result your players will love.

Golf vs Domino is a hyper casual game and a new offering from Polygrunt Studios.

This template is a fully customizable puzzle game template features different characters, coin store, diamonds and levels.

This is the perfect starting point for your next mobile game, hyper casual game, or puzzle game project! 🎮

📱 Demo : Android Demo Link

⭐ FEATURES

📘 Very Easy to Use Guide

🧹 Clean Code Structure

📄 Documentation Included

🎥 Video Tutorial

💬 Discord Support

🧩 TEMPLATE FEATURES

🛠️ Level Creation System with Level Editor

📚 Detailed Documentation

🪙 In App Purcahse and Store with Coins

📢 In App Purchase with No Ads

📊 Monetization with Admob

🎮 Monetization with Unity

🏁 30 Levels

🌍 SUPPORTED PLATFORMS

📱 Android

🍎 iOS

🌐 WebGl

💻 Desktop

⚙️ COMPATIBLITY

🧩 Works with Unity 2022.3.62

📞 SUPPORT

❓ Have questions?

🛠️ Need support?

📧 Contact us at polygrunt@gmail.com

💬 Or Get Support in our Discord

Third-Party Licenses:

This asset uses the Anton font by Vernon Adams under the SIL Open Font License 1.1 and multiple audio files from freesound.org under Creative Commons 0 (CC0).

See Third-Party Notices.txt file included in the package for full details.

Technical Details:

• Number of Meshes: 291
• LOD stages: Yes, 1-4 per model
• Number of Prefabs: 293
• Number of Particles: 4
• Number of Paint Layers: 7
• Number of Materials: 125
• Number of Textures: 615
• Texture Resolutions: up to 4K
• Texture Formats: TGA and PNG

Modular medieval village environment with 290+ unique meshes, particle effects, terrain with paint layers and additional foliage models. Example village scene included!

URP Version Only!

Meshes:

290+ unique meshes including: house parts, fences, wooden elements, crates, boxes, tools and many more. Torches and lamps with fire effects included.

Terrain:

The example village scene is included in this pack.

The terrain includes paint layers and additional foliage models (trees, grass).

Volumetric Fog effect included.

Questions, concerns or assistance:

email: info@dexsoft-games.com

Join Discord Server

Note:

Due to large project size, mobile version is not supported!

Input System:

• Unity Input System (required)

Core Script Architecture:

• PlayerController (core runner logic)
• Event-driven extensibility
• Object pooling systems
• Modular managers (Game, Difficulty, PowerUps, Audio)

Rendering:

• No custom shaders required
• Fully compatible with URP
• Mobile optimization guide included

Mobile Optimization:

• Object pooling
• No per-frame allocations
• No Animator component usage
• MobileOptimizer example script
• Spawn scaling for mobile devices
• Audio compression recommendations

Physics:

• Rigidbody-based controller
• Capsule collider compatible
• Configurable layer masks

Animation System:

• Fully procedural
• No Animation Controller
• No Humanoid Rig required

Platform Targets:

• PC
• Android
• iOS

Demo WebGL: itch.io

Stop Rebuilding Endless Runner Logic From Scratch

Voxel Run is a structured and modular endless runner template built specifically for developers who want a clean base system without unnecessary bloat.

It includes a performant lane-based controller, procedural voxel animation (no Animator required), mobile-ready architecture, and example gameplay systems to demonstrate extensibility.

This is not a reskinned demo game.

It is a foundation designed for customization.

Core Movement System

• Automatic forward movement (Z-axis runner system)
• Lane-based horizontal switching
• Jump mechanic
• Slide mechanic
• Double jump support
• Ground detection & collision handling
• Inspector-exposed parameters for balancing

Strictly designed for endless runner gameplay.

Not a free-roam 3D controller.

Developer-Focused Architecture

• Clean, modular C# scripts
• Event-driven system (OnJump, OnLaneChange, OnHit, etc.)
• No Animator dependency (procedural body animation)
• Inspector-driven configuration
• Easily extensible

You get systems, not restrictions.

Mobile-Ready Codebase

Built with performance in mind:

• No Animator overhead
• Object pooling for obstacles and audio
• Lightweight runtime logic
• Touch and swipe support (Unity Input System)
• Keyboard support for PC testing

The included documentation provides a full mobile optimization guide (URP setup, quality tiers, audio optimization, build settings).

Included Example Systems (Optional)

To help you get started, the package includes lightweight example implementations:

• Difficulty progression system
• Object pooling obstacle spawner
• Coin system with magnet effect
• Power-up system (Shield, Speed Boost, Double Coins, Plane, Magnet)
• Car obstacle system with side collision blocking
• Basic Game Manager
• Camera shake system
• Pooled audio manager
• Infinite ground tiling
• Example voxel character prefab

All example systems are modular and can be removed or replaced without affecting the core controller.

Voxel Procedural Character

• Modular body parts (Head, Torso, Arms, Legs)
• Code-driven procedural animations
• Easy model replacement
• Works with custom modular characters

Swap the visuals. Keep the logic.

Ideal For

• Creating a new endless runner from scratch
• Prototyping runner mechanics quickly
• Mobile-first game development
• Replacing heavy Animator-based controllers
• Voxel or modular character games
• Educational projects and gameplay study

Important – Not Plug & Play (By Design)

Voxel Run is a modular foundation, not a one-click template.

This asset requires a small initial configuration (Tags, Layers, Player setup).

However, a structured Quick Start Guide is included that walks you step-by-step through the setup process.

You can have the provided Run scene fully working in approximately 5 minutes by following the checklist.

No complex setup.

No hidden dependencies.

Just a clear, documented configuration process.

Features:

・Text Generation via Multiple LLM Providers (OpenAI, Anthropic, Gemini, Azure, Bedrock)

・On-Device LLM Inference via LLamaSharp (GGUF models)

・Streaming Response Support

・Environment File-based API Key Configuration

・Editor Window for Model Downloads

Important/Additional Notes:

The ThinLLM package integrates and extends several open-source projects.

These projects remain under their original licenses.

・LLamaSharp

・SmolLM2 (bundled demo model)

ThinLLM is a unified LLM API client that enables seamless integration of multiple AI providers into your Unity projects with a single, consistent interface. It lets developers call OpenAI, Anthropic Claude, Google Gemini, Azure OpenAI, AWS Bedrock, and local LLMs (GGUF models) through one simple Completion() method, with no code changes required when switching providers.

Core Features:

・Unified API Interface: Single Completion("{provider}/{model-name}", messages) method works across all 6 supported LLM providers

・Real-time Streaming: Token-by-token response streaming for responsive UI updates

・Local LLM Support: Run GGUF models offline via LLamaSharp - no API costs, no internet required

・Built-in Model Downloader: Download GGUF models directly from URL within Unity Editor

・Zero External Dependencies: All required libraries are pre-bundled in the package

ThinLLM is perfect for building intelligent NPCs, dynamic dialogue systems, AI assistants, or any application that needs flexible LLM access. The simple model format ("{provider}/{model-name}") makes it trivial to experiment with different providers and find the best fit for your project.

A demo scene with a working chat interface is included so you can start testing immediately out of the box.

• Texture sizes: 2048X2048, 512X512, 256X256, 128X128
• Image Format:PNG
• File count:121
• Animated: Yes/No
• Color Depth: 8-bit, 16-bit
• Transparency Information: PNG with transparency

• Clean, modern, and professional visual style
• Optimized for mobile & PC performance
• Consistent design across all assets
• Easy to integrate into existing Unity projects
• Suitable for casual, arcade, or realistic pool game
• Pool table (top view)
• Cue stick designs
• UI elements (buttons, panels, icons) 
• Backgrounds 

• Branching Dialogue System – Create conversations with multiple choices and story paths.
• NPC Portraits – Assign unique character portraits that display dynamically with dialogue.
• Typewriter Text Effect – Animate text letter by letter, with optional typing sound.
• UnityEvents Integration – Trigger quests, rewards, scene changes, or custom scripts from dialogue choices.
• Localization Support – Fully supports multiple languages; switch language at runtime without modifying dialogues.
• ScriptableObject-Based Data – Store dialogues, nodes, and choices in ScriptableObjects for easy editing.
• Dynamic Choice Buttons – Automatically generates UI buttons based on dialogue choices.
• Demo Scene Included – Test NPC interactions, branching dialogues, and language switching immediately.
• 2D & 3D Compatible – Works with Unity 2D sprites and 3D models.
• Easy to Customize – UI, portraits, audio, and typing speed are fully configurable.
• Lightweight & Efficient – Minimal impact on performance; works in small or large projects.

DialoguePro Pack is a complete dialogue solution for Unity, designed for developers who want dynamic, interactive conversations in their games. With this system, you can create complex branching dialogues, support multiple languages, and trigger game events directly from dialogue choices.

Features:

• Branching Dialogue: Create conversations with multiple choices that change the flow of your story.
• NPC Portraits: Assign different portraits for characters, displayed dynamically with dialogues.
• Typewriter Text Effect: Make your text appear character by character, with optional typing sound.
• UnityEvents Support: Trigger quests, rewards, scene changes, or custom scripts on player choice.
• Localization Ready: Switch between multiple languages at runtime without modifying your dialogues.
• Easy Setup: ScriptableObject-based system, fully compatible with 2D and 3D projects.
• Demo Scene Included: Quickly test NPC interactions, dialogue branching, and language switching.

Why DialoguePro Pack?

• Save hours of coding with a ready-to-use dialogue system.
• Fully customizable UI and events to fit any game style.
• Perfect for RPGs, adventure games, visual novels, or narrative-driven projects.

Included in the Package:

• DialogueManager & Trigger scripts
• DialogueData ScriptableObjects
• DialogueNode & Choice templates
• LocalizationManager & Language switcher
• Prefabs for UI elements and buttons
• Demo scene with example NPCs, dialogues, and language switching

Compatibility:

• Unity 2020.3 or later
• 2D and 3D projects
• TextMeshPro required

Technical Specifications

-Supported Unity Versions

• Unity 2023.3 (LTS) or later.
• Full support for both URP (Universal Render Pipeline) and HDRP (High Definition Render Pipeline).

-Supported Platforms

• PC: Windows, macOS, Linux
• Mobile: Android, iOS

Consoles: PlayStation, Xbox, Nintendo Switch

• WebGL: Fully functional on WebGL builds
• VR/AR: Supports Unity XR (Virtual Reality/Augmented Reality) development

-Graphics API Compatibility

• DirectX 11/12: Supports DirectX for Windows builds.
• OpenGL / OpenGL ES: Compatible with macOS, Linux, and mobile platforms.
• Metal: Fully supported on macOS and iOS devices.
• Vulkan: Supported on compatible devices for high-performance rendering

-Required Dependencies

This asset relies on the following Unity packages:

• com.unity.inputsystem

Used for handling player input in the included examples.

• com.unity.2d.sprite

Required for rendering sprites used in the example scenes.

• com.unity.2d.tilemap

Used for grid-based navigation examples.

• com.unity.burst

Improves performance of pathfinding calculations.

• com.unity.collections

Provides optimized native collections used by the pathfinding system.

• com.unity.mathematics

Used for high-performance math operations.

• com.unity.recorder

Used only for editor recording utilities included in the toolkit.

• com.unity.editorcoroutines

Used for editor tools that perform asynchronous operations in the Unity Editor.

Description

Pathfinding Agent is a high-performance pathfinding system for Unity designed to handle multiple AI agents efficiently using Unity's C# Job System, Burst Compiler, and Native Collections.

The system supports both 2D and 3D grid-based navigation and allows developers to define custom traversal logic for different types of units such as characters that can walk, jump, climb, swim, crawl, or fly.

Unlike traditional single-threaded pathfinding solutions, this package performs parallel path calculations across multiple agents, making it suitable for large simulations, strategy games, RTS games, and AI-heavy environments.

The system is designed to be extensible and modular, allowing developers to integrate their own movement logic while using the provided high-performance pathfinding backend.

Key Features

High Performance Pathfinding

• Uses Unity C# Jobs + Burst Compiler for multi-threaded pathfinding.
• Optimized with NativeCollections for low memory overhead.
• Supports parallel pathfinding requests for multiple agents.

Flexible Grid System

• Generic Grid architecture supporting both 2D and 3D navigation.
• Built-in world-to-grid conversion utilities.
• Efficient neighbor lookup and grid indexing.

Customizable Agent Behaviour

Agents integrate with the system by implementing the IUnit interface, allowing developers to define:

• Agent position and destination
• Movement capabilities (walk, jump, swim, fly, crawl, climb)
• Custom movement states
• Traversal costs and restrictions
• Transform synchronization with Unity objects

Parallel Path Requests

Multiple agents can request paths simultaneously using Burst-compiled jobs, making the system suitable for large numbers of AI units.

Path Optimization

Includes:

• Path retracing
• Path simplification
• Efficient node traversal

Debugging Tools

Includes Gizmo-based debugging tools for visualizing:

• Navigation nodes
• Generated paths
• Traversal logic

These tools help quickly debug navigation behavior during development.

How It Works

1. Add the Surface component to your scene.
2. Configure the grid size and node radius.
3. Assign obstacle layers using Unity colliders.
4. Implement the IUnit interface for your agent.
5. Register the agent with the surface to begin pathfinding.

The system will automatically process path requests using parallel Burst jobs.

Included Systems

• Core navigation grid supporting 2D and 3D environments.Grid
  
• Manages the navigation grid and agent registration.Surface Component
  
• Defines how agents interact with the pathfinding system.IUnit Interface
  
• Burst-compatible data structure used internally by pathfinding jobs.UnitData Struct
  
• Handles A* pathfinding calculations.PathRequest Job
  

Requirements

• Unity 2023.3 or newer (tested up to Unity 6.3)
• C# Jobs SystemUnity packages:
  Burst
  Collections
  

Optional:

• Cysharp UniTask (used in example workflows but not required)

Limitations

• While the destination is recalculated at runtime, the grid walkable areas and obstacle areas are only calculated once

Suitable For

• RTS games
• Simulation games
• AI crowd systems
• Strategy games
• Large-scale NPC movement systems

Support

For questions or technical support:

Email: bluebilly111@gmail.com

WhatsApp: +254741862123

This asset does not include art assets or character controllers.

Movement logic must be implemented by the user through the IUnit interface.

Third-Party Content:

This asset uses AI-generated textures created with Unity AI tools (Unity Muse).

See Third-Party Notices.txt for details.

Number of meshes/prefabs: 3

Number of materials : 2x4K

Number of textures: 10 total (8 + 2 hdrp mask)

Texture dimensions: 4K

Texel density: 1000+ px/m

Polygon count: 10,3K tris total

Rigging: Yes (wheels, ailerons, rudder, elevators, propellers etc.) - see preview images

Animation count: no

Animation type list: no

UV mapping: Yes

LOD information: No

Types of materials and texture maps: PBR (Albedo, MetalSmooth, Normal, AO, HDRP_Mask)

USAGE:

- This model is suitable for use in PC/mobile game-development, VR/AR applications, advertising, design visualization, forensic presentation, etc.

DESCRIPTION:

- AAA-quality asset developed by industry professionals working on world-know military game titles.

- Rigged wheels, ailerons, rudder, elevator, propeller etc.

- Ready to be animated inside Unity.

- Designed for 3rd person view flight.

- Optimised lowpoly asset, that is perfect for game-development

- All materials and textures are intelligently named

- No cleaning up necessary, just drop your models into the scene

- Real world scale 1:1

Support&Incuiries:

Discord

You will like it!

Evolve Studio LTD

Animation

- Number of Animations: 27

- Animation Types: In-Place (Root Transform disabled)

- Loop Animations: Yes (where noted)

- Frame Lengths: 16F – 120F depending on clip

- Rig: Humanoid (Unity Humanoid Avatar)

Animation List:

  Stand Up Loop (120F)

  Stand Up Loop – Turn the Page Early, Loop (120F)

  Stand Up Emotional Start (30F)

  Stand Up Emotional Loop (120F)

  Stand Up Emotional End (35F)

  Stand Up Surprised Start (16F)

  Stand Up Surprised Loop (120F)

  Stand Up Surprised End (20F)

  Sit Down Loop (120F)

  Sit Down Loop – Moving Foot (120F)

  Sit Down – Turn the Page Early, Loop (120F)

  Sit Down – Turn the Page Early, Loop – Turn the Page Early (120F)

  Sit Down Emotional Start (30F)

  Sit Down Emotional Loop (120F)

  Sit Down Emotional Loop 2 – Moving Foot (120F)

  Sit Down Emotional End (35F)

  Sit Down Surprised Start (16F)

  Sit Down Surprised Loop (120F)

  Sit Down Surprised End (20F)

  Seiza Loop (120F)

  Sit Down Pose B Loop (120F)

  Sit Down Pose B Loop – Moving Foot (120F)

  Sit Down Pose C Loop (120F)

  Sit Down Pose C Loop – Moving Foot (120F)

  Lie Down Loop (120F)

  Lie Down Loop – Moving Foot (120F)

Book Prop Model

- Number of Meshes: 2

- Number of Prefabs: 1

- Vertices: 218

- Triangles: 410

- Minimum Polygon Count: 410

- Maximum Polygon Count: 410

- Rigged: No

- UV Mapping: Yes

- LODs: None

Textures & Materials

- Number of Textures: 7

- Texture Dimensions: 2048 x 2048

- Material Types: Unlit, URP-compatible

- Texture Maps: Albedo (Diffuse)

Render Pipeline Compatibility

- Built-in Render Pipeline: ✔ Supported

- Universal Render Pipeline (URP): ✔ Supported

- High Definition Render Pipeline (HDRP): Not tested

Supported Unity Versions

- Unity 2021.3 LTS or later recommended

Package Contents

- 27 Animation Clips (.anim)

- 1 Book Prop Prefab (2 meshes, 7 textures, Unlit + URP materials)

Reading Motion Pack

Bring your characters to life with this comprehensive reading motion pack!

Perfect for chill scenes, visual novels, virtual worlds, and more.

This pack includes 27 carefully crafted animations covering a wide range of 

reading situations — from peaceful page-turning loops to expressive emotional 

and surprised reactions.

Whether your character is standing, sitting, relaxing in seiza, or lying down, 

this pack has you covered.

---

Included Animations:

[Standing]

- Stand Up Loop (120F)

- Stand Up Loop – Turn the Page Early, Loop (120F)

- Stand Up Emotional Start (30F)

- Stand Up Emotional Loop (120F)

- Stand Up Emotional End (35F)

- Stand Up Surprised Start (16F)

- Stand Up Surprised Loop (120F)

- Stand Up Surprised End (20F)

[Sitting]

- Sit Down Loop (120F)

- Sit Down Loop – Moving Foot (120F)

- Sit Down – Turn the Page Early, Loop (120F)

- Sit Down – Turn the Page Early, Loop – Turn the Page Early (120F)

- Sit Down Emotional Start (30F)

- Sit Down Emotional Loop (120F)

- Sit Down Emotional Loop 2 – Moving Foot (120F)

- Sit Down Emotional End (35F)

- Sit Down Surprised Start (16F)

- Sit Down Surprised Loop (120F)

- Sit Down Surprised End (20F)

[Other Poses]

- Seiza Loop (120F)

- Sit Down Pose B Loop (120F)

- Sit Down Pose B Loop – Moving Foot (120F)

- Sit Down Pose C Loop (120F)

- Sit Down Pose C Loop – Moving Foot (120F)

- Lie Down Loop (120F)

- Lie Down Loop – Moving Foot (120F)

---

Also Includes:

A low-poly book prop model, ready to use alongside the animations.

---

Ideal for:

- Chill / relaxing character scenes

- Visual novels and interactive fiction

- Virtual world avatars

- Cutscenes and cinematic storytelling

- Low‑poly prop collection inspired by Edo‑period Japanese interiors

- Optimized meshes suitable for mobile, VR, and stylized games

- Clean topology and consistent scale across all models

- Standard materials for full compatibility with Built‑in, URP, and HDRP

- Prefabs included for all objects for easy drag‑and‑drop use

- Ideal for historical scenes, cozy interiors, and stylized Japanese environments

- Lightweight textures and efficient UV layouts for performance‑friendly us

- Includes 

Low-poly Japanese props inspired by the Edo period!

Perfect for cozy interiors, historical scenes, or stylized storytelling. Includes futons, drawers, tea sets, and more.

This asset pack includes the following items:

Balance △2212

Bell △620

Bench △42

Book_A △12

Book_B △12

Book_C △12

Bottle △1128

Buckert △592

Bucket_Of_Water △820

Chrysanthemum_Close △1160

Chrysanthemum_Open △1160

Coffin △800

Coffin_lid △100

Cooking stove △2472

Cushion_A △1444

Cushion_B △1444

Cushion_C △1444

Desk △52

Fence △10

Fence_Door △34

Futon_Bottom △44

Futon_Folded △308

Futon_Top △560

Futon_Top_2 △748

Insense △96

Insense_burner △520

Insense_burner_2 △768

Kaki △208

Ladder △29000

LowPolyHose △36

Luggage △132

Matoi △2256

MedicineCabinet △448

Mino △312

Mirror △530

Paper △288

Pillow △328

Room △2798

Shelf △4961

Shyoji △132

Stick △312

Yagen △868

Textures

- Primary Texture Dimensions: 1024 x 1024

- Number of Textures: 50

- UV Mapping: Yes

Exceptions (non-square or smaller textures):

  Tex_Bucket_Water 512 x 512

  Tex_Kaki 512 x 512

  Tex_Mob_house 1024 x 512

  Tex_Noren 512 x 1024

Number of textures: 31

Texture dimensions: 2k, 4k

Polygon count:

Total Triangles: 3.3 M

Total Vertices: 2.3 M

Average Triangles per Prefab: 99.9 k

Minimum polygon count: 3 276 Triangles 

Maximum polygon count: 481 334 Triangles 

Number of meshes/prefabs: 34

Rigging: No

Animation count: 0

UV mapping: Yes

LOD information: no LODs

Types of materials and texture maps: Built-in Light Pipeline, PBR Textures

Bring a burst of sweetness to your 3D scenes with this vibrant Ice Cream Collection, featuring a wide variety of beautifully designed frozen treats. This set includes soft-serve cones, classic scoops, ice cream bars, popsicles, fruit-shaped treats, and gourmet sundaes – all crafted with high-quality detail and playful color palettes.

Perfect for advertising, product visualization, animation, game environments, VR/AR experiences, or decorative props in interior scenes, these models are designed to be both eye-catching and versatile.

Support

Please message me PM or use my email: oleg.verenko@gmail.com

BEFORE YOU LEAVE A RATING ON MY 3D MODEL:

If you have any questions or issues with my model, do not hesitate to write to me. I always answer and support my clients.

Design & Form:

• A mix of cones, cups, popsicles, and bars in realistic and stylized designs.
• Includes multi-scoop stacks, swirled soft serves, dipped chocolate cones, fruit designs, and sprinkle toppings.
• Carefully arranged display stands add a professional and decorative touch.

Materials & Textures:

• PBR materials for realistic shading and reflections.
• High-resolution textures for creams, wafers, chocolate coatings, sprinkles, and fruit details.
• Semi-transparent and glossy shaders for realistic ice cream and candy effects.

Colors:

• A bright and appetizing palette of pastel pinks, creamy whites, sunny yellows, rich browns, mint greens, ocean blues, and candy rainbow swirls.
• Metallic accents on stands for a premium presentation.

Tags:

ice cream, popsicle, dessert, sweets, 3D food, frozen treats, gelato, sorbet, sundae, chocolate, fruit ice cream, ice cream cone, cupcake, candy, pastel colors, bakery, summer food, realistic food, PBR, stylized food, food props, 3D dessert collection

Number of textures: 28

Texture dimensions: 1k, 2k, 4k

Polygon count:

Total Triangles: 3 218 520

Total Vertices: 3 085 793

Average Triangles per Prefab: 14 304

Minimum polygon count: 12

Maximum polygon count: 147 882

Number of meshes/prefabs: 225

Rigging: No

Animation count: 0

UV mapping: Yes

LOD information: no LODs

Types of materials and texture maps: Built-in Light Pipeline, PBR Textures

Content List

• Esports arena stage (full environment scene)
• Central circular competition platform with trophy pedestal
• Player desk setups (multiple PC stations with monitors, chairs, desks)
• Large overhead cylindrical LED screen structure
• Transparent perimeter barriers / glass walls
• Tiered stage platforms and stairs
• Side platforms and control/observer desks
• Integrated lighting system (neon strips, floor lighting, accent lights)
• Decorative architectural elements (curved panels, railings, trims)
• Camera/lighting props (stage fixtures)
• Materials and shaders (glass, emissive, metal, plastic surfaces)
• High-resolution game preview renders
• Props (PC, laptops, chairs, gaming desks, gaming chairs, computer monitors, keyboards, mice, mouse pads, headsets, desk-mounted speakers/soundbars, laptops, stage desks (caster/commentator desks), large circular display screens, LED stage floor panels, neon light strips, LED wall panels, trophy (championship cup), stage steps, glass partitions/railings, arena seating platforms, overhead lighting rigs, digital signage panels, cables/wiring, monitor stands, control panels/tablet on desk)

The product does not include a light setup! Watch the preview from Unity.

Support

Please message me PM or use my email: oleg.verenko@gmail.com.

If you have any questions or issues with my model - do not hesitate to write to me. I always answer and support my clients.

This esports stage environment is a high-end, futuristic arena designed for competitive gaming broadcasts, tournaments, and cinematic visualization. The scene is built around a central circular platform that acts as the focal point, featuring a trophy pedestal that reinforces the competitive narrative and final-stage atmosphere.

Design

The design emphasizes symmetry, clarity of sightlines, and broadcast-ready composition. The circular layout allows for 360-degree camera movement, making it ideal for cinematic shots and live-event simulation. The elevated central platform is surrounded by player stations arranged in a balanced formation, ensuring visual focus remains on both the competitors and the centerpiece trophy.

Above the stage, a large suspended cylindrical LED display system dominates the vertical space. This structure is designed for dynamic content such as gameplay feeds, branding, and live statistics, enhancing realism and immersion for esports productions.

Style

The style is futuristic and sleek, combining elements of cyberpunk and high-tech broadcast design. Clean curves, layered platforms, and transparent materials create a modern, premium look. The environment is optimized for both realism and stylized presentation, suitable for cinematic rendering as well as real-time applications.

Form

The stage uses predominantly circular and curved forms to guide the viewer’s eye toward the center. Smooth transitions between levels, rounded edges, and continuous flowing lines give the structure a cohesive and polished aesthetic. The transparent perimeter walls add depth without visually blocking the scene, maintaining openness while defining the arena boundary.

Materials

• Glass: Used extensively for barriers and architectural panels, featuring high transparency and subtle reflections
• Metal: Structural elements, frames, and trims with polished or brushed finishes
• Plastic/Composite: Player desks, chairs, and smaller stage components
• Emissive materials: Integrated into lighting strips, floor patterns, and display accents
• LED surfaces: High-resolution screen materials for the overhead display system

Colors

The color palette is dominated by deep blues and cool tones, creating a professional and immersive arena atmosphere. Neon accents in pink and cyan are used for edge lighting, floor outlines, and architectural highlights, adding contrast and visual energy. The combination of dark base tones with vibrant emissive highlights enhances depth and readability under various lighting conditions.

Tags

esports, esport stage, gaming arena, tournament stage, futuristic stage, cyberpunk, broadcast studio, virtual production, LED screen, arena environment, competition stage, gaming setup, stage design, neon lighting, sci-fi environment, modern architecture, circular stage, glass materials, cinematic environment, real-time ready, event stage, stadium interior, digital arena, high tech, game tournament, VR environment, stage lighting, esports broadcast, production set, 3D scene

Number of textures: 3

Texture dimensions: 2k,4k

Polygon count:

Total Triangles: 226 513

Total Vertices: 177 735

Minimum polygon count: 50k Triangles

Maximum polygon count: 93 383 Triangles

Number of meshes/prefabs: 3

Rigging: No

Animation count: 0

UV mapping: Yes

LOD information: no LODs

Types of materials and texture maps: Built-in Light Pipeline, PBR Textures

This pack includes 3 unique skeleton models:

• Long-neck brachiosaurus creature skeleton 
• Spiked deep-sea fish skeleton 
• Large predatory fish skeleton 

My other full skeleton collections:

https://assetstore.unity.com/packages/3d/characters/animals/ultimate-skeleton-and-skull-pack-game-ready-low-poly-assets-345870

https://assetstore.unity.com/packages/slug/365834

Skeletons Mini Set – 3 Models is a compact collection of highly detailed skeletal 3D assets inspired by prehistoric creatures and marine predators. The pack includes three distinct skeletons featuring different anatomical structures: a long-neck fantasy creature, a spiked deep-sea fish skeleton, and a large predatory fish skeleton.

The models are designed for cinematic scenes, fantasy environments, underwater worlds, museum displays, creature studies, archaeological scenes, and game environments. Each skeleton emphasizes clear bone structure and readable anatomy, making them useful both as environment props and as hero assets for close-up shots.

Design

The models are built with a strong focus on anatomical readability and dramatic silhouettes. Each skeleton highlights key structural components such as vertebrae chains, rib cages, skull cavities, jaw mechanics, and limb or fin frameworks.

The long-neck creature skeleton features an extended vertebral column with large rib structures and heavy limb bones, giving the appearance of a prehistoric or fantasy quadruped creature.

The spiked deep-sea fish skeleton includes exaggerated dorsal spines, elongated ribs, and a sharp skull structure typical of predatory deep-ocean species.

The large predatory fish skeleton is designed with a powerful jaw structure, prominent teeth sockets, large cranial cavity, and a fully articulated spine and fin system.

These variations allow the models to be used across multiple visual contexts, including prehistoric scenes, underwater environments, fantasy worlds, and scientific visualizations.

Style

The skeletons follow a realistic anatomical style with slight stylized exaggeration to enhance visual clarity and silhouette strength. Bone shapes are carefully sculpted to maintain natural curvature while emphasizing structural detail.

The style works well in:

• cinematic renders
• documentary visualizations
• fantasy or prehistoric environments
• underwater scenes
• museum or archaeological displays
• creature design references

The clean bone structure also makes the assets suitable for lighting studies and close-up render shots.

Form

Each model presents a different skeletal structure:

• Quadruped long-neck skeleton with a large rib cage and extended vertebrae
• Spiked fish skeleton with tall dorsal spines and thin rib formations
• Predatory fish skeleton with a strong jaw structure and large cranial bones

The forms vary from tall vertical structures to long horizontal bodies, allowing them to fill different scene compositions such as ground environments, underwater scenes, or display stands.

Materials

The models are optimized for standard PBR bone materials. Surfaces are suitable for applying realistic bone shaders with subtle roughness and micro-surface variation.

Colors

The skeletons use natural bone coloration commonly found in fossil or preserved skeletal remains:

• ivory
• off-white bone
• pale beige
• light calcium tones
• slightly aged yellowish highlights

The neutral palette allows the assets to integrate easily into different lighting environments such as underwater scenes, dark caves, museum displays, or fantasy landscapes.

Use Cases

• underwater environment scenes
• fantasy creature environments
• prehistoric landscapes
• archaeological discoveries
• museum displays
• cinematic VFX shots
• game environment props
• creature anatomy references
• educational visualizations

Tags

skeleton, bone skeleton, creature skeleton, fish skeleton, predator fish skeleton, deep sea fish skeleton, dinosaur skeleton, fantasy creature skeleton, bone anatomy, skeleton model, skeletal creature, vertebrae skeleton, rib cage bones, skull skeleton, marine skeleton, prehistoric skeleton, creature bones, animal skeleton model, bone structure, skeleton asset, anatomy skeleton, fossil skeleton, skeletal creature model, bone creature, skeleton prop

Number of prefabs: 25

Details for one part.

Mesh

- Number of polygons: 2～26214

- No collision

- No rigging

- No LOD

- No animation

- UV mapping: Yes

Material

- Existing material (standard)

Texture

- Number of textures: 1

- Texture size: 256*256-1024*1024

- Texture map type: Base color

The demo scene includes the following:

- Prefabricated indoor layout sample

Supported development platform: Windows

Render Pipeline Disclaimer:

This package is designed for URP.

This is a 3D model of an interior background for a game set in a bar.

This model is easy to place in the background of puzzle or casual games.

In addition, by combining it with the free asset "Korean_Style_Bar", you can create a rich bar without any initial setup.

It comes with prefabricated assets that are already placed, so you can use it as is for the game background.

You can also move the placement of OBJs within the prefab to create different layouts.

You can also use the meshes individually.

Package contents

・Makgeolli cup

・Kettle

・Chamisul cup

・Water bottle

・Refrigerator

・Bottled drinks (3 types with different colors/labels)

・Canned drinks (3 types with different colors/labels)

・Poster (3 types)

・Neon Sign (3 types)

・Sofa (Combinable)

・Decorative Wall (Brick)

・Door

・Picture Frame

・Ice Bucket (with Ice)

・Plant (Houseplant)

・Dartboard

Number of textures 6

Texture dimensions 1024x1024

Polygon count of

Rumah Kaki Seribut 1.816

Number of meshes/prefabs 1

UV mapping: Yes

Types of materials and texture maps PBR

The Architectural Ingenuity of the Eastern Frontier.

The Rumah Kaki Seribu (Millipede House) is a masterclass in indigenous engineering, traditionally built by the Arfak people in the rugged mountains of West Papua. This asset brings a rare piece of Nusantara’s cultural heritage to your digital environment, capturing the unique aesthetic of a structure supported by hundreds of small wooden pillars.

Key Features:

• Authentic Stilt Design: The model features the signature "forest of pillars" that elevates the home, reflecting its real-world purpose of protection against the elements and wildlife.
• Highland Facade: Includes the traditional single-entry ladder and symmetrical plank-based walls seen in Arfak dwellings.
• Material Fidelity: High-quality textures represent natural tropical hardwoods and organic roofing materials, perfect for immersive historical or survival settings.

Technical Requirements

Required:

• Unity 2022.3 or newer
• Game Creator 2 (Core module)
• TextMeshPro (included with Unity)

Production Ready:

• Comprehensive validation system
• Detailed error messages with fix suggestions
• Undo/Redo throughout
• Auto-save options
• Extensive debugging tools

Well Documented:

• 12+ comprehensive guides
• Video tutorials (coming soon)
• Online documentation
• Code examples
• Best practices

Transform Your Open World Into a Living, Breathing Experience

The World Activity System is a comprehensive Unity asset that brings your game worlds to life with discoverable spatial activities and dynamic temporal events. Built specifically for Game Creator 2, it provides a complete framework for creating engaging open-world gameplay without writing complex code.

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

More Details: Online Documentation

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

What is World Activity System?

WAS combines two powerful systems in one package:

Spatial Activities - Discoverable world content like shrines, dungeons, collectibles, and secrets that players explore and interact with.

Temporal Events - Time-based and scheduled events such as blood moons, boss spawns, day/night cycles, and recurring world events.

EventChains - Sophisticated event sequences with branching paths, conditions, and visual editing tools for creating complex gameplay scenarios.

All integrated seamlessly with Game Creator 2's visual scripting system.

Key Features

• Visual Workflow - See your entire event chain at a glance
• Drag & Drop - Intuitive node creation and linking
• Real-Time Validation - Catch errors before they happen
• Side-Panel Inspector - Edit properties without clutter
• One-Click Start Node - Change chain entry point instantly
• Undo/Redo Support - Never lose work to mistakes
• Professional UI - Unity-standard design (like Shader Graph)

Spatial Activity System. Create discoverable world content that rewards exploration:

• Activity Types - Shrines, dungeons, collectibles, secrets, bosses
• Discovery System - Trigger-based and proximity detection
• Anchor System - Place activities in any scene
• Prerequisite System - Control access with conditions
• Completion Tracking - Automatic progress saving
• GC2 Integration - Full Actions & Conditions library

Perfect for: Zelda-style shrines, Skyrim dungeons, collectibles, world bosses

Temporal Event System

Schedule events based on time, conditions, or priorities:

• Interval Events - Repeat every X seconds/minutes
• Time-of-Day Events - Trigger at specific game times
• Conditional Events - Execute when conditions met
• Priority Queue - Intelligent conflict resolution
• Prerequisite Caching - Optimized performance (95% hit rate)
• Event Chaining - Link events into complex sequences

Perfect for: Blood moons, NPC schedules, day/night cycles, boss spawns

EventChain System

Create sophisticated event sequences with full visual editing:

• Branching Logic - Success/failure paths, weighted random selection
• Execution Control - Wait, delay, parallel execution
• Link Conditions - Always, OnSuccess, OnFailure, Never
• Validation System - Catches circular dependencies, unreachable nodes
• Runtime Execution - GetNextNode(), conditional flow
• Debug Support - Timeline view, execution logs

Perfect for: Quest chains, dynamic encounters, NPC behaviors, tutorials

CozyWeather Integration

Use Events to change the environment and weather. You will be able to trigger events and activities either by game time, custom time integrations, or the linked cozy weather time controller. This is an optional offering. Even if selected by mistake, the fallback will be Game Time. A dedicated demo scene has been created to either

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

HuckHub - Possible Updates and Integrations

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

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