Feed aggregator

• Render Pipeline Support: BIRP, URP and HDRP
• Includes Particle Shaders Module with custom shaders
• Includes Projectile System Module
• Particle System Based: All effects are created entirely with Unity’s native particle system, ensuring compatibility across all platforms, including WebGL
• 75 drag and drop ready vfx prefabs
• Demo scene included
• Online Documentation
• Mobile-Ready: optimized particles for smooth performance on mobile devices.

This package provides a complete set of performance & size optimized projectile visual effects designed for modern Unity projects. Every effect is built to reduce memory usage and batch calls by using texture atlases, shared prefabs, and a minimal material setup, making it ideal for both desktop and mobile projects.

A custom shader setup with vertex streams allows emission to be controlled per particle system instead of per material. This gives you more flexibility without increasing draw calls or duplicating materials.

📝 Online Documentation

🔴 WebGL Online Demo

📧 E-Mail

✨Key Features

Performance focused design

• Texture atlas based effects for reduced memory footprint
• Shared root particle prefabs for consistent and efficient setup
• Minimal material usage for improved batching and rendering performance
• Custom shaders with vertex streams enabling emission control per particle system

Demo scene

A clean demo scene is included to test the entire setup and shoot projectiles right away.

Projectile System

Includes an Integrated projectile module that handles the shooting behavior and automatically spawns hit and launch flash effects

Compatibility

Supports BIRP, URP and HDRP

Online Documentation & Intuitive Integration

Setup is fast and straightforward. Clear documentation, organized prefabs, and simple scripts make it easy to integrate the effects into your own project.

Content

• 25 projectile effects
• 25 hit impact effects
• 25 launch flash effects
• 5 visual themes (Nature, Ice, Fire, Electricity, Magic)

This package is ideal for developers who want visually rich projectile effects while keeping memory usage low, batch calls minimal, and systems easy to extend across multiple projects.

Compatibility:

• Unity 6.2 (6000.2.13f1) and newer
• Supports all render pipelines (Built-in, URP, HDRP)
• Works on all platforms (PC, Mobile, Console, WebGL)

Architecture:

• Namespace: GameFeel.Core, GameFeel.Effects, GameFeel.Utils
• Abstract base class FeelFeedback for custom extensions
• Singleton GameFeelManager for global access
• No external dependencies

Included Components:

• TransformFeel - PunchScale, PunchPosition, PunchRotation, ShakePosition, ShakeRotation, WobbleScale
• CameraFeel - ScreenShake, PunchPosition, PunchRotation, FOVPunch, ZoomPunch
• VisualFeel - ColorFlash, AlphaFade, AlphaPulse, ColorPulse
• AudioFeel - PlayOneShot, PitchPunch, VolumePunch, PitchWobble
• ParticleFeel - Play, Burst, Stop, Clear
• FeelSequence - Sequential and Parallel modes with looping

Easing Functions (26 total): Linear, Quad, Cubic, Quart, Sine, Expo, Circ, Elastic, Bounce, Back, Spring, Punch (In/Out/InOut variants)

Performance:

• Coroutine-based animation (no Update overhead when idle)
• MaterialPropertyBlock support for batching-friendly color changes
• Cached shader property IDs
• Optional debug logging (disabled by default)

Cracked Game Feels is a lightweight, modular feedback system that adds polish and impact to your Unity games. Whether you're making a 2D platformer, 3D shooter, or mobile puzzle game, Cracked Game Feels provides the essential "juice" effects that make games feel responsive and satisfying.

What's Included:

• Transform Effects - Punch scale, punch position, shake, wobble, and rotation effects for any GameObject
• Visual Effects - Color flash, alpha fade, and pulse effects for sprites, UI, and 3D meshes
• Camera Effects - Screen shake with Perlin noise, FOV punch, camera position/rotation punch
• Audio Effects - One-shot sound playback with pitch/volume randomization and modulation
• Particle Effects - Trigger particle bursts and control emission
• Time Effects - Hit stop (freeze frames), slow motion, and smooth time scale transitions
• Effect Sequencing - Chain multiple effects together sequentially or in parallel

Key Features:

• Profile-based configuration using ScriptableObjects for designer-friendly iteration
• 26 built-in easing functions (Quad, Cubic, Elastic, Bounce, Back, and more)
• Completion callbacks for chaining custom logic
• Works with 2D sprites, UI elements, and 3D meshes
• Mobile haptic feedback support (iOS/Android)
• Zero garbage allocation during runtime
• Fully documented with XML comments

Quick Start:

1. Add a feedback component (TransformFeel, VisualFeel, CameraFeel, etc.) to any GameObject
2. Configure the effect type and settings in the Inspector
3. Call Play() from your code or link to a UI button

No complex setup required. Just add, configure, and play.

Installation

1. Import the package through Unity’s Package Manager or drag into your project.
2. Ensure InputSystem package is enabled in your project.
3. Create a new GameObject:
   Right-click → Create Empty → Rename: InputSystemManager
4. Add InputDeviceManager to it.
5. Mark the object as DontDestroyOnLoad (automatically done in script).
6. On each UI screen, add UIMenuInputHandler.

Done — no configuration required.

Input Device UI Manager is a lightweight and plug-and-play solution for Unity UI navigation using the new Input System.

It automatically detects whether the player is using a gamepad or keyboard & mouse, and adjusts your UI behavior accordingly:

• Switching UI navigation mode
• Selecting the default UI element (for gamepad navigation)
• Hiding or locking the system cursor
• Broadcasting input-method events to the UI

Perfect for menus, option screens, inventory interfaces, and any UI that requires smooth interaction both with gamepad and mouse.

This package contains:

• InputDeviceManager.cs
  Handles device detection, switching logic, and cursor state.
• UIMenuInputHandler.cs
  Automatically updates individual menus based on the active input method.

Minimal setup, zero dependencies beyond Unity’s Input System.

What’s Included

This asset includes 149 unique optimized low-poly meshes and 154 game-ready prefabs with clean topology and MeshColliders, allowing immediate use in gameplay without additional setup. The pack uses 25 customizable materials, all of which can be easily adjusted by changing color values, making visual customization fast and flexible.

The asset is highly optimized and has a very small file size, making it ideal for performance-sensitive projects such as survival, exploration, and atmospheric games. All assets are fully modular, allowing you to freely combine, rearrange, and reuse elements to build your own environments.

The package includes 5 folders with organized content:

• Buildings: 81 prefabs (modular building parts and structures)
• Props: 50 prefabs
• Environment: 21 prefabs
• FX: 2 prefabs
• Vehicles: 1 prefab

The package includes 4 fully functional and customizable C# scripts:

• DayNightCycle – controls the day and night cycle with multiple presets
• FlickerPointLight – creates realistic flickering lights (candles, lamps)
• FogBreathingURP – dynamic fog density and color variation
• IntroCameraPath – cinematic camera movement for scene presentation

All scripts are easy to customize, and full documentation is included.

Scenes and Visual Setup. This asset includes: DemoScene – a fully assembled, playable abandoned village with dynamic systems enabled, Showcase – a clean scene displaying all included assets.

Assets included (FBX models):

Modular buildings including modular house set 01 (16 parts), modular house set 02 (18 parts), modular house set 03 (19 parts), modular house set 04 (15 parts), log tree houses (2 models), and ladder (1 model). Each modular house is based on wall modules by default; some house sets also include additional structural elements such as doors, roofs, beams, and foundation parts. Fences and infrastructure include large fence modules (4 models), small fence module (1 model), power poles (2 models), and wires (2 models). Nature and environment assets include trees (5 models), large tree (1 model), grass (2 models), rocks (4 models), mushrooms (1 model), plants (1 model), landscape ground (1 model), soil (1 model), and water planes (3 models). Props and survival items include axe (1 model), barrels (3 models), boxes/crates (2 models), candles (3 models), dishes (4 models), food items (10 models), pumpkin (1 model), planter box (1 model), shelves (2 models), table (1 model), bed set 01 (4 parts), bed set 02 (4 parts), and bed set 03 (3 parts). Construction props include wooden planks (10 models). Vehicle includes car (1 model).

The pack includes 25 simple Unity materials. No textures are used; all materials are solid color–based. This approach is intentional and designed to keep the asset lightweight, highly optimized, and easy to customize for different art styles and projects.

Total polygon count across the entire asset pack is 14,931 triangles, making the set extremely lightweight and highly optimized for real-time use, including large scenes and performance-critical projects.

The scene features rain particle effects, dynamic fog, flickering lights, and post-processing effects configured via Global Volume, creating a strong atmospheric mood out of the box.

This asset is designed to work exclusively with the Universal Render Pipeline (URP). Global Volume settings are located in the URP folder. Built-in Render Pipeline and HDRP are not supported. To see all visual effects and dynamic systems in action, make sure to press Play while in the DemoScene.

COMPATIBILITY

• Unity 2022.3 LTS and newer
• Unity 6000.0 (Tech Stream) and newer
• URP

Low Poly Modular Atmospheric Survival Village Pack is an optimized modular environment for atmospheric survival-style games. It includes ready-to-use prefabs with MeshColliders, plus day/night cycle, dynamic fog, and weather effects to build an abandoned village mood fast. URP only.

Assets included (FBX models):

Modular buildings including modular house set 01 (16 parts), modular house set 02 (18 parts), modular house set 03 (19 parts), modular house set 04 (15 parts), log tree houses (2 models), and ladder (1 model). Each modular house is based on wall modules by default; some house sets also include additional structural elements such as doors, roofs, beams, and foundation parts. Fences and infrastructure include large fence modules (4 models), small fence module (1 model), power poles (2 models), and wires (2 models). Nature and environment assets include trees (5 models), large tree (1 model), grass (2 models), rocks (4 models), mushrooms (1 model), plants (1 model), landscape ground (1 model), soil (1 model), and water planes (3 models). Props and survival items include axe (1 model), barrels (3 models), boxes/crates (2 models), candles (3 models), dishes (4 models), food items (10 models), pumpkin (1 model), planter box (1 model), shelves (2 models), table (1 model), bed set 01 (4 parts), bed set 02 (4 parts), and bed set 03 (3 parts). Construction props include wooden planks (10 models). Vehicle includes car (1 model).

The pack includes 25 simple Unity materials. No textures are used; all materials are solid color–based. This approach is intentional and designed to keep the asset lightweight, highly optimized, and easy to customize for different art styles and projects.

Total polygon count across the entire asset pack is 14,931 triangles, making the set extremely lightweight and highly optimized for real-time use, including large scenes and performance-critical projects.

Number of textures: 7

Number of materials: 2 materials (box + internals)

Texture dimensions: 2048×2048 resolution

Triangle count: 21234

Vertex count: 10,750

Prefabs: Unity URP, HDRP & Built-In versions (material setup included, separate prefabs for each pipeline).

Rigging: No

UV mapping: Some UVs are intentionally overlapped and scaled to maximize texel density.

LOD's: None

Collision: No

Types of materials and texture maps: PBR

This game‑ready PBR industrial fuse box is an optimized electrical panel prop built for real‑time engines, VR, and interactive gameplay. It features six fuse sockets, a side power lever, a removable key, and fully removable fuses—ideal for puzzles, collectibles, and scripted logic systems. Each socket includes an indicator bulb supporting green (OK), red (fault), and off states, making it perfect for power puzzles, environment logic, and immersive worldbuilding.

Clean topology, efficient UVs, and detailed weathered materials ensure strong performance and a gritty, realistic industrial look.

Features

• Hinged‑door fuse box with handle (pivot aligned)

• Six fuse sockets with removable fuses

• Indicator bulbs with green / red / off emissive states

• Side power lever and removable key

• Optimized for VR and real‑time engines

Technical Notes

• Emissive elements are provided as separate meshes for easy programmatic on/off control (engine scripting not included). These meshes can be removed or replaced depending on performance needs.

• Some UVs are intentionally overlapped and scaled to maximize texel density.

• Created in Blender 4.4 and textured in Substance Painter.

• Supports Unity URP, HDRP & Built-In

• Once downloaded, the asset is located in the CoyakoGames folder.

Key Features :

• Customizable Simulation: Easily adjust solvers, forces, and collision parameters through inspector or in-game GUI.
• 2D & 3D Support: Compatible with both 2D and 3D physics, including URP 2D/3D renderers.
• Broad & Narrow Phase Collision: Efficient GPU-BVH-based broad-phase collision and compute-shader-driven narrow-phase detection.
• AABB & Sphere Support: Currently mainly support two kinds of colliders, aabb and sphere.
• Signed Distance Field (SDF): Fast SDF generation for tilemaps. Sphere Tracing algorithm to detect collision with SDF.
• Async GPU Feedback: Retrieve collision information from the GPU to trigger game logic or events.
• Interactive GUI: Built-in interface for testing and tuning simulations in real time.
• Highly Extensible: Add new solvers, materials, and features easily; fully scriptable with clean C# API.

# Aleph.Physics – GPU-Accelerated Physics Simulation for Unity (URP)

Aleph.Physics is a high-performance, GPU-driven, lightweight physics simulation framework designed for Unity projects using the Universal Render Pipeline (URP). It provides a modular and flexible system for simulating medium-scale interactive objects entirely on the GPU, minimizing CPU overhead and enabling real-time performance.

The key design principle of Aleph.Physics is **not to achieve full physical accuracy**, but rather to provide **acceptable collisions** while focusing on easy integration into your game. Compared to existing particle or physics simulation systems, Aleph.Physics fills the gap between purely visual particle effects and interactive game physics.

### Collision and Interaction

Aleph.Physics offers robust collision detection and response, along with **GPU-to-CPU asynchronous feedback**, making it ideal for integrating GPU-based physics with CPU-driven game logic. Typically, game logic runs on the CPU, and particle effects are visual-only, but Aleph.Physics allows meaningful interactions between particles and game objects. It supports four types of collision and response:

1. **Particle-to-Particle**: Using GPU Bouding Volume Hierarchy, GPU ray tests, Minkowski Difference, and dynamic collision detection.

2. **Particle-to-Environment**: Using Signed Distance Fields (SDF) or bounding volume checks.

3. **Particle-to-GameObject**: Using GPU ray tests for static collision detection.

4. **Async Feedback**: GPU-to-CPU collision notifications for game logic execution.

All collision computations are performed asynchronously on the GPU for high performance.

### Visualization and Interaction

Aleph.Physics includes an **interactive UI** that visualizes the Bounding Volume Hierarchy (BVH) and supports step-by-step simulation for debugging and experimentation.

### Extensibility

The framework is fully **configurable and extendable**, allowing developers to integrate advanced physics systems into their projects with minimal setup while maintaining high GPU performance. You can customize solvers, forces, and collision behavior, making it suitable for games, simulations, or interactive visual effects.

• Documentation

• Platforms Support: Android, iOS, WebGL

• Render Pipeline Support: Universal Render Pipeline (URP) and Built-in Render Pipeline

• Full Unity C# source code, clean and well-documented

• Built with a clean, modular, and extensible State Machine architecture

This package uses:

• UniTask under MIT License;
• Extenject under MIT License;
• DOTween under Artistic License;

see LICENSE.txt file in package for details.

Swipe Gunner is a dynamic mobile game template where the player controls a weapon mounted on a vehicle, blasting through hordes of monsters on the way to the final destination. It comes with ready-to-play demo levels and is easy to expand, customize, and integrate into any project.

This template is an excellent starting point for building a complete mobile action game with intuitive swipe controls, or for use as a standalone gameplay module within a larger project.

Support

Try a demo: Browser Demo

Template Includes:

Core Gameplay Systems

• Spline movement and aiming system
• Weapon system
• Rocket launch system
• Player systems: shooting, health, damage, explosions
• Camera controller
• Haptic feedback support

Progression & Meta Systems

• Expandable upgrade system with permanent progression:
• Armor – increases player health
• Vehicle – improves movement speed
• Weapon – increases damage
• Bullets – increases ammo capacity
• Rockets – enhances explosive damage
• Money system
• Reward system
• Save system

Enemy Systems

• Enemy AI with basic behavior
• 2 unique animated enemy types:TentacleStickman
• Customizable enemy and player stats (health, damage, speed, etc.)
• Enemy spawn editor

User Interface

• In-game HUD
• Settings window
• Loading screen
• Tutorial swipe screen
• Level complete screen
• Level failed screen

Level & Content Setup

• Basic level setup
• Tutorial system
• Example scenes
• Ready-to-play demo levels

Visuals & Audio

• Particle effects
• Sound effects

Data & Extensibility

• Easy game data management
• Designed to be easily expandable and customizable

CORE FEATURES

Grid Management System

• Dynamic grid generation with configurable dimensions and cell sizes
• Procedural edge erosion for organic, irregular grid shapes
• O(1) cell lookups for maximum performance
• Automatic coordinate conversion between grid and world space
• Flood-fill connectivity analysis and safe spawn positioning

Object Management

• Component-based architecture separating state from animation
• GridObject for position tracking, blocking, and interactions
• Optional GridMovement component for smooth animations
• GridEntity with automatic camera billboarding for 2D and 3D
• Push, swap, and teleport interactions
• Visual offset system for large objects spanning multiple cells

Movement System

• Five distinct movement types: Walk, Jump, Dash, Knockback, and Teleport
• Smooth interpolation with customizable easing curves
• Event system with OnMoveStart and OnMoveComplete callbacks
• Configurable speeds, jump heights, and dash multipliers
• Automatic fallback to instant teleport for static objects

Pathfinding and Queries

• Efficient A* pathfinding with diagonal movement support
• Manhattan distance queries for diamond-shaped ranges
• Chebyshev distance queries for square-shaped areas
• Line-of-sight detection with obstacle awareness
• Neighbor queries for both 4-directional and 8-directional movement
• Straight-line path calculations until blocked

Visual Feedback System

• Six highlight types: ValidMove, Attack, Danger, Path, Hover, None
• Priority-based highlighting with automatic layering
• Per-cell color customization with glow intensity and pulse speed
• Persistent danger zone marking
• Batch highlighting operations
• MaterialPropertyBlock optimization to avoid instancing overhead

Procedural Generation

• Configurable edge erosion with chance, iterations, and dither
• Smart erosion algorithm: corners erode faster than flat edges
• Main island detection for spawn safety
• Distance-from-void calculations
• Weighted prefab selection for visual variety
• Automatic wall regeneration after terrain changes

Camera System

• Automatic isometric camera setup and positioning
• Three camera styles: Isometric Orthographic, Isometric Perspective, Top-Down
• One-click grid centering with offset control
• Smooth focus transitions to specific cells
• Zoom control for both orthographic and perspective modes
• Automatic distance calculation based on grid size

Wall Generation

• Decorative boundary walls with stackable segments
• Smart placement algorithm avoiding camera occlusion
• Per-direction rotation control for proper alignment
• Random sprite selection for visual diversity
• Configurable height, offset, and material properties
• Automatic updates when grid shape changes

EDITOR INTEGRATION

Custom Inspectors

• One-click grid initialization and erosion
• Interactive grid selector tool in Scene view
• Real-time cell state visualization
• Quick wall generation controls
• Property validation and default value handling

Comprehensive Gizmos

• Grid boundary visualization with toggleable display
• Selected cell highlighting with state indicators
• Occupancy visualization with color coding
• Camera-to-grid connection lines
• Distance and position labels

PERFORMANCE OPTIMIZED

• Dictionary-based cell lookups: O(1) access time
• HashSet flood-fill for fast connectivity analysis
• MaterialPropertyBlock for efficient highlight rendering
• Zero garbage collection in movement coroutines
• Optimized range queries using mathematical formulas
• Suitable for grids up to 100x100 cells

DOCUMENTATION AND EXAMPLES

• Over 1200 lines of comprehensive documentation
• Quick start guide with minimal setup code
• Four complete example implementations
• Full API reference for all public methods
• Troubleshooting guide for common issues
• Code examples for 2D sprites and 3D models

COMPATIBILITY

• Works with 2D sprites and 3D models with no performance difference
• Universal Render Pipeline (URP) compatible
• Built-in Render Pipeline (BiRP) compatible
• Shader fallback system for maximum compatibility
• Unity 2020.3 or higher recommended
• Clean namespace organization with zero external dependencies

WHAT YOU GET

• Fully commented C# source code
• Complete grid system with pathfinding
• Movement system with five animation types
• Visual feedback and highlighting system
• Procedural generation tools
• Camera controller with multiple styles
• Wall generation system
• Custom editor tools and inspectors
• Example scene with working demo
• Comprehensive documentation

PERFECT FOR

• Tactical RPGs and strategy games
• Turn-based combat systems
• Puzzle games with grid mechanics
• Roguelike and dungeon crawlers
• Tower defense games
• Board game adaptations
• Tactics-style gameplay

Cracked Grids - Complete Isometric Grid System for Unity

| DOCUMENTATION | PRIVACY POLICY |

Cracked Grids is a powerful, production-ready framework designed to eliminate the complexity of building grid-based games in Unity. Whether you're creating a tactical RPG with deep strategic combat, a roguelike dungeon crawler, a puzzle game with intricate mechanics, or a turn-based strategy title, Cracked Grids provides the complete foundation you need to bring your vision to life.

Built from the ground up with real game development needs in mind, Cracked Grids handles all the tedious technical challenges of grid-based gameplay so you can focus on what makes your game unique. The framework takes care of coordinate systems, pathfinding algorithms, movement animations, object placement, and visual feedback - all the foundational systems that would otherwise take weeks or months to implement and debug yourself.

What sets Cracked Grids apart is its intelligent component-based architecture. Rather than forcing you into rigid structures, it separates concerns cleanly: grid state management is independent from movement animation, allowing you to mix and match capabilities as needed. Want a static obstacle that blocks movement? Just add the base component. Need an animated character with smooth movement transitions? Add the optional movement component. Building a sprite-based game today but want to upgrade to 3D models tomorrow? The same code works for both with zero modifications.

The system embraces flexibility without sacrificing performance. Every major operation is optimized for real-time gameplay - cell lookups happen in constant time, pathfinding uses efficient algorithms suitable for large grids, and visual effects leverage Unity's rendering optimizations to avoid unnecessary overhead. You get the ease of use of a high-level framework with the performance characteristics of hand-optimized code.

Cracked Grids also understands that great grid-based games need more than just basic movement. The framework includes sophisticated visual feedback systems for highlighting valid moves and dangerous zones, procedural generation tools for creating organic-looking play spaces, automatic camera positioning for perfect isometric views, and decorative systems for polishing your game's presentation. These aren't afterthoughts - they're integral parts of the framework designed to work together seamlessly.

Perhaps most importantly, Cracked Grids respects your time. The included documentation covers every feature in depth with practical examples, the custom editor tools let you visualize and debug your grid in real-time, and the complete source code is fully commented for those moments when you need to understand exactly what's happening under the hood. You're not just getting code - you're getting a complete solution that's ready to use in your next project, today.

Whether you're a solo developer building your first tactics game or a studio creating your next commercial title, Cracked Grids provides the robust, battle-tested foundation that lets you spend your time on gameplay, content, and polish instead of reinventing the grid-based game wheel.

• Average polygon count: ~30,000 triangles
• Clean topology and non-overlapping UVs
• PBR textures (Base Color, Normal, Metallic, Roughness)
• Texture resolution: 2048x2048
• Texture maps included: Albedo, Normal, Metallic, Height, Roughness, Ambient Occlusion
• Optimized for real-time use in Unity (VR/AR/mobile/PC)
• Prefab included for easy drag-and-drop
• FBX format included
• Suitable for industrial, training, and simulation scenes

This package features a realistic, low-poly gas cutting machine with PBR textures, ideal for industrial, training, and factory simulation projects. The model is fully customizable, well-optimized for real-time applications, and suitable for VR/AR environments, mobile, and desktop platforms. Clean topology and UVs make it easy to modify or retexture as needed.

• Models Included:

– 3 floating island variations

– Stylized pine trees

– Stylized palm trees

– Low-poly round trees

– Rocks and small environment props

– Lighthouse model

• Mesh Info:

– Clean low-poly topology

– Optimized for mobile and lightweight games

• Textures:

3 textures with a maximum size of 1024x1024 / 512x512:

• Format:

– FBX + Unity-ready prefab files

– Organized folders for easy import

• Objects : 47
• Vertices: 8,380
• Edges: 15,859
• Faces: 7,795
• Triangles: 15,771

This low-poly floating island environment is designed to bring a vibrant and stylized atmosphere to your game world. Each island features unique shapes, vegetation, and color palettes, creating a charming and visually appealing scene ideal for adventure, exploration, casual, and mobile games.

The pack includes multiple floating islands with different themes: a tropical island with palm trees and a small water area, a forest island with stylized pine trees, and an additional island with round low-poly trees. Each asset is carefully modeled with clean topology, simplified forms, and an optimized triangle count to ensure smooth performance across devices.

All models are fully UV-mapped and use simple materials suitable for mobile and stylized rendering. The scene offers assets that can be reorganized, duplicated, or expanded to create larger floating worlds. This pack is perfect for developers looking to quickly build stylized environments with a cohesive visual identity.

Number of animations: 507

Animation types: Root Motion & In place

Important Notice:

If you already purchased the following packs individually:"Injured Walk Animations Part 1 and 2", "Survivor Move Animations", or "Swim Techniques Animations",do not repurchase this bundle — it includes all of them.

🧭 Bundle Description:

Survival Master Kit brings together several specialized animation packs to cover all aspects of survival—on land and in water. With over 500 animations and a variety of included props, this bundle offers everything you need to create an immersive and believable survival experience.

✅ Bundle Content:

🔹 Survivor Move – 170 animations

Essential survival actions: drinking, eating, hunting, fishing, healing, using tools, shooting with guns or bow, urinating, defecating, vomiting, and more.

🔹 Swim Techniques – 70 animations

Realistic swimming styles: crawl, breaststroke, butterfly, backstroke, floating… ideal for aquatic gameplay.

Included Props (2): Floatie, Wooden Board.

🔹 Injured Walk part 1 and 2 – 267 animations

Injured locomotion: limping, exhaustion, pain, slowed movement… perfect for illustrating the physical toll of survival.

Included Prop (1): Stick used as a walking aid.

⚠️

***This pack contains only animation files.

No original character models or meshes are included.

Please retarget them to your own characters.***

Unity Version Tested:

• Unity 2022.3 LTS and above

Render Pipeline Compatibility:

• Built-in
• URP
• HDRP (UI-Only, no pipeline-specific shaders required)

Input System:

• Requires Unity Input System package
• (Old Input Manager not supported in v1.0.0)

Programming Structure:

• Fully ScriptableObject-based item database
• Modular UI system using Unity UI (+TextMeshPro)
• Clean namespace-based code organization

Included Systems:

• Inventory management (scrollable list)
• Equipment system with prefab spawning
• Tooltip system with dynamic stat display
• Item filtering by category
• Stackable items support
• Modifiers for items

Demo Included:

• Example scene with sample items, UI, and test character
• Placeholder models for weapons, armor, consumables, materials

Source Code:

• Full source included

Dependencies:

• TextMeshPro
• Unity Input System

Supported Platforms:

• Windows
• Mac
• Linux
• Mobile (UI-scalable, no platform-specific code)
• WebGL (UI only, behavior works out-of-box)

Core Inventory System is a complete, flexible, and beginner-friendly inventory and equipment framework built for Unity.

Whether you're creating an RPG, survival game, action adventure, or prototype, this system gives you a full working inventory setup out-of-the-box — while still being clean, extensible, and fully customizable.

Built using ScriptableObjects, clean UI architecture, and modular code, this system can be adapted to a wide range of gameplay styles. Equip armor, assign weapons, stack consumables, show item details with a dynamic tooltip, and visually spawn equipped gear on the player.

Features

• Click-to-equip / unequip equipment system
• Visual equipment preview (spawns models on the demo character)
• Scrollable inventory grid UI
• Item filtering by category (Weapons, Armor, Consumables, Materials, All)
• Smart tooltip system that automatically adapts based on item type
• Stackable item support (with customizable limits)
• ScriptableObject-driven item definitions
• Clean runtime API (add items programmatically with one line)
• Fully editable UI (fonts, colors, layout, sprites, icons)

Included Content

• Ready-to-use inventory UI prefab
• Demo scene with a sample character
• Placeholder models for armor, weapons, consumables, and materials
• Sample item ScriptableObjects to learn from
• Full PDF documentation (setup, customization, extending the system)

Designed For Developers

Whether you’re a solo developer, student, or studio, this system saves time while providing a clean foundation to build on.

Easily extend:

• New item types
• New stats
• New UI styles
• Additional equipment slots
• Gameplay logic such as crafting or durability

Code is clean, commented, and organized for learning and modification.

Best For:

• RPGs
• Fantasy or survival games
• Action adventure
• Loot-based systems
• Prototyping gameplay mechanics

Documentation Included

A complete PDF guide is included, covering:

• Setup
• Creating items
• Editing UI
• Adding slots
• Extending item stats
• Tooltip logic

• Runtime screenshot capture system for Unity.
• Standard and high-quality supersampled screenshot capture.
• Camera-based screenshot capture with configurable resolution.
• Fixed-resolution output is independent of screen size.
• Burst capture mode for rapid screenshot sequences, if needed.
• Optional automatic HUD / UI hiding during capture.
• Dedicated settings asset for clean configuration and reuse.
• Real-time capture confirmation with success or error feedback.
• Editor integration with menu actions and Inspector utilities.
• Extensible API with capture events and callbacks.
• Input System support (new Input System recommended).
• Cross-platform saving with automatic platform-safe paths. 
• Built-in support for Windows, macOS, and Linux.

Screenshot+ is a lightweight, extensible screenshot capture system for Unity, designed for developers, artists, and studios who need clean, reliable, and professional in-game screenshots.

Whether you’re capturing marketing material, documenting development progress, creating promotional shots, or giving players a built-in screenshot feature, Screenshot+ provides full control with minimal setup and zero external dependencies.

Features:

Standard & High-Quality Supersampled Screenshots ☑️
Capture standard screenshots instantly, or hold the capture input to generate ultra-sharp supersampled images using a configurable resolution multiplier.

Multiple Capture Modes ☑️
Screenshot+ supports standard screen capture, high-quality supersampling, camera-based captures, fixed-resolution output, and burst capture for rapid sequences.

Optional HUD / UI Auto-Hiding ☑️
Automatically hide selected UI elements during capture, making Screenshot+ ideal for trailers, promotional images, and cinematic presentations.

Built-In Capture Feedback ☑️
Clear success or error popup notifications ensure you always know whether a screenshot was saved correctly.

Configurable Settings Asset ☑️
All behavior is driven by a dedicated settings asset, allowing easy reuse, tuning, and of course; clean project organization.

Editor Integration ☑️
Includes editor menu actions and inspector utilities for quick testing, capture triggering, and easy access to the save directory.

Input System Support ☑️
Compatible with Unity’s new Input System, with optional support for classic input workflows.

Cross-Platform Saving ☑️
Screenshots are saved automatically using platform-appropriate paths, supporting Windows, macOS, and Linux.

Usage:

0. Import the Screenshot+ package into your project.

1. Add the ScreenshotSystem component to a GameObject.

2. Create and assign a ScreenshotSettings asset.

3. Configure capture behavior in the Inspector.

By default, screenshots are saved to:

Users/Pictures/<YourFolderName>/Screenshot_YYYY-MM-DD_HH-MM-SS.png

Recommended Unity Version:

Unity 2022 or higher!

Works on both Input Systems!

But the latest one is always recommended!

Have feature ideas? Need help?

You're welcome to join my Discord!

📄 Documentation:
Full integration and setup details are included in the Documentation pdf located inside the NumberSequenceGameTemplate/Documentation folder.

📄 Font Information:
This asset uses Unity’s default Arial font, which is included with Unity and does not require any third-party licensing.

📄 Audio Information:
No background music or sound effects are included in this package.
However, the SoundManager system and functions are already integrated — you can easily assign your own audio clips following the steps described in the Documentation pdf.

Join our community on Discord for support.

This Template includes:

• Level-based gameplay
• Simple customization options
• Ready-to-play demo scene

✅ Ready-to-Play Game Template

Import, play, and start customizing immediately.

✅ Level System Included

Comes with a working Level Manager to easily add or modify levels.

✅ Audio Integration

Includes a ready-to-use Sound Manager — easily replace or assign your own music and effects.

✅ Full Scene Setup

Demo scene and prefabs are provided to help you quickly integrate the system into your own game.

🧱 Included Folders

Assets/

└── NumberSequenceGameTemplate/

├── Scenes/

├── Scripts/

├── UI/

├── Prefabs/

└── Documentation/

🎨 Customization

• Assets/NumberSequenceGameTemplate/UI/Change UI elements, background, fonts, and button styles under:
  
• Adjust box count and layout under GridGenerator to set difficulty.
• Number Sequence Game Template/SoundManager/Music/Sound/Add your own sound effects in:
  

💬 Support

For bug reports, feature requests, or technical assistance:

📧 nexaframeproduction@gmail.com

❤️ Thank You

Thank you for choosing Number Sequence Game Template by NexaFrame Production!

Your feedback and reviews help us improve and build more high-quality Unity assets.

Category: Tools / Editor Extensions

Unity Version: 2022.3 or higher

Supported Editor Versions: 2022.3 LTS – 2025.x

Supported Platforms: Windows, macOS

Dependencies: None

Key Features

• One-click scene switching from the Unity toolbar
• Favorites system with persistent storage
• Build Settings integration (add, remove, reorder scenes)
• Drag-and-drop scene ordering
• Scene caching (file size, last access, access count)
• Automatic preloading for favorite scenes
• Compact Mode for small screens
• Toolbar alignment: Left, Center, or Right
• Modern, minimal UI styled for Unity Dark/Light themes
• Non-intrusive, zero-setup workflow
• Editor-only — does not affect builds

Included Contents

• ToolbarCallback.csC# Scripts (Editor Only):
  SceneToolbar.cs
  SceneDropdownWindow.cs
  SceneCacheManager.cs
  SceneToolbarTheme.cs
  
• README.md
• Documentation.pdf
  
• Replaceable toolbar logo (PNG)Branding Assets:
  

Performance

• Event-driven design with no per-frame overhead
• Lightweight reflection used only during toolbar injection
• Optimized IMGUI drawing
• Cache capped for predictable memory usage

Limitations

• Only scenes included in Build Settings are displayed
• Editor-only tool (not included in runtime builds)

JQ Scene Toolbar is a powerful yet minimal Unity Editor extension that redefines how you manage scenes.

With one click, you can switch between scenes, mark your most-used ones as favorites, and monitor performance with a real-time cache system all from a polished, compact toolbar next to your Play buttons.

Whether you’re building prototypes, large projects, or multiplayer worlds, this tool keeps your workflow efficient and visually refined.

Highlights

• Quick Scene Switching: Open scenes instantly from Build Settings.
• Favorites System: Pin your most-used scenes for faster access.
• Scene Cache Manager: Tracks access counts and preloads frequently used scenes.
• Compact Mode: Save screen space with a minimal layout.
• Toolbar Pinning: Choose to place the toolbar on the left or right of Unity’s editor bar.
• Toast Notifications: Receive modern pop-ups when loading or favoriting scenes.
• Persistent Preferences: Keeps your layout and favorites saved automatically.
• One-Click Add to Build Settings: Add missing scenes right from the toolbar.

Texture dimensions:1024X1024

Number of textures:46

Rigging:Yes

Characters (x6)

Archer,Barbarrian,Crusader,Priest,Saman,Sniper

texture size：1024 x 1024

Number of texture map：Archer（10），Barbarrian（8）,Crusader（8）,Priest（6）,

Saman（8）,Sniper（5）

Material is using URP Toon Shader

Polycount:

Characters

Archer: 2724 triangles

Barbarrian: 2764 triangles

Crusader: 2852 triangles

Priest: 2988 triangles

Saman: 2709 triangles

Sniper: 2987 triangles

Rigging:Yes

Animation Type: Generic

Animations

Archer:

Archer_attack

Archer_die

Archer_hit

Archer_idle

Archer_walk

Barbarrian:

Barbarrian_attack

Barbarrian_die

Barbarrian_hit

Barbarrian_idle

Barbarrian_walk

Crusader:

Crusader_attack

Crusader_die

Crusader_hit

Crusader_idle

Crusader_walk

Priest:

Priest_attack

Priest_die

Priest_hit

Priest_idle

Priest_walk

Saman:

Saman_attack

Saman_die

Saman_hit

Saman_idle

Saman_walk

Sniper:

Sniper_attack

Sniper_die

Sniper_hit

Sniper_idle

Sniper_walk

● Key Features

  Visual Organization

  - Color-coded row backgrounds with automatic rules

  - 4 separator styles (Classic, Bubble, Underline, Left-Aligned)

  - Component icons with click-to-edit

  - Tree lines in Professional view mode

  - Prefab status indicators (overrides, variants, missing)

  - Zebra striping (alternating row colors)

  - Depth-based coloring (Rainbow, Gradient, Monochrome)

  Productivity Tools

  - Favorites system with persistent stars (F5)

  - Bookmarks with hotkeys (Ctrl+1-9)

  - Advanced search by name, tag, layer, component

  - Selection history navigation (Alt+Left/Right)

  - Batch rename with patterns ({name}, {index}, {parent})

  - Object statistics (vertex/triangle counts)

  - Save/load view presets

  Quick Access

  - Alt+Click instant style popup

  - Visibility toggle (eye icon)

  - Lock toggle (padlock icon)

  - Child count, tag, and layer badges

  Configuration

  - Project Settings integration

  - JSON import/export for teams

  - Per-object control via HierarchyLabel component

  - 3 view modes (Default, Professional, Minimal)

  Performance

  - Tested with 5000+ objects

  - 0ms hierarchy repaint

  - Editor-only (zero runtime overhead)

  - All render pipelines supported

Hierarchy Pro Lite is an editor productivity tool, not game content. It enhances Unity's Hierarchy window to help

  you organize and navigate scenes faster.

  Is it customizable?

  Yes, fully:

  - Create your own color rules (by name, tag, layer, component)

  - Define custom icon mappings

  - Choose from 4 separator styles

  - 3 view modes (Default, Professional, Minimal)

  - Save/load presets for different workflows

  - Per-object overrides via HierarchyLabel component

  - Import/export settings as JSON for team sharing

  Genre/project suitability:

  Works with any project type:

  - 2D or 3D games

  - VR/AR applications

  - Architectural visualization

  - Simulations

  - Mobile, console, or PC

  - Any render pipeline (Built-in, URP, HDRP)

  Who benefits most:

  - Projects with 100+ scene objects

  - Teams needing consistent organization

  - Developers managing multiple scenes

  - Anyone tired of scrolling through cluttered hierarchies

  What it's NOT:

  - Not a runtime asset (no scripts in builds)

  - Not art, audio, or game content

  - Not tied to any specific genre or template

  Bottom line: If you use Unity's Hierarchy window, this tool makes it better—regardless of what you're building.

Color Atlas Texture Workflow 2048x2048px

Number of polygons: 1.179

Number of triangles: 1.833

Number of meshes: 13

Rigging: No

UV mapping: Yes

VR/AR ready low poly model

3D Low Poly Nature Packs Free is a lightweight and stylized environment asset pack designed for game developers seeking a charming and optimized nature setting. This free pack includes a variety of trees, rocks, bushes, and ground elements, all created in a clean low poly style ideal for mobile and indie games.
Perfect for prototyping or enhancing your scenes with a minimal, colorful aesthetic. Compatible with URP and built for performance.

Features:

-Stylized low poly models

-Trees, rocks, plants, and ground assets

-Mobile and performance-friendly

-Ideal for casual, adventure, or simulation games

-Easy drag-and-drop prefabs

Technical details

• Models: 20
• Tris: 179.9k
• Number of textures: 549
• Texture dimensions: 16x16 - 1024
• Animations: Yes
• Animation count: 19

Voxel Dungeon Pack: Unearth Ancient Evils with Animated Voxel Assets

Delve into the shadowy depths with our Voxel Dungeon Pack! This comprehensive collection features 20 meticulously crafted modular voxel models, including animated elements, designed to help you construct formidable and atmospheric dungeon environments for your games and projects.

Key Features:

• Diverse Dungeon Assets: A rich selection of structural elements, magical artifacts to build complex and engaging dungeons.
• Animated Elements: Bring your dungeon to life with interactive animations for gates and levers, adding dynamic gameplay and visual interest.
• Low-Poly Voxel Art: Optimized for smooth performance, these models maintain a consistent, stylized aesthetic perfect for any voxel-based adventure.
• Ready to Use: Seamlessly integrate these pre-made models into your Unity project.

Models Included (x20):

• Gate Lever (animated)
• Pillars (x2)
• Walls (x3)
• Magic Stones (x3)
• Lich Stone Cauldron
• Spawn Points (x2)
• Gates (x3, some animated)
• Stone Pit
• Stone Portal
• Stone Statues (x2)
• Skeleton in Cage

Construct dark labyrinths and thrilling challenges in your voxel world with our Voxel Dungeon Pack!

---------------------------- Voxel Collection Pack ----------------------------

• Characters Pack
• Farm Animals Pack
• African Animals Pack
• Forest Animals Pack
• Arctic Animals Pack
• Jungle Animals Pack
• Desert Animals Pack
• Birds Animals Pack
• Dinosaurs Pack
• Ocean Animals Pack
• Mythical Creatures Pack
• Props Pack
• Trees Pack
• Plants Pack
• Traps Pack
• Modular Houses Pack
• Weapons Pack
• Shields Pack

Follow us for updates, previews & tutorials:

FACEBOOK | YOUTUBE | TWITTER | INSTAGRAM | WEBSITE

• Scripts (.cs): 3

• Shaders (.shader): 2

• Textures (.png/.jpg/.tga/.exr): 11

• Materials (.mat): 5

• Scriptable assets (.asset): 6

• Scene files (.unity): 1

• Documentation (.pdf): 1

The Fire - Burning Camera Effect is a fully customizable visual effect designed for Unity that simulates intense, dynamic fire burning across the screen. Originally crafted to give players the feeling that they themselves are catching fire, this asset can be pushed far beyond its core use case. With a wide range of tweakable settings, including fire intensity, burn spread, distortion, heat haze, smoke overlays, and screen warping, you can sculpt exactly the atmosphere you need, whether it’s a hellish environment, a meltdown effect, a supernatural possession, or even abstract visual art.

This is not a one-trick effect. It’s a powerful, flexible tool that can be used creatively new artistic directions. Whether you're aiming for subtle screen heat or total apocalyptic flames, Fire - Burning Camera Effect gives you full control to go beyond the fire.